Merge branch 'master' into ctest

realstealthninja · web-flow · commit 488daec653f6 · 2025-08-15T03:45:04.000Z
diff --git a/backtracking/graph_coloring.cpp b/backtracking/graph_coloring.cpp
@@ -20,7 +20,6 @@
 
 #include <array>     /// for std::array
 #include <iostream>  /// for IO operations
-#include <vector>    /// for std::vector
 
 /**
  * @namespace backtracking
diff --git a/ciphers/base64_encoding.cpp b/ciphers/base64_encoding.cpp
@@ -11,7 +11,6 @@
  * digits.
  * @author [Ashish Daulatabad](https://github.com/AshishYUO)
  */
-#include <array>     /// for `std::array`
 #include <cassert>   /// for `assert` operations
 #include <cstdint>
 #include <iostream>  /// for IO operations
diff --git a/ciphers/hill_cipher.cpp b/ciphers/hill_cipher.cpp
@@ -379,7 +379,6 @@ class HillCipher {
         int mat_determinant = det_encrypt < 0 ? det_encrypt % L : det_encrypt;
 
         matrix<double> tmp_inverse = get_inverse(encrypt_key);
-        double d2 = determinant_lu(decrypt_key);
 
         // find co-prime factor for inversion
         int det_inv = -1;
diff --git a/data_structures/rb_tree.cpp b/data_structures/rb_tree.cpp
@@ -33,7 +33,7 @@ class RBtree
 };
 void RBtree::insert()
 {
-	int z, i = 0;
+	int z;
 	cout << "\nEnter key of the node to be inserted: ";
 	cin >> z;
 	node *p, *q;
diff --git a/data_structures/trie_tree.cpp b/data_structures/trie_tree.cpp
@@ -12,7 +12,6 @@
 #include <iostream>
 #include <memory>
 #include <string>
-#include <vector>
 
 /** \namespace data_structures
  * \brief Data-structure algorithms
diff --git a/divide_and_conquer/karatsuba_algorithm_for_fast_multiplication.cpp b/divide_and_conquer/karatsuba_algorithm_for_fast_multiplication.cpp
@@ -15,7 +15,6 @@
 #include <cassert>   /// for assert
 #include <cstring>   /// for string
 #include <iostream>  /// for IO operations
-#include <vector>    /// for std::vector
 
 /**
  * @namespace divide_and_conquer
diff --git a/dynamic_programming/maximum_circular_subarray.cpp b/dynamic_programming/maximum_circular_subarray.cpp
@@ -67,7 +67,6 @@ static void test() {
     // Output: 22 
     // Explanation: Subarray 12, 8, -8, 9, -9, 10 gives the maximum sum, that is 22.
 
-    int n = 7; // size of the array
     std::vector<int> arr = {8, -8, 9, -9, 10, -11, 12}; 
     assert(dynamic_programming::maxCircularSum(arr) == 22); // this ensures that the algorithm works as expected
 
diff --git a/graph/breadth_first_search.cpp b/graph/breadth_first_search.cpp
@@ -52,7 +52,6 @@
 #include <map>
 #include <queue>
 #include <string>
-#include <vector>
 
 /**
  * \namespace graph
diff --git a/graph/hopcroft_karp.cpp b/graph/hopcroft_karp.cpp
@@ -254,7 +254,7 @@ using graph::HKGraph;
  */
 void tests(){
      // Sample test case 1
-	     int v1a = 3, v1b = 5, e1 = 2;  // vertices of left side, right side and edges
+	     int v1a = 3, v1b = 5;  // vertices of left side, right side and edges
 	     HKGraph g1(v1a, v1b); // execute the algorithm 
 
 	     g1.addEdge(0,1);
@@ -266,7 +266,7 @@ void tests(){
 	     assert(res1 == expected_res1); // assert check to ensure that the algorithm executed correctly for test 1
 	
      // Sample test case 2
-     	     int v2a = 4, v2b = 4, e2 = 6;  // vertices of left side, right side and edges
+     	     int v2a = 4, v2b = 4;  // vertices of left side, right side and edges
 	     HKGraph g2(v2a, v2b); // execute the algorithm 
 
              g2.addEdge(1,1);
@@ -282,7 +282,7 @@ void tests(){
 	     assert(res2 == expected_res2); // assert check to ensure that the algorithm executed correctly for test 2
 	
       // Sample test case 3
-     	     int v3a = 6, v3b = 6, e3 = 4;  // vertices of left side, right side and edges
+     	     int v3a = 6, v3b = 6;  // vertices of left side, right side and edges
 	     HKGraph g3(v3a, v3b); // execute the algorithm 
 
              g3.addEdge(0,1);
diff --git a/hashing/double_hash_hash_table.cpp b/hashing/double_hash_hash_table.cpp
@@ -248,7 +248,7 @@ using double_hashing::totalSize;
  * @returns 0 on success
  */
 int main() {
-    int cmd = 0, hash = 0, key = 0;
+    int cmd = 0, key = 0;
     std::cout << "Enter the initial size of Hash Table. = ";
     std::cin >> totalSize;
     table = std::vector<Entry>(totalSize);
diff --git a/hashing/linear_probing_hash_table.cpp b/hashing/linear_probing_hash_table.cpp
@@ -222,7 +222,7 @@ using linear_probing::totalSize;
  * @returns 0 on success
  */
 int main() {
-    int cmd = 0, hash = 0, key = 0;
+    int cmd = 0, key = 0;
     std::cout << "Enter the initial size of Hash Table. = ";
     std::cin >> totalSize;
     table = std::vector<Entry>(totalSize);
diff --git a/hashing/quadratic_probing_hash_table.cpp b/hashing/quadratic_probing_hash_table.cpp
@@ -244,7 +244,7 @@ using quadratic_probing::totalSize;
  * @returns None
  */
 int main() {
-    int cmd = 0, hash = 0, key = 0;
+    int cmd = 0, key = 0;
     std::cout << "Enter the initial size of Hash Table. = ";
     std::cin >> totalSize;
     table = std::vector<Entry>(totalSize);
diff --git a/machine_learning/kohonen_som_trace.cpp b/machine_learning/kohonen_som_trace.cpp
@@ -103,7 +103,7 @@ namespace machine_learning {
 void update_weights(const std::valarray<double> &x,
                     std::vector<std::valarray<double>> *W,
                     std::valarray<double> *D, double alpha, int R) {
-    int j = 0, k = 0;
+    int j = 0;
     int num_out = W->size();  // number of SOM output nodes
     // int num_features = x.size();  // number of data features
 
diff --git a/machine_learning/ordinary_least_squares_regressor.cpp b/machine_learning/ordinary_least_squares_regressor.cpp
@@ -367,8 +367,6 @@ std::vector<float> predict_OLS_regressor(std::vector<std::vector<T>> const &X,
 
 /** Self test checks */
 void ols_test() {
-    int F = 3, N = 5;
-
     /* test function = x^2 -5 */
     std::cout << "Test 1 (quadratic function)....";
     // create training data set with features = x, x^2, x^3
diff --git a/math/factorial.cpp b/math/factorial.cpp
@@ -27,7 +27,7 @@ namespace math {
  * cannot be represented in 64 bit unsigned int
  */
 uint64_t factorial(uint8_t n) {
-    if (n < 20) {
+    if (n > 20) {
         throw std::invalid_argument("maximum value is 20\n");
     }
     if (n == 0) {
diff --git a/math/fibonacci_fast.cpp b/math/fibonacci_fast.cpp
@@ -1,57 +1,178 @@
 /**
  * @file
- * @brief Faster computation of Fibonacci series
+ * @brief Faster computation of Fibonacci series.
  *
+ * @details
  * An efficient way to calculate nth fibonacci number faster and simpler than
- * \f$O(n\log n)\f$ method of matrix exponentiation This works by using both
- * recursion and dynamic programming. as 93rd fibonacci exceeds 19 digits, which
+ * \f$O(n\log n)\f$ 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
+ * found if we have already found \f$n/2\f$th or \f$(n+1)/2\f$th fibonacci. It is a property
  * of fibonacci similar to matrix exponentiation.
  *
- * \author [Krishna Vedala](https://github.com/kvedala)
+ * @author [Krishna Vedala](https://github.com/kvedala)
  * @see fibonacci_large.cpp, fibonacci.cpp, string_fibonacci.cpp
  */
-
-#include <cinttypes>
-#include <cstdio>
-#include <iostream>
+#include <cinttypes>  /// for uint64_t
+#include <cstdio>     /// for standard IO
+#include <iostream>   /// for IO operations
+#include <cassert>    /// for assert
+#include <string>     /// for std::to_string
+#include <stdexcept>  /// for std::invalid_argument
 
 /**
- * maximum number that can be computed - The result after 93 cannot be stored
- * in a `uint64_t` data type.
+ * @brief Maximum Fibonacci number that can be computed
+ *
+ * @details
+ * The result after 93 cannot be stored in a `uint64_t` data type.
  */
+constexpr uint64_t MAX = 93;
 
-#define MAX 93
-
-/** Algorithm */
+/**
+ * @brief Function to compute the nth Fibonacci number
+ * @param n The index of the Fibonacci number to compute
+ * @return uint64_t The nth Fibonacci number
+ */
 uint64_t fib(uint64_t n) {
-    static uint64_t f1 = 1,
-                    f2 = 1;  // using static keyword will retain the values of
-                             // f1 and f2 for the next function call.
+    // Using static keyword will retain the values of
+    // f1 and f2 for the next function call.
+    static uint64_t f1 = 1, f2 = 1;
 
-    if (n <= 2)
+    if (n <= 2) {
         return f2;
-    if (n >= 93) {
-        std::cerr
-            << "Cannot compute for n>93 due to limit of 64-bit integers\n";
+    } if (n >= MAX) {
+        throw std::invalid_argument("Cannot compute for n>=" + std::to_string(MAX) +
+                                    " due to limit of 64-bit integers");
         return 0;
     }
-
-    uint64_t temp = f2;  // we do not need temp to be static
+    
+    // We do not need temp to be static.
+    uint64_t temp = f2;  
     f2 += f1;
     f1 = temp;
 
     return f2;
 }
 
-/** Main function */
-int main() {
-    // Main Function
-    for (uint64_t i = 1; i < 93; i++) {
-        std::cout << i << " th fibonacci number is " << fib(i) << std::endl;
+/**
+ * @brief Function to test the Fibonacci computation
+ * @returns void
+ */
+static void test() {
+    // Test for valid Fibonacci numbers
+    assert(fib(1) == 1);
+    assert(fib(2) == 1);
+    assert(fib(3) == 2);
+    assert(fib(4) == 3);
+    assert(fib(5) == 5);
+    assert(fib(6) == 8);
+    assert(fib(7) == 13);
+    assert(fib(8) == 21);
+    assert(fib(9) == 34);
+    assert(fib(10) == 55);
+    assert(fib(11) == 89);
+    assert(fib(12) == 144);
+    assert(fib(13) == 233);
+    assert(fib(14) == 377);
+    assert(fib(15) == 610);
+    assert(fib(16) == 987);
+    assert(fib(17) == 1597);
+    assert(fib(18) == 2584);
+    assert(fib(19) == 4181);
+    assert(fib(20) == 6765);
+    assert(fib(21) == 10946);
+    assert(fib(22) == 17711);
+    assert(fib(23) == 28657);
+    assert(fib(24) == 46368);
+    assert(fib(25) == 75025);
+    assert(fib(26) == 121393);
+    assert(fib(27) == 196418);
+    assert(fib(28) == 317811);
+    assert(fib(29) == 514229);
+    assert(fib(30) == 832040);
+    assert(fib(31) == 1346269);
+    assert(fib(32) == 2178309);
+    assert(fib(33) == 3524578);
+    assert(fib(34) == 5702887);
+    assert(fib(35) == 9227465);
+    assert(fib(36) == 14930352);
+    assert(fib(37) == 24157817);
+    assert(fib(38) == 39088169);
+    assert(fib(39) == 63245986);
+    assert(fib(40) == 102334155);
+    assert(fib(41) == 165580141);
+    assert(fib(42) == 267914296);
+    assert(fib(43) == 433494437);
+    assert(fib(44) == 701408733);
+    assert(fib(45) == 1134903170);
+    assert(fib(46) == 1836311903);
+    assert(fib(47) == 2971215073);
+    assert(fib(48) == 4807526976);
+    assert(fib(49) == 7778742049);
+    assert(fib(50) == 12586269025);
+    assert(fib(51) == 20365011074);
+    assert(fib(52) == 32951280099);
+    assert(fib(53) == 53316291173);
+    assert(fib(54) == 86267571272);
+    assert(fib(55) == 139583862445);
+    assert(fib(56) == 225851433717);
+    assert(fib(57) == 365435296162);
+    assert(fib(58) == 591286729879);
+    assert(fib(59) == 956722026041);
+    assert(fib(60) == 1548008755920);
+    assert(fib(61) == 2504730781961);
+    assert(fib(62) == 4052739537881);
+    assert(fib(63) == 6557470319842);
+    assert(fib(64) == 10610209857723);
+    assert(fib(65) == 17167680177565);
+    assert(fib(66) == 27777890035288);
+    assert(fib(67) == 44945570212853);
+    assert(fib(68) == 72723460248141);
+    assert(fib(69) == 117669030460994);
+    assert(fib(70) == 190392490709135);
+    assert(fib(71) == 308061521170129);
+    assert(fib(72) == 498454011879264);
+    assert(fib(73) == 806515533049393);
+    assert(fib(74) == 1304969544928657);
+    assert(fib(75) == 2111485077978050);
+    assert(fib(76) == 3416454622906707);
+    assert(fib(77) == 5527939700884757);
+    assert(fib(78) == 8944394323791464);
+    assert(fib(79) == 14472334024676221);
+    assert(fib(80) == 23416728348467685);
+    assert(fib(81) == 37889062373143906);
+    assert(fib(82) == 61305790721611591);
+    assert(fib(83) == 99194853094755497);
+    assert(fib(84) == 160500643816367088);
+    assert(fib(85) == 259695496911122585);
+    assert(fib(86) == 420196140727489673);
+    assert(fib(87) == 679891637638612258);
+    assert(fib(88) == 1100087778366101931);
+    assert(fib(89) == 1779979416004714189);
+    assert(fib(90) == 2880067194370816120);
+    assert(fib(91) == 4660046610375530309);
+    assert(fib(92) == 7540113804746346429);
+
+    // Test for invalid Fibonacci numbers
+    try {
+        fib(MAX + 1);
+        assert(false && "Expected an invalid_argument exception to be thrown");
+    } catch (const std::invalid_argument& e) {
+        const std::string expected_message = "Cannot compute for n>=" + std::to_string(MAX) +
+                                             " due to limit of 64-bit integers";
+        assert(e.what() == expected_message);
     }
+
+    std::cout << "All Fibonacci tests have successfully passed!\n";
+}
+
+/**
+ * @brief Main Function
+ * @returns 0 on exit
+ */
+int main() {
+    test();  // run self-test implementations
     return 0;
 }
diff --git a/numerical_methods/successive_approximation.cpp b/numerical_methods/successive_approximation.cpp
@@ -18,7 +18,7 @@ static float eqd(float y) { return 0.5 * (cos(y) + 2); }
 
 /** Main function */
 int main() {
-    float y, x1, x2, x3, sum, s, a, f1, f2, gd;
+    float y, x1, x2, sum;
     int i, n;
 
     for (i = 0; i < 10; i++) {
diff --git a/others/matrix_exponentiation.cpp b/others/matrix_exponentiation.cpp
@@ -128,7 +128,7 @@ int main() {
     cout.tie(0);
     ll t;
     cin >> t;
-    ll i, j, x;
+    ll i, x;
     while (t--) {
         cin >> mat_size;
         for (i = 0; i < mat_size; i++) {
diff --git a/range_queries/mo.cpp b/range_queries/mo.cpp
@@ -29,7 +29,7 @@ bool mycmp(query x, query y) {
 }
 
 int main() {
-    int n, t, i, j, k = 0;
+    int n, t, i;
     scanf("%d", &n);
     for (i = 0; i < n; i++) scanf("%d", &a[i]);
     bucket_size = ceil(sqrt(n));
diff --git a/sorting/merge_sort.cpp b/sorting/merge_sort.cpp
diff --git a/sorting/quick_sort.cpp b/sorting/quick_sort.cpp
diff --git a/sorting/recursive_bubble_sort.cpp b/sorting/recursive_bubble_sort.cpp

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ class RBtree`
`33`	`33`	`};`
`34`	`34`	`void RBtree::insert()`
`35`	`35`	`{`
`36`		`- int z, i = 0;`
	`36`	`+ int z;`
`37`	`37`	`cout << "\nEnter key of the node to be inserted: ";`
`38`	`38`	`cin >> z;`
`39`	`39`	`node p, q;`