-
+
@@ -330,6 +330,7 @@ output" style="pointer-events: none;" class="inline"/>
+
constexpr uint32_t N
A struct to represent sparse table for min() as their invariant function, for the given array A....
Definition: sparse_table.cpp:47
int save_nd_data(const char *fname, const std::vector< std::valarray< double >> &X)
Definition: kohonen_som_trace.cpp:58
double _random(double a, double b)
Definition: kohonen_som_topology.cpp:53
void test_circle(std::vector< std::valarray< double >> *data)
Definition: kohonen_som_trace.cpp:196
@@ -372,7 +373,7 @@ Here is the call graph for this function:
-
+
@@ -437,7 +438,7 @@ Here is the call graph for this function:
-
+
@@ -508,7 +509,7 @@ Here is the call graph for this function:
-
360 const int N =
data ->size();
+
360 const int N =
data ->size();
361 const double R = 0.1;
363 const int num_classes = 8;
@@ -527,7 +528,7 @@ Here is the call graph for this function:
379 for (i = 0; i < N; i++) {
379 for (i = 0; i <
N ; i++) {
-
197 const int N =
data ->size();
+
197 const int N =
data ->size();
198 const double R = 0.75, dr = 0.3;
199 double a_t = 0., b_t = 2.f * M_PI;
200 double a_r = R - dr, b_r = R + dr;
@@ -588,7 +589,7 @@ Here is the call graph for this function:
206 for (i = 0; i < N; i++) {
206 for (i = 0; i <
N ; i++) {
208 double theta =
_random (a_t, b_t);
209 data [0][i][0] = r *
cos (theta);
-
278 const int N =
data ->size();
+
278 const int N =
data ->size();
279 const double dr = 0.2;
-
285 for (i = 0; i < N; i++) {
+
285 for (i = 0; i <
N ; i++) {
288 double theta =
_random (0, M_PI);
diff --git a/d9/d49/kohonen__som__trace_8cpp_a0283886819c7c140a023582b7269e2d0_cgraph.svg b/d9/d49/kohonen__som__trace_8cpp_a0283886819c7c140a023582b7269e2d0_cgraph.svg
index 5ebe47062..23b13cf65 100644
--- a/d9/d49/kohonen__som__trace_8cpp_a0283886819c7c140a023582b7269e2d0_cgraph.svg
+++ b/d9/d49/kohonen__som__trace_8cpp_a0283886819c7c140a023582b7269e2d0_cgraph.svg
@@ -1,7 +1,7 @@
-
diff --git a/d9/d49/kohonen__som__trace_8cpp_a0283886819c7c140a023582b7269e2d0_cgraph_org.svg b/d9/d49/kohonen__som__trace_8cpp_a0283886819c7c140a023582b7269e2d0_cgraph_org.svg
index f2e240142..c6f4883ac 100644
--- a/d9/d49/kohonen__som__trace_8cpp_a0283886819c7c140a023582b7269e2d0_cgraph_org.svg
+++ b/d9/d49/kohonen__som__trace_8cpp_a0283886819c7c140a023582b7269e2d0_cgraph_org.svg
@@ -1,7 +1,7 @@
-
-
diff --git a/d9/d49/kohonen__som__trace_8cpp_a1440a7779ac56f47a3f355ce4a8c7da0_cgraph_org.svg b/d9/d49/kohonen__som__trace_8cpp_a1440a7779ac56f47a3f355ce4a8c7da0_cgraph_org.svg
index 168362ec7..63f8b25d5 100644
--- a/d9/d49/kohonen__som__trace_8cpp_a1440a7779ac56f47a3f355ce4a8c7da0_cgraph_org.svg
+++ b/d9/d49/kohonen__som__trace_8cpp_a1440a7779ac56f47a3f355ce4a8c7da0_cgraph_org.svg
@@ -1,7 +1,7 @@
-
-
diff --git a/d9/d49/kohonen__som__trace_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph_org.svg b/d9/d49/kohonen__som__trace_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph_org.svg
index b7842cca2..8b531669d 100644
--- a/d9/d49/kohonen__som__trace_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph_org.svg
+++ b/d9/d49/kohonen__som__trace_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph_org.svg
@@ -1,7 +1,7 @@
-
-
-
diff --git a/d9/d49/kohonen__som__trace_8cpp_a6d0455dd5c30adda100e95f0423c786e_cgraph_org.svg b/d9/d49/kohonen__som__trace_8cpp_a6d0455dd5c30adda100e95f0423c786e_cgraph_org.svg
index 22293d66c..926132eba 100644
--- a/d9/d49/kohonen__som__trace_8cpp_a6d0455dd5c30adda100e95f0423c786e_cgraph_org.svg
+++ b/d9/d49/kohonen__som__trace_8cpp_a6d0455dd5c30adda100e95f0423c786e_cgraph_org.svg
@@ -1,7 +1,7 @@
-
-
-
-
-
-
Range queries using sparse-tables.
+
Functions for Implementation of Sparse Table
More...
-
Range queries using sparse-tables.
+
Functions for Implementation of Sparse Table
+
Range queries using sparse-tables.
-
-
+
-
110 for (
int i = 0; i < N; i++) {
+
110 for (
int i = 0; i <
N ; i++) {
@@ -247,6 +247,7 @@ Here is the call graph for this function:
+constexpr uint32_t N
A struct to represent sparse table for min() as their invariant function, for the given array A....
Definition: sparse_table.cpp:47
uint64_t result(uint64_t n)
Definition: fibonacci_sum.cpp:76
-
-
-
-
-
-
-
+
+
+std::is_unsigned< uint128_t >
+
+Node1
+
+std::is_unsigned< uint128_t >
+
+
+
+
+Node2
+
+std::true_type
+
+
+
+
+Node2->Node1
+
+
+
diff --git a/d9/d88/palindrome__partitioning_8cpp__incl.svg b/d9/d88/palindrome__partitioning_8cpp__incl.svg
index b81f88ba1..19d689f52 100644
--- a/d9/d88/palindrome__partitioning_8cpp__incl.svg
+++ b/d9/d88/palindrome__partitioning_8cpp__incl.svg
@@ -1,7 +1,7 @@
-
-
-
-
-
-
-
-
+
+
+Algorithms_in_C++: base64_encoding Namespace Reference
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Functions for Base64 Encoding and Decoding implementation.
+More...
+
+
Functions for Base64 Encoding and Decoding implementation.
+
+
+
+
+Algorithms_in_C++: linear_recurrence_matrix Namespace Reference
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Functions for Linear Recurrence Matrix implementation.
+More...
+
+
Functions for Linear Recurrence Matrix implementation.
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+ciphers/uint128_t.hpp
+
+Node1
+
+ciphers/uint128_t.hpp
+
+
+
+
+Node2
+
+algorithm
+
+
+
+
+Node1->Node2
+
+
+
+Node3
+
+ostream
+
+
+
+
+Node1->Node3
+
+
+
+Node4
+
+string
+
+
+
+
+Node1->Node4
+
+
+
+Node5
+
+utility
+
+
+
+
+Node1->Node5
+
+
+
diff --git a/da/d01/rat__maze_8cpp__incl.svg b/da/d01/rat__maze_8cpp__incl.svg
index 13ec8367f..fa68ab815 100644
--- a/da/d01/rat__maze_8cpp__incl.svg
+++ b/da/d01/rat__maze_8cpp__incl.svg
@@ -1,7 +1,7 @@
-
+
+
+Algorithms_in_C++: machine_learning::aystar_search::AyStarSearch< Puzzle > Class Template Reference
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
A class defining A* search algorithm . for some initial state and final state.
+ More...
+
+
+
+
+
template<typename Puzzle>
+
+
A class defining A* search algorithm . for some initial state and final state.
+
AyStarSearch class is defined as the informed search algorithm that is formulated in terms of weighted graphs: starting from a specific starting node of a graph (initial state), it aims to find a path to the given goal node having the smallest cost (least distance travelled, shortest time, etc.) The weighted edges (or cost) is evaluated on two factors, G score (cost required from starting node or initial state to current state) and H score (cost required from current state to final state). The F(state), then is evaluated as: F(state) = G(state) + H(state). The best search would be the final state having minimum F(state) value
Template Parameters
+
+ Puzzle denotes the puzzle or problem involving initial state and final state to be solved by A* search.
+
+
+
Note 1. The algorithm is referred from pesudocode from Wikipedia page as is.
+For AyStarSearch <, ==, and <=) b. generate_possible_moves()
+
+
+
+
+
◆
+
+
+
+
+template<typename Puzzle >
+
+
+
+
Parameterized constructor for AyStarSearch .
+
Parameters
+
+ initial denoting initial state of the puzzle final denoting final state of the puzzle
+
+
+
+
382 Initial =
Info (initial);
+
+
+
struct machine_learning::aystar_search::AyStarSearch::Info Info
Struct that handles all the information related to the current state.
+
+
+
+
+
+
◆
+
+
+
+
+template<typename Puzzle >
+
+
+
Main algorithm for finding FinalState, given the InitialState
Parameters
+
+ dist the heuristic finction, defined by the user permissible_depth the depth at which the A* search discards searching for solution
+
+
+
Returns List of moves from Final state to initial state, if evaluated, else returns an empty array
+
Stores the parent of the states
+
Stores the g_score
+
Stores the list to explore
+
Stores the list that are explored
+
+
+
+
+
+
+
+
+
+
+
+
+
432 parent_of[Initial] =
nullptr ;
+
433 g_score[Initial] = 0;
+
+
435 while (!open_list.
empty ()) {
+
+
+
+
439 uint32_t min_f_score = 1e9;
+
440 for (
auto iter = open_list.
begin (); iter != open_list.
end ();
+
+
+
+
444 uint32_t f_score = iter->heuristic_value + iter->depth;
+
445 if (f_score < min_f_score) {
+
446 min_f_score = f_score;
+
447 it_low_f_score = iter;
+
+
+
+
+
452 Info *current_state =
new Info (*it_low_f_score);
+
+
+
455 if (current_state->state == Final.state) {
+
456 return Solution (current_state, parent_of);
+
+
+
459 open_list.
erase (it_low_f_score);
+
+
+
462 if (current_state->depth >= permissible_depth) {
+
+
+
+
+
+
468 current_state->state.generate_possible_moves();
+
+
470 for (Puzzle &neighbor : total_possible_moves) {
+
+
+
473 Info Neighbor = {neighbor, dist(neighbor, Final.state),
+
474 current_state->depth + 1};
+
475 uint32_t temp_g_score = Neighbor.depth;
+
+
+
+
+
480 auto closed_list_iter = closed_list.
find (Neighbor);
+
481 if (closed_list_iter != closed_list.
end ()) {
+
+
+
+
485 if (Neighbor.depth < closed_list_iter->depth) {
+
486 closed_list.
erase (closed_list_iter);
+
+
+
+
+
491 auto neighbor_g_score_iter = g_score.
find (Neighbor);
+
+
+
494 if (neighbor_g_score_iter != g_score.
end ()) {
+
495 if (neighbor_g_score_iter->second > temp_g_score) {
+
496 neighbor_g_score_iter->second = temp_g_score;
+
497 parent_of[Neighbor] = current_state;
+
+
+
500 g_score[Neighbor] = temp_g_score;
+
501 parent_of[Neighbor] = current_state;
+
+
+
+
+
506 auto iter = open_list.
find (Neighbor);
+
507 if (iter == open_list.
end ()) {
+
+
509 }
else if (iter->depth > Neighbor.depth) {
+
510 open_list.
erase (iter);
+
+
+
+
514 closed_list.
emplace (*current_state);
+
+
+
+
+
+
std::vector< Puzzle > Solution(Info *FinalState, const std::map< Info, Info *, comparison_operator > &parent_of)
A helper solution: launches when a solution for AyStarSearch is found.
Definition: a_star_search.cpp:394
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
◆
+
+
+
+
+template<typename Puzzle >
+
+
+
+
A helper solution: launches when a solution for AyStarSearch is found.
+
Parameters
+
+ FinalState the pointer to the obtained final state parent_of the list of all parents of nodes stored during A* search
+
+
+
Returns the list of moves denoting moves from final state to initial state (in reverse)
+
+
+
398 Info *current_state = FinalState;
+
+
+
+
+
+
404 while (current_state !=
nullptr ) {
+
+
406 current_state = parent_of.
find (*current_state)->second;
+
+
+
+
T emplace_back(T... args)
+
+
+
+
+
+
The documentation for this class was generated from the following file:
+machine_learning/a_star_search.cpp
+
+
+
+
diff --git a/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a5bb772fd41005fdefa8bd32edbf00cc3_cgraph.md5 b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a5bb772fd41005fdefa8bd32edbf00cc3_cgraph.md5
new file mode 100644
index 000000000..71cb66771
--- /dev/null
+++ b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a5bb772fd41005fdefa8bd32edbf00cc3_cgraph.md5
@@ -0,0 +1 @@
+8c8c45c919edf5999cede22373099e4c
\ No newline at end of file
diff --git a/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a5bb772fd41005fdefa8bd32edbf00cc3_cgraph.svg b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a5bb772fd41005fdefa8bd32edbf00cc3_cgraph.svg
new file mode 100644
index 000000000..9e815c1e9
--- /dev/null
+++ b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a5bb772fd41005fdefa8bd32edbf00cc3_cgraph.svg
@@ -0,0 +1,182 @@
+
+
+
+
+
+
+machine_learning::aystar_search::AyStarSearch::a_star_search
+
+Node1
+
+machine_learning::aystar
+_search::AyStarSearch::
+a_star_search
+
+
+
+
+Node2
+
+std::set::begin
+
+
+
+
+Node1->Node2
+
+
+
+Node3
+
+std::set::emplace
+
+
+
+
+Node1->Node3
+
+
+
+Node4
+
+std::set::empty
+
+
+
+
+Node1->Node4
+
+
+
+Node5
+
+std::map::end
+
+
+
+
+Node1->Node5
+
+
+
+Node6
+
+std::set::end
+
+
+
+
+Node1->Node6
+
+
+
+Node7
+
+std::set::erase
+
+
+
+
+Node1->Node7
+
+
+
+Node8
+
+std::map::find
+
+
+
+
+Node1->Node8
+
+
+
+Node9
+
+std::set::find
+
+
+
+
+Node1->Node9
+
+
+
+Node10
+
+machine_learning::aystar
+_search::AyStarSearch::
+Solution
+
+
+
+
+Node1->Node10
+
+
+
+Node10->Node8
+
+
+
+Node11
+
+std::vector::emplace_back
+
+
+
+
+Node10->Node11
+
+
+
diff --git a/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.map b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.map
new file mode 100644
index 000000000..7fec55504
--- /dev/null
+++ b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.map
@@ -0,0 +1,5 @@
+
+
diff --git a/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.md5 b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.md5
new file mode 100644
index 000000000..dbee2f9c2
--- /dev/null
+++ b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.md5
@@ -0,0 +1 @@
+fa104f62e0167a8f92371e84db46bd57
\ No newline at end of file
diff --git a/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.svg b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.svg
new file mode 100644
index 000000000..e3c8b6699
--- /dev/null
+++ b/da/d02/classmachine__learning_1_1aystar__search_1_1_ay_star_search_a8687882bdb604ab367da6e8fe42a35c9_cgraph.svg
@@ -0,0 +1,54 @@
+
+
+
+
+
+
+machine_learning::aystar_search::AyStarSearch::Solution
+
+Node1
+
+machine_learning::aystar
+_search::AyStarSearch::
+Solution
+
+
+
+
+Node2
+
+std::vector::emplace_back
+
+
+
+
+Node1->Node2
+
+
+
+Node3
+
+std::map::find
+
+
+
+
+Node1->Node3
+
+
+
diff --git a/da/d24/sqrt__double_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/da/d24/sqrt__double_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
index 288ae6def..cb855703a 100644
--- a/da/d24/sqrt__double_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
+++ b/da/d24/sqrt__double_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg
@@ -1,7 +1,7 @@
-
-
+
+
+data_structures::trie_using_hashmap::Trie
+
+Node1
+
+data_structures::trie
+_using_hashmap::Trie
+
+
+
+
+Node2
+
+std::shared_ptr< data
+_structures::trie_using
+_hashmap::Trie::Node >
+
+
+
+
+Node2->Node1
+ root_node
+
+
+
diff --git a/da/d35/sieve__of__eratosthenes_8cpp__incl.svg b/da/d35/sieve__of__eratosthenes_8cpp__incl.svg
index c8b581370..3257b8578 100644
--- a/da/d35/sieve__of__eratosthenes_8cpp__incl.svg
+++ b/da/d35/sieve__of__eratosthenes_8cpp__incl.svg
@@ -1,7 +1,7 @@
-
+
+
+Algorithms_in_C++: data_structures::sparse_table::Sparse_table Struct Reference
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+int64_t query (int64_t l, int64_t r) Queries the sparse table for the value of the interval l, r . More...
+n = 0 size of input array. std::array < int64_t, N > A = {} input array to perform RMQ. More... std::array < std::array < int64_t, N >, M > ST {} the sparse table storing min() std::array < int64_t, N > LOG = {} where floor(log2(i)) are precomputed.
+
+
+
◆
+
+
+
+
+
+
+
+
+ int64_t data_structures::sparse_table::Sparse_table::query
+ (
+ int64_t
+ l ,
+
+ int64_t
+ r
+
+ )
+
+
+
+
+inline
+
+
+
+
+
Queries the sparse table for the value of the interval l, r .
+
Parameters
+
+ l the left index of the range (inclusive). r the right index of the range (inclusive).
+
+
+
Returns the computed value of the given interval. @complexity: O(1)
+
< smallest power of 2 covering [l,r]
+
< represents minimum value over the range [g,l]
+
< represents minimum value over the range [g, r - pow(2,g) + 1]
+
< represents minimum value over the whole range [l,r]
+
+
110 int64_t g =
LOG [r - l + 1];
+
111 int64_t x =
ST [g][l];
+
+
+
114 ST [g][r - (1 << g) + 1];
+
+
+
117 return (
A [x] <=
A [y] ? x : y);
+
+
+
std::array< int64_t, N > LOG
where floor(log2(i)) are precomputed.
Definition: sparse_table.cpp:59
+
std::array< int64_t, N > A
input array to perform RMQ.
Definition: sparse_table.cpp:56
+
std::array< std::array< int64_t, N >, M > ST
the sparse table storing min() values for given interval.
Definition: sparse_table.cpp:58
+
+
+
+
+
+
+
+
+
+
+
+ std::array <int64_t, N> data_structures::sparse_table::Sparse_table::A = {}
+
+
+
+
input array to perform RMQ.
+
Warning check if N is not less than n. if so, manually increase the value of N
+
+
+
+
The documentation for this struct was generated from the following file:
+
+
Algorithms_in_C++: ciphers/uint128_t.hpp File Reference
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#include <algorithm>#include <ostream>#include <string>#include <utility>
+
Go to the source code of this file.
+
+std::string add (const std::string &first, const std::string &second) Adding two string. More... uint128_t operator+ (const T &p, const uint128_t &q) uint128_t operator- (const T p, const uint128_t &q) uint128_t operator* (const T p, const uint128_t &q) uint128_t operator/ (const T p, const uint128_t &q) uint128_t operator% (const T p, const uint128_t &q) uint128_t operator& (const T &p, const uint128_t &q) uint128_t operator| (const T p, const uint128_t &q) uint128_t operator^ (const T p, const uint128_t &q) bool operator&& (const T p, const uint128_t &q) bool operator|| (const T p, const uint128_t &q) bool operator== (const T p, const uint128_t &q) bool operator!= (const T p, const uint128_t &q) bool operator< (const T p, const uint128_t &q) bool operator<= (const T p, const uint128_t &q) bool operator> (const T p, const uint128_t &q) bool operator>= (const T p, const uint128_t &q)
+
+
Implementation of 128-bit unsigned integers.
Note The implementation can be flagged as not completed. This header is used with enough operations as a part of bigger integer types 256-bit integer.
+
Author Ashish Daulatabad
+
+
+
◆
+
+
+
+
+
+ #define CIPHERS_UINT128_T_HPP_
+
+
+
+
+
+
+
◆
+
+
+
+
+
Adding two string.
+
Adds two long integer, only used for printing numbers
Parameters
+
+ first First integer string second Second integer string
+
+
+
Returns string denoting the addition of both the strings
+
+
+
39 int16_t
sum = 0, carry = 0;
+
40 for (int32_t i =
static_cast< int32_t
> (first.
size ()) - 1,
+
41 j =
static_cast< int32_t
> (second.
size ()) - 1;
+
42 i >= 0 || j >= 0; --i, --j) {
+
43 sum = ((i >= 0 ? first[i] -
'0' : 0) + (j >= 0 ? second[j] -
'0' : 0) +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
T sum(const std::vector< std::valarray< T >> &A)
Definition: vector_ops.hpp:232
+
+
+
+
+
+
+
+
+
+
+
diff --git a/da/d41/uint128__t_8hpp_a3ff77262ffd6743df5b808d41382a6f3_cgraph.md5 b/da/d41/uint128__t_8hpp_a3ff77262ffd6743df5b808d41382a6f3_cgraph.md5
new file mode 100644
index 000000000..3060e0f84
--- /dev/null
+++ b/da/d41/uint128__t_8hpp_a3ff77262ffd6743df5b808d41382a6f3_cgraph.md5
@@ -0,0 +1 @@
+0488c28a4644dd1c1998315f301235f8
\ No newline at end of file
diff --git a/da/d41/uint128__t_8hpp_a3ff77262ffd6743df5b808d41382a6f3_cgraph.svg b/da/d41/uint128__t_8hpp_a3ff77262ffd6743df5b808d41382a6f3_cgraph.svg
new file mode 100644
index 000000000..e112e982d
--- /dev/null
+++ b/da/d41/uint128__t_8hpp_a3ff77262ffd6743df5b808d41382a6f3_cgraph.svg
@@ -0,0 +1,112 @@
+
+
+
+
+
+
+add
+
+Node1
+
+add
+
+
+
+
+Node2
+
+std::string::begin
+
+
+
+
+Node1->Node2
+
+
+
+Node3
+
+std::string::end
+
+
+
+
+Node1->Node3
+
+
+
+Node4
+
+std::string::push_back
+
+
+
+
+Node1->Node4
+
+
+
+Node5
+
+std::reverse
+
+
+
+
+Node1->Node5
+
+
+
+Node6
+
+std::string::size
+
+
+
+
+Node1->Node6
+
+
+
+Node7
+
+machine_learning::sum
+
+
+
+
+Node1->Node7
+
+
+
diff --git a/da/d41/uint128__t_8hpp_source.html b/da/d41/uint128__t_8hpp_source.html
new file mode 100644
index 000000000..5772532ad
--- /dev/null
+++ b/da/d41/uint128__t_8hpp_source.html
@@ -0,0 +1,1311 @@
+
+
+
+Algorithms_in_C++: ciphers/uint128_t.hpp Source File
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Go to the documentation of this file.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
19 #ifndef CIPHERS_UINT128_T_HPP_
+
20 #define CIPHERS_UINT128_T_HPP_
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
39 int16_t
sum = 0, carry = 0;
+
40 for (int32_t i =
static_cast< int32_t
> (first.
size ()) - 1,
+
41 j =
static_cast< int32_t
> (second.
size ()) - 1;
+
42 i >= 0 || j >= 0; --i, --j) {
+
43 sum = ((i >= 0 ? first[i] -
'0' : 0) + (j >= 0 ? second[j] -
'0' : 0) +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
70 this->f = this->s = 0;
+
71 if (str.
size () > 1 && str[1] ==
'x' ) {
+
72 for (
auto i = 2; i < str.
size (); ++i) {
+
+
74 if (str[i] >=
'0' && str[i] <=
'9' ) {
+
75 *
this += (str[i] -
'0' );
+
76 }
else if (str[i] >=
'A' && str[i] <=
'F' ) {
+
77 *
this += (str[i] -
'A' + 10);
+
78 }
else if (str[i] >=
'a' && str[i] <=
'f' ) {
+
79 *
this += (str[i] -
'a' + 10);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
115 uint128_t (
const uint64_t high,
const uint64_t low) : f(high), s(low) {}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
142 return __builtin_clzll(f);
+
+
144 return 64 + __builtin_clzll(s);
+
+
+
147 _BitScanForward64(&r, f);
+
+
+
150 _BitScanForward64(&l, s);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
165 return __builtin_ctzll(f);
+
+
167 return 64 + __builtin_ctzll(s);
+
+
+
170 _BitScanReverse64(&r, s);
+
+
+
173 _BitScanReverse64(&l, f);
+
+
+
+
+
+
+
+
+
+
+
184 inline explicit operator bool()
const {
return (f || s); }
+
+
+
+
+
+
+
+
+
193 inline explicit operator T()
const {
+
194 return static_cast< T
> (s);
+
+
+
+
+
+
+
201 inline uint64_t
lower ()
const {
return s; }
+
+
+
+
+
+
207 inline uint64_t
upper ()
const {
return f; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
253 return uint128_t (f + (p + s < s), p + s);
+
+
+
+
+
+
+
+
+
262 return uint128_t (f + (p.s + s < s) + p.f, p.s + s);
+
+
+
+
+
+
+
+
+
+
+
+
274 bool app = p + s < s;
+
+
+
+
+
+
+
+
+
+
+
+
286 bool app = p.s + s < s;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
330 return uint128_t (f - p.f - app, s - p.s);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
402 uint64_t f_first = s >> 32, f_second = s & 0xFFFFFFFF,
+
403 s_first = p.s >> 32, s_second = p.s & 0xFFFFFFFF;
+
404 uint64_t fi = f_first * s_first, se = f_first * s_second,
+
405 th = s_first * f_second, fo = s_second * f_second;
+
406 uint64_t tmp = ((se & 0xFFFFFFFF) << 32), tmp2 = (th & 0xFFFFFFFF)
+
+
408 int cc = (tmp + tmp2 < tmp);
+
+
410 cc += (tmp + fo < tmp);
+
411 uint64_t carry = fi + (se >> 32) + (th >> 32);
+
412 return uint128_t (this->f * p.s + this->s * p.f + carry + cc, tmp + fo);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
434 uint64_t f_first = s >> 32, f_second = s & 0xFFFFFFFF,
+
435 s_first = p.s >> 32, s_second = p.s & 0xFFFFFFFF;
+
436 uint64_t fi = f_first * s_first, se = f_first * s_second,
+
437 th = s_first * f_second, fo = s_second * f_second;
+
438 uint64_t tmp = (se << 32), tmp2 = (th << 32);
+
439 int cc = (tmp + tmp2 < tmp);
+
+
441 cc += (tmp + fo < tmp);
+
442 uint64_t carry = fi + (se >> 32) + (th >> 32);
+
443 f = this->f * p.s + this->s * p.f + carry + cc;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
457 }
else if (*
this == p) {
+
+
+
+
461 uint16_t left = tmp.
_lez () -
_lez ();
+
+
+
+
465 while (left >= 0 && tmp2 >= p) {
+
466 uint16_t shf = tmp2._lez() - tmp.
_lez ();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
480 return {quotient << left, tmp2};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
575 return f < other.f || (f == other.f && s < other.s);
+
+
+
+
+
+
+
+
+
584 return f < other.f || (f == other.f && s <= other.s);
+
+
+
+
+
+
+
+
+
593 return f > other.f || (f == other.f && s > other.s);
+
+
+
+
+
+
+
+
+
602 return (f > other.f) || (f == other.f && s >= other.s);
+
+
+
+
+
+
+
+
+
611 return f == other.f && s == other.s;
+
+
+
+
+
+
+
+
+
620 return f != other.f || s != other.s;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
635 return (s || f) && (b.s || b.f);
+
+
+
+
+
+
+
+
+
644 return (s || f) || (b.s || b.f);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
734 return (f || s) && b;
+
+
+
+
+
+
+
+
+
+
+
+
+
747 return (f || s) || b;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
767 }
else if (p >= 64 && p <= 128) {
+
768 return uint128_t ((this->s << (p - 64)), 0);
+
769 }
else if (p < 64 && p > 0) {
+
770 return uint128_t ((this->f << p) + ((this->s >> (64 - p))),
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
786 if (p >= 64 && p <= 128) {
+
787 this->f = (this->s << (p - 64));
+
+
+
790 f = ((this->f << p) + (this->s >> (64 - p)));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
808 }
else if (p >= 64 && p <= 128) {
+
809 return uint128_t (0, (this->f >> (p - 64)));
+
810 }
else if (p < 64 && p > 0) {
+
+
812 (this->s >> p) + (this->f << (64 - p)));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
829 s = (this->f >> (p - 64));
+
+
831 s = (this->s >> p) + (this->f << (64 - p));
+
+
+
+
+
+
+
+
+
+
+
+
+
844 return uint128_t (this->f & p.f, this->s & p.s);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
902 return uint128_t (this->f | p.f, this->s | p.s);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
947 return uint128_t (this->f ^ p.f, this->s ^ p.s);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
988 for (
int i = 0; i < 64; ++i) {
+
989 if (p.s & (1LL << i)) {
+
+
+
+
+
994 for (
int i = 0; i < 64; ++i) {
+
995 if (p.f & (1LL << i)) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1059 inline bool operator&&(
const T p,
const uint128_t &q) {
+
+
+
+
+
+
1065 inline bool operator||(
const T p,
const uint128_t &q) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1084 inline bool operator<(
const T p,
const uint128_t &q) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
class for 128-bit unsigned integer
Definition: uint128_t.hpp:59
+
uint128_t operator-()
operator - using twos complement
Definition: uint128_t.hpp:337
+
bool operator&&(const T b)
operator && for other types
Definition: uint128_t.hpp:733
+
uint128_t(const std::string &str)
Parameterized constructor.
Definition: uint128_t.hpp:106
+
uint128_t operator+(const uint128_t &p)
operator + for uint128_t and other integer types.
Definition: uint128_t.hpp:261
+
uint128_t & operator+=(const uint128_t &p)
operator += for uint128_t
Definition: uint128_t.hpp:285
+
uint128_t operator<<(const T p)
operator << for uint128_t
Definition: uint128_t.hpp:764
+
bool operator<=(const uint128_t &other)
operator <= for uint128_t
Definition: uint128_t.hpp:583
+
uint128_t & operator|=(const T p)
operator |= for other types (bitwise operator)
Definition: uint128_t.hpp:924
+
uint64_t upper() const
returns upper 64-bit integer part
Definition: uint128_t.hpp:207
+
uint128_t & operator%=(const T &p)
operator %= for uint128_t
Definition: uint128_t.hpp:564
+
uint128_t & operator<<=(const T p)
operator <<= for uint128_t
Definition: uint128_t.hpp:784
+
uint128_t & operator&=(const T p)
operator &= for other types (bitwise operator)
Definition: uint128_t.hpp:879
+
bool operator>(const uint128_t &other)
operator > for uint128_t
Definition: uint128_t.hpp:592
+
uint128_t operator--(int p)
operator – (post-decrement)
Definition: uint128_t.hpp:352
+
uint128_t operator|(const uint128_t &p)
operator | for uint128_t (bitwise operator)
Definition: uint128_t.hpp:901
+
uint128_t operator/(const uint128_t &p)
operator / for uint128_t and other integer types.
Definition: uint128_t.hpp:488
+
bool operator||(const uint128_t &b)
operator || for uint128_t
Definition: uint128_t.hpp:643
+
bool operator>=(const T other)
operator >= for other types
Definition: uint128_t.hpp:697
+
uint128_t & operator++()
pre-increment operator
Definition: uint128_t.hpp:296
+
uint128_t operator|(const T p)
operator | for other types (bitwise operator)
Definition: uint128_t.hpp:892
+
~uint128_t()=default
Destructor for uint128_t.
+
uint128_t operator~()
operator ~ for uint128_t
Definition: uint128_t.hpp:754
+
uint128_t operator*(const uint128_t &p)
operator * for uint128_t and other integer types.
Definition: uint128_t.hpp:401
+
bool operator<=(const T other)
operator <= for other types
Definition: uint128_t.hpp:673
+
uint128_t operator*(const T p)
operator * for uint128_t and other integer types.
Definition: uint128_t.hpp:392
+
uint128_t & operator|=(const uint128_t &p)
operator |= for uint128_t (bitwise operator)
Definition: uint128_t.hpp:910
+
friend std::ostream & operator<<(std::ostream &op, const uint128_t &p)
operator << for printing uint128_t integer
Definition: uint128_t.hpp:983
+
uint128_t operator+(const T p)
operator + for uint128_t and other integer types.
Definition: uint128_t.hpp:252
+
bool operator<(const T other)
operator < for other types
Definition: uint128_t.hpp:661
+
uint128_t & operator&=(const uint128_t &p)
operator &= for uint128_t (bitwise operator)
Definition: uint128_t.hpp:865
+
uint128_t & operator%=(const uint128_t &p)
operator %= for uint128_t
Definition: uint128_t.hpp:551
+
uint128_t & operator/=(const uint128_t &p)
operator /= for uint128_t
Definition: uint128_t.hpp:509
+
uint128_t(const uint128_t &num)=default
Copy constructor.
+
uint128_t & operator^=(const T &p)
operator ^= for other types (bitwise operator)
Definition: uint128_t.hpp:969
+
uint128_t operator-(const T &p)
operator - for uint128_t and other integer types.
Definition: uint128_t.hpp:318
+
uint128_t operator>>(const T p)
operator >> for uint128_t
Definition: uint128_t.hpp:805
+
bool operator!=(const T other)
operator != for other types
Definition: uint128_t.hpp:721
+
bool operator==(const T other)
operator == for other types
Definition: uint128_t.hpp:709
+
bool operator==(const uint128_t &other)
operator == for uint128_t
Definition: uint128_t.hpp:610
+
uint32_t _trz()
Trailing zeroes in binary.
Definition: uint128_t.hpp:162
+
uint128_t(uint128_t &&num) noexcept
Move constructor.
Definition: uint128_t.hpp:127
+
bool operator||(const T b)
operator || for other types
Definition: uint128_t.hpp:746
+
uint128_t operator-(const uint128_t &p)
operator - for uint128_t
Definition: uint128_t.hpp:328
+
bool operator>(const T other)
operator > for other types
Definition: uint128_t.hpp:685
+
void __get_integer_from_string(const std::string &str)
First and second half of 128 bit number.
Definition: uint128_t.hpp:69
+
uint128_t & operator-=(const T &p)
operator -= for uint128_t and other integer types.
Definition: uint128_t.hpp:365
+
uint128_t operator^(const uint128_t &p)
operator ^ for uint128_t (bitwise operator)
Definition: uint128_t.hpp:946
+
uint128_t(const uint64_t high, const uint64_t low)
Parameterized constructor.
Definition: uint128_t.hpp:115
+
uint128_t & operator^=(const uint128_t &p)
operator ^= for uint128_t (bitwise operator)
Definition: uint128_t.hpp:955
+
uint128_t operator&(const T p)
operator & for other types (bitwise operator)
Definition: uint128_t.hpp:855
+
uint64_t lower() const
returns lower 64-bit integer part
Definition: uint128_t.hpp:201
+
uint128_t operator^(const T p)
operator ^ for other types (bitwise operator)
Definition: uint128_t.hpp:937
+
std::pair< uint128_t, uint128_t > divide(const uint128_t &p)
divide function for uint128_t and other integer types.
Definition: uint128_t.hpp:454
+
bool operator&&(const uint128_t &b)
operator && for uint128_t
Definition: uint128_t.hpp:634
+
bool operator!=(const uint128_t &other)
operator != for uint128_t
Definition: uint128_t.hpp:619
+
uint128_t & operator-=(const uint128_t &p)
operator -= for uint128_t
Definition: uint128_t.hpp:377
+
uint128_t operator%(const uint128_t &p)
operator % for uint128_t
Definition: uint128_t.hpp:532
+
bool operator<(const uint128_t &other)
operator < for uint128_t
Definition: uint128_t.hpp:574
+
uint128_t operator&(const uint128_t &p)
operator & for uint128_t (bitwise operator)
Definition: uint128_t.hpp:843
+
bool operator!()
operator ! for uint128_t
Definition: uint128_t.hpp:627
+
uint128_t & operator>>=(const T p)
operator >>= for uint128_t
Definition: uint128_t.hpp:825
+
uint128_t(T low)
Parameterized constructor.
Definition: uint128_t.hpp:100
+
uint128_t operator%(const T &p)
operator % for uint128_t and other integer types.
Definition: uint128_t.hpp:542
+
uint128_t & operator*=(const uint128_t &p)
operator *= for uint128_t and other integer types.
Definition: uint128_t.hpp:433
+
uint128_t & operator+=(const T p)
operator += for uint128_t and other integer types.
Definition: uint128_t.hpp:273
+
bool operator>=(const uint128_t &other)
operator >= for uint128_t
Definition: uint128_t.hpp:601
+
uint128_t & operator--()
operator – (pre-decrement)
Definition: uint128_t.hpp:343
+
uint128_t operator/(const T p)
operator / for uint128_t and other integer types.
Definition: uint128_t.hpp:498
+
uint32_t _lez()
Leading zeroes in binary.
Definition: uint128_t.hpp:139
+
uint128_t & operator*=(const T p)
operator *= for uint128_t and other integer types.
Definition: uint128_t.hpp:423
+
bool operator()()
operator () for uint128_t
Definition: uint128_t.hpp:651
+
uint128_t & operator=(const std::string &p)
operator = for type string
Definition: uint128_t.hpp:227
+
uint128_t operator++(int)
post-increment operator
Definition: uint128_t.hpp:305
+
uint128_t & operator=(uint128_t &&p)=default
Move assignment operator.
+
uint128_t & operator=(const uint128_t &p)=default
operator = for uint128_t
+
uint128_t & operator=(const T &p)
operator = for other types
Definition: uint128_t.hpp:217
+
uint128_t & operator/=(const T p)
operator /= for uint128_t and other integer types.
Definition: uint128_t.hpp:522
+
bool operator==(const Complex &a, const Complex &b)
Operator overload of '==' on Complex class. Logical Equal overload for our Complex class.
Definition: complex_numbers.cpp:175
+
+
+
+
+
+
+
T sum(const std::vector< std::valarray< T >> &A)
Definition: vector_ops.hpp:232
+
+
std::vector< float > operator/(std::vector< T > const &A, float const scalar)
Definition: ordinary_least_squares_regressor.cpp:174
+
std::vector< T > operator-(std::vector< T > const &A, std::vector< T > const &B)
Definition: ordinary_least_squares_regressor.cpp:183
+
std::vector< T > operator+(std::vector< T > const &A, std::vector< T > const &B)
Definition: ordinary_least_squares_regressor.cpp:204
+
+
+
+
+
std::string add(const std::string &first, const std::string &second)
Adding two string.
Definition: uint128_t.hpp:37
+
+
-
-
-
+
+
+Algorithms_in_C++: dynamic_programming/minimum_edit_distance.cpp File Reference
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Implementation of Minimum Edit Distance using Dynamic Programing.
+More...
+
#include <cassert>#include <iostream>#include <vector>
+
+
Implementation of Minimum Edit Distance using Dynamic Programing.
+
Given two strings str1 & str2 and we have to calculate the minimum number of operations (Insert, Remove, Replace) required to convert str1 to str2.
+
+
We will solve this problem using Naive recursion. But as we are approaching with a DP solution. So, we will take a DP array to store the solution of all sub-problems so that we don't have to perform recursion again and again. Now to solve the problem, We can traverse all characters from either right side of the strings or left side. Suppose we will do it from the right side. So, there are two possibilities for every pair of characters being traversed.
+If the last characters of two strings are the same, Ignore the characters and get the count for the remaining string. So, we get the solution for lengths m-1 and n-1 in a DP array.
+Else, (If last characters are not the same), we will consider all three operations (Insert, Remove, Replace) on the last character of the first string and compute the minimum cost for all three operations and take the minimum of three values in the DP array. For Insert: Recur for m and n-1 For Remove: Recur for for m-1 and n For Replace: Recur for for m-1 and n-1
+
+
Author Nirjas Jakilim
+
+
+
◆
+
+
+
+
+
+ uint64_t dynamic_programming::minimum_edit_distance::editDistDP
+ (
+ std::string str1 ,
+
+ std::string str2 ,
+
+ uint64_t
+ m ,
+
+ uint64_t
+ n
+
+ )
+
+
+
+
+
Calculates and stores the result of all the sub-problems, so that we don't have to recur to compute the minimum cost of a particular operation if it is already computed and stored in the dp vector.
+
Parameters
+
+ dp vector to store the computed minimum costs str1 to pass the 1st string str2 to pass the 2nd string m the length of str1 n the length of str2
+
+
+
Returns dp[m][n] the minimum cost of operations needed to convert str1 to str2
+
Create a table to store results of subproblems
+
creasting 2D vector dp to store the results of subproblems
+
Fill d[][] in bottom up manner
+
If first string is empty, only option is to insert all characters of second string
+
Minimum operations = j
+
If second string is empty, only option is to remove all characters of second string
+
Minimum operations = i
+
If last characters are same, ignore last char and recur for remaining string
+
If the last character is different, consider all possibilities and find the minimum
+
returning the minimum cost of operations needed to convert str1 to str2
+
+
+
+
+
+
93 for (uint64_t i = 0; i <= m; i++) {
+
94 for (uint64_t j = 0; j <= n; j++) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
109 else if (str1[i - 1] == str2[j - 1]) {
+
110 dp[i][j] = dp[i - 1][j - 1];
+
+
+
+
+
+
116 dp[i][j] = 1 +
min (dp[i][j - 1],
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
◆
+
+
+
+
+
+ int main
+ (
+ int
+ argc ,
+
+ char *
+ argv []
+
+ )
+
+
+
+
+
main function
+
Parameters
+
+ argc commandline argument count (ignored) argv commandline array of arguments (ignored)
+
+
+
Returns 0 on exit
+
+
+
+
+
static void test()
Self-test implementations.
Definition: minimum_edit_distance.cpp:132
+
+
+
+
+
+
+
◆
+
+
+
+
+
+ uint64_t dynamic_programming::minimum_edit_distance::min
+ (
+ uint64_t
+ x ,
+
+ uint64_t
+ y ,
+
+ uint64_t
+ z
+
+ )
+
+
+
+
+
Takes input of the cost of three operations: Insert, Replace and Delete and return the minimum cost among them.
+
Parameters
+
+ x used to pass minimum cost of Insert operations y used to pass minimum cost of Replace operations z used to pass minimum cost of Delete operations
+
+
+
Returns x if x is the minimum value
+
+y if y is the minimum value
+
+z if z is the minimum value
+
returns x, if x is the minimum value
+
returns y, if y is the minimum value
+
returns z if z is the minimum value
+
+
64 if (x <= y && x <= z) {
+
+
+
67 if (y <= x && y <= z) {
+
+
+
+
+
+
+
+
+
+
+
◆
+
+
+
+
+
+
+
+
+ static void test
+ (
+ )
+
+
+
+
+static
+
+
+
+
+
Self-test implementations.
+
Returns void
+
+
+
+
+
136 uint64_t expected_output1 = 5;
+
+
+
139 assert(output1 == expected_output1);
+
140 std::cout <<
"Minimum Number of Operations Required: " << output1
+
+
+
+
+
+
146 uint64_t expected_output2 = 3;
+
+
+
149 assert(output2 == expected_output2);
+
150 std::cout <<
"Minimum Number of Operations Required: " << output2
+
+
+
+
+
+
uint64_t editDistDP(std::string str1, std::string str2, uint64_t m, uint64_t n)
Calculates and stores the result of all the sub-problems, so that we don't have to recur to compute t...
Definition: minimum_edit_distance.cpp:88
+
+
+
+
+
+
+
+
+
diff --git a/da/d52/minimum__edit__distance_8cpp_a0ddf1224851353fc92bfbff6f499fa97_cgraph.md5 b/da/d52/minimum__edit__distance_8cpp_a0ddf1224851353fc92bfbff6f499fa97_cgraph.md5
new file mode 100644
index 000000000..d68f82680
--- /dev/null
+++ b/da/d52/minimum__edit__distance_8cpp_a0ddf1224851353fc92bfbff6f499fa97_cgraph.md5
@@ -0,0 +1 @@
+1d870b19e256347c9c55e5ac4895c7ea
\ No newline at end of file
diff --git a/da/d52/minimum__edit__distance_8cpp_a0ddf1224851353fc92bfbff6f499fa97_cgraph.svg b/da/d52/minimum__edit__distance_8cpp_a0ddf1224851353fc92bfbff6f499fa97_cgraph.svg
new file mode 100644
index 000000000..2eed52f1d
--- /dev/null
+++ b/da/d52/minimum__edit__distance_8cpp_a0ddf1224851353fc92bfbff6f499fa97_cgraph.svg
@@ -0,0 +1,67 @@
+
+
+
+
+
+
+main
+
+Node1
+
+main
+
+
+
+
+Node2
+
+test
+
+
+
+
+Node1->Node2
+
+
+
+Node3
+
+std::endl
+
+
+
+
+Node2->Node3
+
+
+
+Node4
+
+std::string::length
+
+
+
+
+Node2->Node4
+
+
+
diff --git a/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map b/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
new file mode 100644
index 000000000..ba6912f58
--- /dev/null
+++ b/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map
@@ -0,0 +1,5 @@
+
+
diff --git a/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 b/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
new file mode 100644
index 000000000..489f8b7be
--- /dev/null
+++ b/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5
@@ -0,0 +1 @@
+5d4300b05742c51159ae7bfa132fa0d6
\ No newline at end of file
diff --git a/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg b/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
new file mode 100644
index 000000000..91f8dffba
--- /dev/null
+++ b/da/d52/minimum__edit__distance_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg
@@ -0,0 +1,52 @@
+
+
+
+
+
+
+test
+
+Node1
+
+test
+
+
+
+
+Node2
+
+std::endl
+
+
+
+
+Node1->Node2
+
+
+
+Node3
+
+std::string::length
+
+
+
+
+Node1->Node3
+
+
+
diff --git a/da/d5a/class_complex_a3cfc522c782726f49ee20af17b77f867_cgraph.svg b/da/d5a/class_complex_a3cfc522c782726f49ee20af17b77f867_cgraph.svg
index efd0c6ac6..7c3b8f342 100644
--- a/da/d5a/class_complex_a3cfc522c782726f49ee20af17b77f867_cgraph.svg
+++ b/da/d5a/class_complex_a3cfc522c782726f49ee20af17b77f867_cgraph.svg
@@ -1,7 +1,7 @@
-
-
-
-
-
+
+
+Algorithms_in_C++: machine_learning::aystar_search::AyStarSearch< Puzzle >::Info Struct Reference
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Struct that handles all the information related to the current state.
+ More...
+
+state heuristic_value = 0 Holds the current state. depth = 0 stores h score
+
+
template<typename Puzzle>
+
+
Struct that handles all the information related to the current state.
+
+
+
◆ [1/5]
+
+
+
+
+template<typename Puzzle >
+
+
+
+
stores g score
+
Default constructor
+
+
+
+
+
◆ [2/5]
+
+
+
+
+template<typename Puzzle >
+
+
+
+
+
+
+inline explicit
+
+
+
+
+
constructor having Puzzle as parameter
+
Parameters
+
+
+
+
+
+
+
+
◆ [3/5]
+
+
+
+
+template<typename Puzzle >
+
+
+
+
constructor having three parameters
+
Parameters
+
+ A a puzzle object h_value heuristic value of this puzzle object depth the depth at which this node was found during traversal
+
+
+
+
size_t depth
stores h score
Definition: a_star_search.cpp:297
+
size_t heuristic_value
Holds the current state.
Definition: a_star_search.cpp:296
+
+
+
+
+
◆ [4/5]
+
+
+
+
+template<typename Puzzle >
+
+
+
+
Copy constructor.
+
Parameters
+
+ A Info object reference
+
+
+
+
+
+
+
◆ [5/5]
+
+
+
+
+template<typename Puzzle >
+
+
+
+
+
+
+inline noexcept
+
+
+
+
+
Move constructor.
+
Parameters
+
+ A Info object reference
+
+
+
+
+
+
+
+
◆ [1/2]
+
+
+
+
+template<typename Puzzle >
+
+
+
+
copy assignment operator
+
Parameters
+
+ A Info object reference
+
+
+
+
+
+
+
◆ [2/2]
+
+
+
+
+template<typename Puzzle >
+
+
+
+
+
+
+inline noexcept
+
+
+
+
+
move assignment operator
+
Parameters
+
+ A Info object reference
+
+
+
+
+
+
+
+
The documentation for this struct was generated from the following file:
+machine_learning/a_star_search.cpp
+
+
+
+
diff --git a/da/d70/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1_info_aea763e487cf100668d4eff160e40c3fa_cgraph.md5 b/da/d70/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1_info_aea763e487cf100668d4eff160e40c3fa_cgraph.md5
new file mode 100644
index 000000000..a745e5ba7
--- /dev/null
+++ b/da/d70/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1_info_aea763e487cf100668d4eff160e40c3fa_cgraph.md5
@@ -0,0 +1 @@
+ee468c4f9d15d7b30ae1212a8f33da54
\ No newline at end of file
diff --git a/da/d70/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1_info_aea763e487cf100668d4eff160e40c3fa_cgraph.svg b/da/d70/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1_info_aea763e487cf100668d4eff160e40c3fa_cgraph.svg
new file mode 100644
index 000000000..a8e14ce95
--- /dev/null
+++ b/da/d70/structmachine__learning_1_1aystar__search_1_1_ay_star_search_1_1_info_aea763e487cf100668d4eff160e40c3fa_cgraph.svg
@@ -0,0 +1,39 @@
+
+
+
+
+
+
+machine_learning::aystar_search::AyStarSearch::Info::operator=
+
+Node1
+
+machine_learning::aystar
+_search::AyStarSearch::
+Info::operator=
+
+
+
+
+Node2
+
+std::move
+
+
+
+
+Node1->Node2
+
+
+
diff --git a/da/d74/connected__components__with__dsu_8cpp__incl.svg b/da/d74/connected__components__with__dsu_8cpp__incl.svg
index a5d5a32d6..66faac741 100644
--- a/da/d74/connected__components__with__dsu_8cpp__incl.svg
+++ b/da/d74/connected__components__with__dsu_8cpp__incl.svg
@@ -1,7 +1,7 @@
-
+
+
+dynamic_programming/abbreviation.cpp
+
+Node1
+
+dynamic_programming
+/abbreviation.cpp
+
+
+
+
+Node2
+
+cassert
+
+
+
+
+Node1->Node2
+
+
+
+Node3
+
+iostream
+
+
+
+
+Node1->Node3
+
+
+
+Node4
+
+string
+
+
+
+
+Node1->Node4
+
+
+
+Node5
+
+vector
+
+
+
+
+Node1->Node5
+
+
+
diff --git a/da/d77/spirograph_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph.svg b/da/d77/spirograph_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph.svg
index d5852a0e6..7e949aeb6 100644
--- a/da/d77/spirograph_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph.svg
+++ b/da/d77/spirograph_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph.svg
@@ -1,7 +1,7 @@
-
diff --git a/da/d77/spirograph_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph_org.svg b/da/d77/spirograph_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph_org.svg
index 3a9bc1e76..ee5c80218 100644
--- a/da/d77/spirograph_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph_org.svg
+++ b/da/d77/spirograph_8cpp_a3c04138a5bfe5d72780bb7e82a18e627_cgraph_org.svg
@@ -1,7 +1,7 @@
-
-
-
-
-
-
+
+
+Algorithms_in_C++: ciphers/uint256_t.hpp File Reference
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
#include <string>
+
#include <utility>
+
#include "uint128_t.hpp "
+
+
Go to the source code of this file.
+
+uint256_t operator+ (const T p, const uint256_t &q) uint256_t operator- (const T p, const uint256_t &q) uint256_t operator* (const T p, const uint256_t &q) uint256_t operator/ (const T p, const uint256_t &q) uint256_t operator% (const T p, const uint256_t &q) uint256_t operator& (const T &p, const uint256_t &q) uint256_t operator| (const T p, const uint256_t &q) uint256_t operator^ (const T p, const uint256_t &q) bool operator&& (const T p, const uint256_t &q) bool operator|| (const T p, const uint256_t &q) bool operator== (const T p, const uint256_t &q) bool operator!= (const T p, const uint256_t &q) bool operator< (const T p, const uint256_t &q) bool operator<= (const T p, const uint256_t &q) bool operator> (const T p, const uint256_t &q) bool operator>= (const T p, const uint256_t &q)
+
+
Implementation of 256-bit unsigned integers.
Note The implementation can be flagged as not completed. This header is used with enough operations to demonstrate the usage of ECDH (Elliptic Curve Diffie-Hellman) Key exchange.
+
Author Ashish Daulatabad
+
+
+
◆
+
+
+
+
+
+ #define CIPHERS_UINT256_T_HPP_
+
+
+
+
+
+
Algorithms_in_C++: ciphers/uint256_t.hpp Source File
+
+
+
+
+
+
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Go to the documentation of this file.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
15 #ifndef CIPHERS_UINT256_T_HPP_
+
16 #define CIPHERS_UINT256_T_HPP_
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
45 if (str.
size () > 1 && str[1] ==
'x' ) {
+
46 for (
auto i = 2; i < str.
size (); ++i) {
+
+
48 if (str[i] >=
'0' && str[i] <=
'9' ) {
+
49 *
this += (str[i] -
'0' );
+
50 }
else if (str[i] >=
'A' && str[i] <=
'F' ) {
+
51 *
this += (str[i] -
'A' + 10);
+
52 }
else if (str[i] >=
'a' && str[i] <=
'f' ) {
+
53 *
this += (str[i] -
'a' + 10);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
104 : f(
std ::move(high)), s(
std ::move(low)) {}
+
+
+
+
+
+
+
111 uint256_t (
const uint64_t high,
const uint64_t low) : f(high), s(low) {}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
127 return 128 + s.
_lez ();
+
+
+
+
+
+
+
+
+
+
+
+
139 return 128 + f.
_trz ();
+
+
+
+
+
+
+
146 inline explicit operator bool()
const {
return f || s; }
+
+
+
+
+
+
+
+
+
155 inline explicit operator T()
const {
+
156 return static_cast< T
> (s);
+
+
+
+
+
+
+
163 inline explicit operator uint128_t ()
const {
return s; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
221 bool app = s + p < s;
+
+
+
+
+
+
+
+
+
+
231 bool app = (s + p.s < s);
+
232 return {f + app + p.f, s + p.s};
+
+
+
+
+
+
+
+
+
+
+
+
244 bool app = (p + s < s);
+
+
+
+
+
+
+
+
+
+
+
+
256 bool app = (s + p.s < s);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
300 return {f - p.f - app, s - p.s};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
373 s_second(p.s.
lower ());
+
374 uint128_t fi = f_first * s_first, se = f_first * s_second,
+
375 th = s_first * f_second, fo = s_second * f_second;
+
376 uint128_t tmp = se << 64, tmp2 = th << 64;
+
377 int cc = (tmp + tmp2 < tmp);
+
+
379 cc += (tmp + fo < tmp);
+
380 return {f * p.s + s * p.f + fi + se.
upper () + th.upper() + cc,
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
403 s_second(p.s.
lower ());
+
404 uint128_t fi = f_first * s_first, se = f_first * s_second,
+
405 th = s_first * f_second, fo = s_second * f_second;
+
406 uint128_t tmp = se << 64, tmp2 = th << 64;
+
407 int cc = (tmp + tmp2 < tmp);
+
+
409 cc += (tmp + fo < tmp);
+
410 f = f * p.s + s * p.f + fi + se.
upper () + th.upper() + cc;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
424 }
else if (*
this == p) {
+
+
+
+
428 uint16_t left = tmp.
_lez () -
_lez ();
+
+
+
+
432 while (left >= 0 && tmp2 >= p) {
+
433 uint16_t shf = tmp2._lez() - tmp.
_lez ();
+
+
+
+
+
+
+
+
+
+
+
+
+
+
447 return {quotient << left, tmp2};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
544 return f < other.f || (f == other.f && s < other.s);
+
+
+
+
+
+
+
+
+
553 return f < other.f || (f == other.f && s <= other.s);
+
+
+
+
+
+
+
+
+
562 return f > other.f || (f == other.f && s > other.s);
+
+
+
+
+
+
+
+
+
571 return (f > other.f) || (f == other.f && s >= other.s);
+
+
+
+
+
+
+
+
+
580 return f == other.f && s == other.s;
+
+
+
+
+
+
+
+
+
589 return !((*this) == other);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
604 return (s || f) && (b.s || b.f);
+
+
+
+
+
+
+
+
+
613 return (s || f) || (b.s || b.f);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
703 return (s || f) && (b);
+
+
+
+
+
+
+
+
+
+
+
+
+
716 return (s || f) || (b);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
735 return {this->f, this->s};
+
736 }
else if (p >= 128) {
+
+
+
739 return uint256_t ((this->f << p) + (this->s >> (128 - p)),
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
754 this->f = (this->s << (p - 128));
+
+
+
757 f = ((this->s >> (128 - p)) + (this->f << p));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
774 return {this->f, this->s};
+
775 }
else if (p >= 128) {
+
+
+
+
779 (this->s >> p) + (this->f << (128 - p)));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
794 s = (this->f >> (p - 128));
+
+
796 s = (this->s >> p) + (this->f << (128 - p));
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
821 return {f & p.f, s & p.s};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
866 return {this->f | p.f, this->s | p.s};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
911 return {this->f ^ p.f, this->s ^ p.s};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
953 for (uint64_t i = 0; i < 128; ++i) {
+
+
+
+
+
+
+
+
961 for (
int i = 0; i < 128; ++i) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1027 inline bool operator&&(
const T p,
const uint256_t &q) {
+
+
+
+
+
+
1033 inline bool operator||(
const T p,
const uint256_t &q) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
1052 inline bool operator<(
const T p,
const uint256_t &q) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
class for 128-bit unsigned integer
Definition: uint128_t.hpp:59
+
uint64_t upper() const
returns upper 64-bit integer part
Definition: uint128_t.hpp:207
+
uint32_t _trz()
Trailing zeroes in binary.
Definition: uint128_t.hpp:162
+
uint64_t lower() const
returns lower 64-bit integer part
Definition: uint128_t.hpp:201
+
uint32_t _lez()
Leading zeroes in binary.
Definition: uint128_t.hpp:139
+
class for 256-bit unsigned integer
Definition: uint256_t.hpp:33
+
uint256_t & operator/=(const uint256_t &p)
operator /= for uint256_t
Definition: uint256_t.hpp:476
+
uint256_t(uint128_t high, uint128_t low)
Parameterized constructor.
Definition: uint256_t.hpp:103
+
bool operator!()
operator ! for uint256_t
Definition: uint256_t.hpp:596
+
uint32_t _lez()
Leading zeroes in binary.
Definition: uint256_t.hpp:123
+
uint256_t & operator=(const std::string &p)
operator = for type string
Definition: uint256_t.hpp:202
+
uint256_t(uint256_t &&num) noexcept
Move constructor.
Definition: uint256_t.hpp:95
+
bool operator<=(const uint256_t &other)
operator <= for uint256_t
Definition: uint256_t.hpp:552
+
uint256_t(const std::string &str)
Parameterized constructor.
Definition: uint256_t.hpp:81
+
bool operator<=(const T &other)
operator <= for other types
Definition: uint256_t.hpp:642
+
uint256_t operator+(const T &p)
operator + for uint256_t and other integer types.
Definition: uint256_t.hpp:220
+
uint256_t & operator>>=(const T &p)
operator >>= for uint256_t
Definition: uint256_t.hpp:790
+
uint256_t operator--(int p)
operator – (post-decrement)
Definition: uint256_t.hpp:322
+
uint256_t(const uint64_t high, const uint64_t low)
Parameterized constructor.
Definition: uint256_t.hpp:111
+
uint256_t operator|(const uint256_t &p)
operator | for uint256_t (bitwise operator)
Definition: uint256_t.hpp:865
+
bool operator&&(const T &b)
operator && for other types
Definition: uint256_t.hpp:702
+
~uint256_t()=default
Destructor for uint256_t.
+
uint256_t operator-()
operator - using twos complement
Definition: uint256_t.hpp:307
+
bool operator||(const uint256_t &b)
operator || for uint256_t
Definition: uint256_t.hpp:612
+
uint256_t(const uint256_t &num)=default
Copy constructor.
+
uint256_t operator>>(const T &p)
operator >> for uint256_t
Definition: uint256_t.hpp:772
+
uint256_t operator<<(const T &p)
operator << for uint256_t
Definition: uint256_t.hpp:733
+
bool operator||(const T &b)
operator || for other types
Definition: uint256_t.hpp:715
+
uint256_t & operator*=(const T &p)
operator *= for uint256_t and other integer types.
Definition: uint256_t.hpp:392
+
uint256_t operator/(const uint256_t &p)
operator / for uint256_t and other integer types.
Definition: uint256_t.hpp:469
+
uint256_t & operator%=(const uint256_t &p)
operator %= for uint256_t
Definition: uint256_t.hpp:520
+
friend std::ostream & operator<<(std::ostream &op, uint256_t p)
operator << for printing uint256_t integer
Definition: uint256_t.hpp:947
+
uint256_t operator&(const T &p)
operator & for other types (bitwise operator)
Definition: uint256_t.hpp:811
+
uint256_t operator~()
operator ~ for uint256_t
Definition: uint256_t.hpp:723
+
uint256_t & operator|=(const uint256_t &p)
operator |= for uint256_t (bitwise operator)
Definition: uint256_t.hpp:887
+
uint256_t & operator|=(const T &p)
operator |= for other types (bitwise operator)
Definition: uint256_t.hpp:877
+
uint256_t operator^(const uint256_t &p)
operator ^ for uint256_t (bitwise operator)
Definition: uint256_t.hpp:910
+
bool operator()()
operator () for uint256_t
Definition: uint256_t.hpp:620
+
uint256_t operator++(int)
post-increment operator
Definition: uint256_t.hpp:275
+
uint256_t operator%(const T &p)
operator % for uint256_t and other integer types.
Definition: uint256_t.hpp:509
+
uint256_t & operator^=(const T &p)
operator ^= for other types (bitwise operator)
Definition: uint256_t.hpp:933
+
uint256_t & operator++()
pre-increment operator
Definition: uint256_t.hpp:266
+
uint256_t & operator--()
operator – (pre-decrement)
Definition: uint256_t.hpp:313
+
uint256_t operator-(const T &p)
operator - for uint256_t and other integer types.
Definition: uint256_t.hpp:288
+
bool operator!=(const T &other)
operator != for other types
Definition: uint256_t.hpp:690
+
bool operator==(const uint256_t &other)
operator == for uint256_t
Definition: uint256_t.hpp:579
+
uint256_t & operator%=(const T &p)
operator %= for uint256_t
Definition: uint256_t.hpp:533
+
uint256_t & operator&=(const T p)
operator &= for other types (bitwise operator)
Definition: uint256_t.hpp:843
+
bool operator==(const T &other)
operator == for other types
Definition: uint256_t.hpp:678
+
uint256_t operator&(const uint256_t &p)
operator & for uint256_t (bitwise operator)
Definition: uint256_t.hpp:820
+
uint256_t & operator/=(const T &p)
operator /= for uint256_t and other integer types.
Definition: uint256_t.hpp:489
+
uint32_t _trz()
Trailing zeroes in binary.
Definition: uint256_t.hpp:135
+
bool operator&&(const uint256_t &b)
operator && for uint256_t
Definition: uint256_t.hpp:603
+
uint128_t lower() const
returns lower 128-bit integer part
Definition: uint256_t.hpp:169
+
uint256_t & operator&=(const uint256_t &p)
operator &= for uint256_t (bitwise operator)
Definition: uint256_t.hpp:829
+
uint256_t operator*(const uint256_t &p)
operator * for uint256_t and other integer types.
Definition: uint256_t.hpp:371
+
uint256_t operator*(const T &p)
operator * for uint256_t and other integer types.
Definition: uint256_t.hpp:362
+
bool operator!=(const uint256_t &other)
operator != for uint256_t
Definition: uint256_t.hpp:588
+
uint256_t operator-(const uint256_t &p)
operator - for uint256_t
Definition: uint256_t.hpp:298
+
uint256_t & operator*=(const uint256_t &p)
operator *= for uint256_t and other integer types.
Definition: uint256_t.hpp:401
+
uint256_t & operator^=(const uint256_t &p)
operator ^= for uint256_t (bitwise operator)
Definition: uint256_t.hpp:919
+
uint256_t & operator=(const T &p)
operator = for other types
Definition: uint256_t.hpp:192
+
bool operator<(const T &other)
operator < for other types
Definition: uint256_t.hpp:630
+
uint256_t & operator+=(const uint256_t &p)
operator += for uint256_t
Definition: uint256_t.hpp:255
+
uint256_t operator/(const T &p)
operator / for uint256_t and other integer types.
Definition: uint256_t.hpp:458
+
bool operator>(const uint256_t &other)
operator > for uint256_t
Definition: uint256_t.hpp:561
+
uint256_t & operator-=(const uint256_t &p)
operator -= for uint256_t
Definition: uint256_t.hpp:347
+
uint256_t operator^(const T &p)
operator ^ for other types (bitwise operator)
Definition: uint256_t.hpp:901
+
uint256_t operator-=(const T p)
operator -= for uint256_t and other integer types.
Definition: uint256_t.hpp:335
+
uint256_t & operator<<=(const T &p)
operator <<= for uint256_t
Definition: uint256_t.hpp:751
+
uint256_t operator|(const T &p)
operator | for other types (bitwise operator)
Definition: uint256_t.hpp:856
+
uint256_t operator%(const uint256_t &p)
operator % for uint256_t
Definition: uint256_t.hpp:499
+
uint256_t & operator=(const uint256_t &p)=default
operator = for uint256_t
+
bool operator>(const T &other)
operator > for other types
Definition: uint256_t.hpp:654
+
uint256_t & operator=(uint256_t &&p)=default
Move assignment operator.
+
bool operator>=(const uint256_t &other)
operator >= for uint256_t
Definition: uint256_t.hpp:570
+
uint128_t upper() const
returns upper 128-bit integer part
Definition: uint256_t.hpp:175
+
uint256_t(T low)
Parameterized constructor.
Definition: uint256_t.hpp:75
+
uint256_t operator+(const uint256_t &p)
operator + for uint256_t and other integer types.
Definition: uint256_t.hpp:230
+
std::pair< uint256_t, uint256_t > divide(const uint256_t &p)
divide function for uint256_t and other integer types.
Definition: uint256_t.hpp:421
+
uint256_t & operator+=(const T &p)
operator += for uint256_t and other integer types.
Definition: uint256_t.hpp:243
+
bool operator<(const uint256_t &other)
operator < for uint256_t
Definition: uint256_t.hpp:543
+
void __get_integer_from_string(const std::string &str)
First and second half of 256 bit number.
Definition: uint256_t.hpp:43
+
bool operator>=(const T &other)
operator >= for other types
Definition: uint256_t.hpp:666
+
bool operator==(const Complex &a, const Complex &b)
Operator overload of '==' on Complex class. Logical Equal overload for our Complex class.
Definition: complex_numbers.cpp:175
+
+
+
+
+
+
+
+
+
std::vector< float > operator/(std::vector< T > const &A, float const scalar)
Definition: ordinary_least_squares_regressor.cpp:174
+
std::vector< T > operator-(std::vector< T > const &A, std::vector< T > const &B)
Definition: ordinary_least_squares_regressor.cpp:183
+
std::vector< T > operator+(std::vector< T > const &A, std::vector< T > const &B)
Definition: ordinary_least_squares_regressor.cpp:204
+
+
+
+
std::string add(const std::string &first, const std::string &second)
Adding two string.
Definition: uint128_t.hpp:37
+
+
-
-
-
+
+
+std::is_unsigned< uint128_t >
+
+Node1
+
+std::is_unsigned< uint128_t >
+
+
+
+
+Node2
+
+std::true_type
+
+
+
+
+Node2->Node1
+
+
+
diff --git a/da/dc3/linked__list_8cpp.html b/da/dc3/linked__list_8cpp.html
index 24410b28a..9478f439c 100644
--- a/da/dc3/linked__list_8cpp.html
+++ b/da/dc3/linked__list_8cpp.html
@@ -201,70 +201,70 @@ Here is the call graph for this function: 
1.9.1