From c7a9a423978c7b19fa9d19302d875bb995b81038 Mon Sep 17 00:00:00 2001 From: realstealthninja Date: Sun, 24 Nov 2024 15:01:37 +0000 Subject: [PATCH] Documentation for 77b9f39d96724524a3eb056bdbe2bc70f1ecd057 --- d4/d32/fibonacci__fast_8cpp.html | 284 +++++++++++++++++----- d4/d32/fibonacci__fast_8cpp.js | 5 +- d4/d32/fibonacci__fast_8cpp_source.html | 185 +++++++++++--- db/d51/fibonacci__fast_8cpp__incl.map | 14 +- db/d51/fibonacci__fast_8cpp__incl.md5 | 2 +- db/d51/fibonacci__fast_8cpp__incl.svg | 74 +++++- db/d51/fibonacci__fast_8cpp__incl_org.svg | 74 +++++- doxygen_crawl.html | 3 +- globals_defs.html | 2 +- globals_func_t.html | 2 +- globals_m.html | 2 +- globals_t.html | 2 +- globals_vars.html | 1 + navtreedata.js | 22 +- navtreeindex10.js | 4 +- navtreeindex11.js | 4 +- navtreeindex12.js | 4 +- navtreeindex13.js | 4 +- navtreeindex14.js | 1 + navtreeindex3.js | 10 +- navtreeindex4.js | 4 +- navtreeindex5.js | 4 +- navtreeindex6.js | 4 +- navtreeindex7.js | 4 +- navtreeindex8.js | 4 +- navtreeindex9.js | 4 +- search/all_12.js | 2 +- search/all_19.js | 2 +- search/defines_6.js | 2 +- search/functions_14.js | 2 +- search/variables_c.js | 23 +- 31 files changed, 577 insertions(+), 177 deletions(-) diff --git a/d4/d32/fibonacci__fast_8cpp.html b/d4/d32/fibonacci__fast_8cpp.html index aa0a9dd5f..a85ccdf5a 100644 --- a/d4/d32/fibonacci__fast_8cpp.html +++ b/d4/d32/fibonacci__fast_8cpp.html @@ -122,8 +122,8 @@ $(function(){initNavTree('d4/d32/fibonacci__fast_8cpp.html','../../'); initResiz
-Macros | -Functions
+Functions | +Variables
fibonacci_fast.cpp File Reference
@@ -133,52 +133,43 @@ $(function(){initNavTree('d4/d32/fibonacci__fast_8cpp.html','../../'); initResiz
#include <cinttypes>
#include <cstdio>
#include <iostream>
+#include <cassert>
+#include <string>
+#include <stdexcept>
Include dependency graph for fibonacci_fast.cpp:
-
+

Go to the source code of this file.

- - - -

-Macros

#define MAX   93
 
+ + + + + +

Functions

uint64_t fib (uint64_t n)
 Function to compute the nth Fibonacci number.
 
static void test ()
 Function to test the Fibonacci computation.
 
int main ()
 Main Function.
 
+ + + +

+Variables

constexpr uint64_t MAX = 93
 for std::invalid_argument
 

Detailed Description

Faster computation of Fibonacci series.

-

An efficient way to calculate nth fibonacci number faster and simpler than \(O(n\log n)\) method of matrix exponentiation This works by using both recursion and dynamic programming. as 93rd fibonacci exceeds 19 digits, which cannot be stored in a single long long variable, we can only use it till 92nd fibonacci we can use it for 10000th fibonacci etc, if we implement bigintegers. This algorithm works with the fact that nth fibonacci can easily found if we have already found n/2th or (n+1)/2th fibonacci It is a property of fibonacci similar to matrix exponentiation.

+

An efficient way to calculate nth fibonacci number faster and simpler than \(O(n\log n)\) method of matrix exponentiation. This works by using both recursion and dynamic programming. As 93rd fibonacci exceeds 19 digits, which cannot be stored in a single long long variable, we can only use it till 92nd fibonacci we can use it for 10000th fibonacci etc, if we implement bigintegers. This algorithm works with the fact that nth fibonacci can easily found if we have already found \(n/2\)th or \((n+1)/2\)th fibonacci. It is a property of fibonacci similar to matrix exponentiation.

Author
Krishna Vedala
See also
fibonacci_large.cpp, fibonacci.cpp, string_fibonacci.cpp

Definition in file fibonacci_fast.cpp.

-

Macro Definition Documentation

- -

◆ MAX

- -
-
- - - - -
#define MAX   93
-
-

maximum number that can be computed - The result after 93 cannot be stored in a uint64_t data type.

- -

Definition at line 27 of file fibonacci_fast.cpp.

- -
-
-

Function Documentation

+

Function Documentation

◆ fib()

@@ -193,28 +184,38 @@ Functions
-

Algorithm

-

Definition at line 30 of file fibonacci_fast.cpp.

-
30 {
-
31 static uint64_t f1 = 1,
-
32 f2 = 1; // using static keyword will retain the values of
-
33 // f1 and f2 for the next function call.
-
34
-
35 if (n <= 2)
-
36 return f2;
-
37 if (n >= 93) {
-
38 std::cerr
-
39 << "Cannot compute for n>93 due to limit of 64-bit integers\n";
-
40 return 0;
-
41 }
+

Function to compute the nth Fibonacci number.

+
Parameters
+ + +
nThe index of the Fibonacci number to compute
+
+
+
Returns
uint64_t The nth Fibonacci number
+ +

Definition at line 38 of file fibonacci_fast.cpp.

+
38 {
+
39 // Using static keyword will retain the values of
+
40 // f1 and f2 for the next function call.
+
41 static uint64_t f1 = 1, f2 = 1;
42
-
43 uint64_t temp = f2; // we do not need temp to be static
-
44 f2 += f1;
-
45 f1 = temp;
-
46
-
47 return f2;
-
48}
+
43 if (n <= 2) {
+
44 return f2;
+
45 } if (n >= MAX) {
+
46 throw std::invalid_argument("Cannot compute for n>=" + std::to_string(MAX) +
+
47 " due to limit of 64-bit integers");
+
48 return 0;
+
49 }
+
50
+
51 // We do not need temp to be static.
+
52 uint64_t temp = f2;
+
53 f2 += f1;
+
54 f1 = temp;
+
55
+
56 return f2;
+
57}
+
MAX
constexpr uint64_t MAX
for std::invalid_argument
Definition fibonacci_fast.cpp:31
@@ -232,18 +233,185 @@ Functions
-

Main function

-

Definition at line 51 of file fibonacci_fast.cpp.

-
51 {
-
52 // Main Function
-
53 for (uint64_t i = 1; i < 93; i++) {
-
54 std::cout << i << " th fibonacci number is " << fib(i) << std::endl;
-
55 }
-
56 return 0;
-
57}
-
fib
uint64_t fib(uint64_t n)
Definition fibonacci_fast.cpp:30
+

Main Function.

+
Returns
0 on exit
+ +

Definition at line 175 of file fibonacci_fast.cpp.

+
175 {
+
176 test(); // run self-test implementations
+
177 return 0;
+
178}
+
test
static void test()
Function to test the Fibonacci computation.
Definition fibonacci_fast.cpp:63
+
+
+ +

◆ test()

+ +
+
+ + + + + +
+ + + + + + + +
static void test ()
+ 		+static
+
+ +

Function to test the Fibonacci computation.

+
Returns
void
+ +

Definition at line 63 of file fibonacci_fast.cpp.

+
63 {
+
64 // Test for valid Fibonacci numbers
+
65 assert(fib(1) == 1);
+
66 assert(fib(2) == 1);
+
67 assert(fib(3) == 2);
+
68 assert(fib(4) == 3);
+
69 assert(fib(5) == 5);
+
70 assert(fib(6) == 8);
+
71 assert(fib(7) == 13);
+
72 assert(fib(8) == 21);
+
73 assert(fib(9) == 34);
+
74 assert(fib(10) == 55);
+
75 assert(fib(11) == 89);
+
76 assert(fib(12) == 144);
+
77 assert(fib(13) == 233);
+
78 assert(fib(14) == 377);
+
79 assert(fib(15) == 610);
+
80 assert(fib(16) == 987);
+
81 assert(fib(17) == 1597);
+
82 assert(fib(18) == 2584);
+
83 assert(fib(19) == 4181);
+
84 assert(fib(20) == 6765);
+
85 assert(fib(21) == 10946);
+
86 assert(fib(22) == 17711);
+
87 assert(fib(23) == 28657);
+
88 assert(fib(24) == 46368);
+
89 assert(fib(25) == 75025);
+
90 assert(fib(26) == 121393);
+
91 assert(fib(27) == 196418);
+
92 assert(fib(28) == 317811);
+
93 assert(fib(29) == 514229);
+
94 assert(fib(30) == 832040);
+
95 assert(fib(31) == 1346269);
+
96 assert(fib(32) == 2178309);
+
97 assert(fib(33) == 3524578);
+
98 assert(fib(34) == 5702887);
+
99 assert(fib(35) == 9227465);
+
100 assert(fib(36) == 14930352);
+
101 assert(fib(37) == 24157817);
+
102 assert(fib(38) == 39088169);
+
103 assert(fib(39) == 63245986);
+
104 assert(fib(40) == 102334155);
+
105 assert(fib(41) == 165580141);
+
106 assert(fib(42) == 267914296);
+
107 assert(fib(43) == 433494437);
+
108 assert(fib(44) == 701408733);
+
109 assert(fib(45) == 1134903170);
+
110 assert(fib(46) == 1836311903);
+
111 assert(fib(47) == 2971215073);
+
112 assert(fib(48) == 4807526976);
+
113 assert(fib(49) == 7778742049);
+
114 assert(fib(50) == 12586269025);
+
115 assert(fib(51) == 20365011074);
+
116 assert(fib(52) == 32951280099);
+
117 assert(fib(53) == 53316291173);
+
118 assert(fib(54) == 86267571272);
+
119 assert(fib(55) == 139583862445);
+
120 assert(fib(56) == 225851433717);
+
121 assert(fib(57) == 365435296162);
+
122 assert(fib(58) == 591286729879);
+
123 assert(fib(59) == 956722026041);
+
124 assert(fib(60) == 1548008755920);
+
125 assert(fib(61) == 2504730781961);
+
126 assert(fib(62) == 4052739537881);
+
127 assert(fib(63) == 6557470319842);
+
128 assert(fib(64) == 10610209857723);
+
129 assert(fib(65) == 17167680177565);
+
130 assert(fib(66) == 27777890035288);
+
131 assert(fib(67) == 44945570212853);
+
132 assert(fib(68) == 72723460248141);
+
133 assert(fib(69) == 117669030460994);
+
134 assert(fib(70) == 190392490709135);
+
135 assert(fib(71) == 308061521170129);
+
136 assert(fib(72) == 498454011879264);
+
137 assert(fib(73) == 806515533049393);
+
138 assert(fib(74) == 1304969544928657);
+
139 assert(fib(75) == 2111485077978050);
+
140 assert(fib(76) == 3416454622906707);
+
141 assert(fib(77) == 5527939700884757);
+
142 assert(fib(78) == 8944394323791464);
+
143 assert(fib(79) == 14472334024676221);
+
144 assert(fib(80) == 23416728348467685);
+
145 assert(fib(81) == 37889062373143906);
+
146 assert(fib(82) == 61305790721611591);
+
147 assert(fib(83) == 99194853094755497);
+
148 assert(fib(84) == 160500643816367088);
+
149 assert(fib(85) == 259695496911122585);
+
150 assert(fib(86) == 420196140727489673);
+
151 assert(fib(87) == 679891637638612258);
+
152 assert(fib(88) == 1100087778366101931);
+
153 assert(fib(89) == 1779979416004714189);
+
154 assert(fib(90) == 2880067194370816120);
+
155 assert(fib(91) == 4660046610375530309);
+
156 assert(fib(92) == 7540113804746346429);
+
157
+
158 // Test for invalid Fibonacci numbers
+
159 try {
+
160 fib(MAX + 1);
+
161 assert(false && "Expected an invalid_argument exception to be thrown");
+
162 } catch (const std::invalid_argument& e) {
+
163 const std::string expected_message = "Cannot compute for n>=" + std::to_string(MAX) +
+
164 " due to limit of 64-bit integers";
+
165 assert(e.what() == expected_message);
+
166 }
+
167
+
168 std::cout << "All Fibonacci tests have successfully passed!\n";
+
169}
+
fib
uint64_t fib(uint64_t n)
Function to compute the nth Fibonacci number.
Definition fibonacci_fast.cpp:38
+
+
+
+

Variable Documentation

+ +

◆ MAX

+ +
+
+ + + + + +
+ + + + +
uint64_t MAX = 93
+ 		+constexpr
+
+ +

for std::invalid_argument

+

for uint64_t for standard IO for IO operations for assert for std::to_string

+

Maximum Fibonacci number that can be computed

+

The result after 93 cannot be stored in a uint64_t data type.

+ +

Definition at line 31 of file fibonacci_fast.cpp.

+
diff --git a/d4/d32/fibonacci__fast_8cpp.js b/d4/d32/fibonacci__fast_8cpp.js index e558125c3..03760739e 100644 --- a/d4/d32/fibonacci__fast_8cpp.js +++ b/d4/d32/fibonacci__fast_8cpp.js @@ -1,6 +1,7 @@ var fibonacci__fast_8cpp = [ - [ "MAX", "d4/d32/fibonacci__fast_8cpp.html#a392fb874e547e582e9c66a08a1f23326", null ], [ "fib", "d4/d32/fibonacci__fast_8cpp.html#a5712edca101204eca8accdb1e096707f", null ], - [ "main", "d4/d32/fibonacci__fast_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ] + [ "main", "d4/d32/fibonacci__fast_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ], + [ "test", "d4/d32/fibonacci__fast_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ], + [ "MAX", "d4/d32/fibonacci__fast_8cpp.html#abebd72fcda852381644b55f9316719a0", null ] ]; \ No newline at end of file diff --git a/d4/d32/fibonacci__fast_8cpp_source.html b/d4/d32/fibonacci__fast_8cpp_source.html index bd5e1983d..77c9d322b 100644 --- a/d4/d32/fibonacci__fast_8cpp_source.html +++ b/d4/d32/fibonacci__fast_8cpp_source.html @@ -125,45 +125,158 @@ $(function(){initNavTree('d4/d32/fibonacci__fast_8cpp_source.html','../../'); in
Go to the documentation of this file.
1
-
18#include <cinttypes>
-
19#include <cstdio>
-
20#include <iostream>
-
21
-
27#define MAX 93
-
28
-
-
30uint64_t fib(uint64_t n) {
-
31 static uint64_t f1 = 1,
-
32 f2 = 1; // using static keyword will retain the values of
-
33 // f1 and f2 for the next function call.
-
34
-
35 if (n <= 2)
-
36 return f2;
-
37 if (n >= 93) {
-
38 std::cerr
-
39 << "Cannot compute for n>93 due to limit of 64-bit integers\n";
-
40 return 0;
-
41 }
+
18#include <cinttypes>
+
19#include <cstdio>
+
20#include <iostream>
+
21#include <cassert>
+
22#include <string>
+
23#include <stdexcept>
+
24
+
31constexpr uint64_t MAX = 93;
+
32
+
+
38uint64_t fib(uint64_t n) {
+
39 // Using static keyword will retain the values of
+
40 // f1 and f2 for the next function call.
+
41 static uint64_t f1 = 1, f2 = 1;
42
-
43 uint64_t temp = f2; // we do not need temp to be static
-
44 f2 += f1;
-
45 f1 = temp;
-
46
-
47 return f2;
-
48}
-
-
49
-
-
51int main() {
-
52 // Main Function
-
53 for (uint64_t i = 1; i < 93; i++) {
-
54 std::cout << i << " th fibonacci number is " << fib(i) << std::endl;
-
55 }
-
56 return 0;
+
43 if (n <= 2) {
+
44 return f2;
+
45 } if (n >= MAX) {
+
46 throw std::invalid_argument("Cannot compute for n>=" + std::to_string(MAX) +
+
47 " due to limit of 64-bit integers");
+
48 return 0;
+
49 }
+
50
+
51 // We do not need temp to be static.
+
52 uint64_t temp = f2;
+
53 f2 += f1;
+
54 f1 = temp;
+
55
+
56 return f2;
57}
-
fib
uint64_t fib(uint64_t n)
Definition fibonacci_fast.cpp:30
-
main
int main()
Definition fibonacci_fast.cpp:51
+
58
+
+
63static void test() {
+
64 // Test for valid Fibonacci numbers
+
65 assert(fib(1) == 1);
+
66 assert(fib(2) == 1);
+
67 assert(fib(3) == 2);
+
68 assert(fib(4) == 3);
+
69 assert(fib(5) == 5);
+
70 assert(fib(6) == 8);
+
71 assert(fib(7) == 13);
+
72 assert(fib(8) == 21);
+
73 assert(fib(9) == 34);
+
74 assert(fib(10) == 55);
+
75 assert(fib(11) == 89);
+
76 assert(fib(12) == 144);
+
77 assert(fib(13) == 233);
+
78 assert(fib(14) == 377);
+
79 assert(fib(15) == 610);
+
80 assert(fib(16) == 987);
+
81 assert(fib(17) == 1597);
+
82 assert(fib(18) == 2584);
+
83 assert(fib(19) == 4181);
+
84 assert(fib(20) == 6765);
+
85 assert(fib(21) == 10946);
+
86 assert(fib(22) == 17711);
+
87 assert(fib(23) == 28657);
+
88 assert(fib(24) == 46368);
+
89 assert(fib(25) == 75025);
+
90 assert(fib(26) == 121393);
+
91 assert(fib(27) == 196418);
+
92 assert(fib(28) == 317811);
+
93 assert(fib(29) == 514229);
+
94 assert(fib(30) == 832040);
+
95 assert(fib(31) == 1346269);
+
96 assert(fib(32) == 2178309);
+
97 assert(fib(33) == 3524578);
+
98 assert(fib(34) == 5702887);
+
99 assert(fib(35) == 9227465);
+
100 assert(fib(36) == 14930352);
+
101 assert(fib(37) == 24157817);
+
102 assert(fib(38) == 39088169);
+
103 assert(fib(39) == 63245986);
+
104 assert(fib(40) == 102334155);
+
105 assert(fib(41) == 165580141);
+
106 assert(fib(42) == 267914296);
+
107 assert(fib(43) == 433494437);
+
108 assert(fib(44) == 701408733);
+
109 assert(fib(45) == 1134903170);
+
110 assert(fib(46) == 1836311903);
+
111 assert(fib(47) == 2971215073);
+
112 assert(fib(48) == 4807526976);
+
113 assert(fib(49) == 7778742049);
+
114 assert(fib(50) == 12586269025);
+
115 assert(fib(51) == 20365011074);
+
116 assert(fib(52) == 32951280099);
+
117 assert(fib(53) == 53316291173);
+
118 assert(fib(54) == 86267571272);
+
119 assert(fib(55) == 139583862445);
+
120 assert(fib(56) == 225851433717);
+
121 assert(fib(57) == 365435296162);
+
122 assert(fib(58) == 591286729879);
+
123 assert(fib(59) == 956722026041);
+
124 assert(fib(60) == 1548008755920);
+
125 assert(fib(61) == 2504730781961);
+
126 assert(fib(62) == 4052739537881);
+
127 assert(fib(63) == 6557470319842);
+
128 assert(fib(64) == 10610209857723);
+
129 assert(fib(65) == 17167680177565);
+
130 assert(fib(66) == 27777890035288);
+
131 assert(fib(67) == 44945570212853);
+
132 assert(fib(68) == 72723460248141);
+
133 assert(fib(69) == 117669030460994);
+
134 assert(fib(70) == 190392490709135);
+
135 assert(fib(71) == 308061521170129);
+
136 assert(fib(72) == 498454011879264);
+
137 assert(fib(73) == 806515533049393);
+
138 assert(fib(74) == 1304969544928657);
+
139 assert(fib(75) == 2111485077978050);
+
140 assert(fib(76) == 3416454622906707);
+
141 assert(fib(77) == 5527939700884757);
+
142 assert(fib(78) == 8944394323791464);
+
143 assert(fib(79) == 14472334024676221);
+
144 assert(fib(80) == 23416728348467685);
+
145 assert(fib(81) == 37889062373143906);
+
146 assert(fib(82) == 61305790721611591);
+
147 assert(fib(83) == 99194853094755497);
+
148 assert(fib(84) == 160500643816367088);
+
149 assert(fib(85) == 259695496911122585);
+
150 assert(fib(86) == 420196140727489673);
+
151 assert(fib(87) == 679891637638612258);
+
152 assert(fib(88) == 1100087778366101931);
+
153 assert(fib(89) == 1779979416004714189);
+
154 assert(fib(90) == 2880067194370816120);
+
155 assert(fib(91) == 4660046610375530309);
+
156 assert(fib(92) == 7540113804746346429);
+
157
+
158 // Test for invalid Fibonacci numbers
+
159 try {
+
160 fib(MAX + 1);
+
161 assert(false && "Expected an invalid_argument exception to be thrown");
+
162 } catch (const std::invalid_argument& e) {
+
163 const std::string expected_message = "Cannot compute for n>=" + std::to_string(MAX) +
+
164 " due to limit of 64-bit integers";
+
165 assert(e.what() == expected_message);
+
166 }
+
167
+
168 std::cout << "All Fibonacci tests have successfully passed!\n";
+
169}
+
+
170
+
+
175int main() {
+
176 test(); // run self-test implementations
+
177 return 0;
+
178}
+
+
fib
uint64_t fib(uint64_t n)
Function to compute the nth Fibonacci number.
Definition fibonacci_fast.cpp:38
+
test
static void test()
Function to test the Fibonacci computation.
Definition fibonacci_fast.cpp:63
+
MAX
constexpr uint64_t MAX
for std::invalid_argument
Definition fibonacci_fast.cpp:31
+
main
int main()
Main Function.
Definition fibonacci_fast.cpp:175
diff --git a/db/d51/fibonacci__fast_8cpp__incl.map b/db/d51/fibonacci__fast_8cpp__incl.map index 4bb0cd3ae..dfd74e0c1 100644 --- a/db/d51/fibonacci__fast_8cpp__incl.map +++ b/db/d51/fibonacci__fast_8cpp__incl.map @@ -1,9 +1,15 @@ - + - + - + - + + + + + + + diff --git a/db/d51/fibonacci__fast_8cpp__incl.md5 b/db/d51/fibonacci__fast_8cpp__incl.md5 index b804aac79..912a486af 100644 --- a/db/d51/fibonacci__fast_8cpp__incl.md5 +++ b/db/d51/fibonacci__fast_8cpp__incl.md5 @@ -1 +1 @@ -c96f68a933ff6c91e93d7b7a862098b9 \ No newline at end of file +f4b8357f8b4009666debbdf3edc63421 \ No newline at end of file diff --git a/db/d51/fibonacci__fast_8cpp__incl.svg b/db/d51/fibonacci__fast_8cpp__incl.svg index b86f124c2..746b6c93f 100644 --- a/db/d51/fibonacci__fast_8cpp__incl.svg +++ b/db/d51/fibonacci__fast_8cpp__incl.svg @@ -4,8 +4,8 @@ - + @@ -23,8 +23,8 @@ Node1 - -math/fibonacci_fast.cpp + +math/fibonacci_fast.cpp @@ -41,8 +41,8 @@ Node1->Node2 - - + + @@ -59,8 +59,8 @@ Node1->Node3 - - + + @@ -77,8 +77,62 @@ Node1->Node4 - - + + + + + + + +Node5 + + +cassert + + + + + +Node1->Node5 + + + + + + + + +Node6 + + +string + + + + + +Node1->Node6 + + + + + + + + +Node7 + + +stdexcept + + + + + +Node1->Node7 + + + diff --git a/db/d51/fibonacci__fast_8cpp__incl_org.svg b/db/d51/fibonacci__fast_8cpp__incl_org.svg index 73276d7c1..30f963a28 100644 --- a/db/d51/fibonacci__fast_8cpp__incl_org.svg +++ b/db/d51/fibonacci__fast_8cpp__incl_org.svg @@ -4,16 +4,16 @@ - + math/fibonacci_fast.cpp Node1 - -math/fibonacci_fast.cpp + +math/fibonacci_fast.cpp @@ -30,8 +30,8 @@ Node1->Node2 - - + + @@ -48,8 +48,8 @@ Node1->Node3 - - + + @@ -66,8 +66,62 @@ Node1->Node4 - - + + + + + + + +Node5 + + +cassert + + + + + +Node1->Node5 + + + + + + + + +Node6 + + +string + + + + + +Node1->Node6 + + + + + + + + +Node7 + + +stdexcept + + + + + +Node1->Node7 + + + diff --git a/doxygen_crawl.html b/doxygen_crawl.html index 4e2679d83..385d77d42 100644 --- a/doxygen_crawl.html +++ b/doxygen_crawl.html @@ -2044,8 +2044,9 @@ - + + diff --git a/globals_defs.html b/globals_defs.html index 293ad133e..df12e2caa 100644 --- a/globals_defs.html +++ b/globals_defs.html @@ -134,7 +134,7 @@ $(function(){initNavTree('globals_defs.html',''); initResizable(true); });
  • HASHMAX : hash_search.cpp
  • LIMS : qr_eigen_values.cpp
  • ll : matrix_exponentiation.cpp
    • -
  • MAX : fibonacci_fast.cpp, power_for_huge_numbers.cpp, paranthesis_matching.cpp, hash_search.cpp, ternary_search.cpp
    • +
  • MAX : power_for_huge_numbers.cpp, paranthesis_matching.cpp, hash_search.cpp, ternary_search.cpp
  • MAX_ITERATIONS : bisection_method.cpp
  • pb : matrix_exponentiation.cpp
  • PRIME : rabin_karp.cpp
    • diff --git a/globals_func_t.html b/globals_func_t.html index 26d700197..1461efc79 100644 --- a/globals_func_t.html +++ b/globals_func_t.html @@ -125,7 +125,7 @@ $(function(){initNavTree('globals_func_t.html',''); initResizable(true); });

    - t -