Merge branch 'master' into Lazeeez

ciphers/uint128_t.hpp

@@ -462,7 +462,7 @@ class uint128_t {
         tmp <<= left;
         uint128_t quotient(0);
         uint128_t zero(0);
-        while (left >= 0 && tmp2 >= p) {
+        while (tmp2 >= p) {
             uint16_t shf = tmp2._lez() - tmp._lez();
             if (shf) {
                 tmp >>= shf;

ciphers/uint256_t.hpp

@@ -429,7 +429,7 @@ class uint256_t {
         tmp <<= left;
         uint256_t quotient(0);
         uint256_t zero(0);
-        while (left >= 0 && tmp2 >= p) {
+        while (tmp2 >= p) {
             uint16_t shf = tmp2._lez() - tmp._lez();
             if (shf) {
                 tmp >>= shf;

data_structures/reverse_a_linked_list.cpp

@@ -121,12 +121,10 @@ void list::reverseList() {
  * @returns the top element of the list
  */
 int32_t list::top() {
-    try {
-        if (!isEmpty()) {
-            return head->val;
-        }
-    } catch (const std::exception &e) {
-        std::cerr << "List is empty" << e.what() << '\n';
+    if (!isEmpty()) {
+        return head->val;
+    } else {
+        throw std::logic_error("List is empty");
     }
 }
 /**
@@ -134,16 +132,14 @@ int32_t list::top() {
  *  @returns the last element of the list
  */
 int32_t list::last() {
-    try {
-        if (!isEmpty()) {
-            Node *t = head;
-            while (t->next != nullptr) {
-                t = t->next;
-            }
-            return t->val;
+    if (!isEmpty()) {
+        Node *t = head;
+        while (t->next != nullptr) {
+            t = t->next;
         }
-    } catch (const std::exception &e) {
-        std::cerr << "List is empty" << e.what() << '\n';
+        return t->val;
+    } else {
+        throw std::logic_error("List is empty");
     }
 }
 /**
@@ -164,7 +160,7 @@ int32_t list::traverse(int index) {
 
     /* if we get to this line,the caller was asking for a non-existent element
     so we assert fail */
-    assert(0);
+    exit(1);
 }
 
 }  // namespace linked_list

numerical_methods/composite_simpson_rule.cpp

@@ -35,8 +35,9 @@
  *
  */
 
-#include <cassert>     /// for assert
-#include <cmath>       /// for math functions
+#include <cassert>  /// for assert
+#include <cmath>    /// for math functions
+#include <cmath>
 #include <cstdint>     /// for integer allocation
 #include <cstdlib>     /// for std::atof
 #include <functional>  /// for std::function
@@ -64,13 +65,13 @@ namespace simpson_method {
  * @returns the result of the integration
  */
 double evaluate_by_simpson(std::int32_t N, double h, double a,
-                           std::function<double(double)> func) {
+                           const std::function<double(double)>& func) {
     std::map<std::int32_t, double>
         data_table;  // Contains the data points. key: i, value: f(xi)
     double xi = a;   // Initialize xi to the starting point x0 = a
 
     // Create the data table
-    double temp;
+    double temp = NAN;
     for (std::int32_t i = 0; i <= N; i++) {
         temp = func(xi);
         data_table.insert(
@@ -82,12 +83,13 @@ double evaluate_by_simpson(std::int32_t N, double h, double a,
     // Remember: f(x0) + 4*f(x1) + 2*f(x2) + ... + 2*f(xN-2) + 4*f(xN-1) + f(xN)
     double evaluate_integral = 0;
     for (std::int32_t i = 0; i <= N; i++) {
-        if (i == 0 || i == N)
+        if (i == 0 || i == N) {
             evaluate_integral += data_table.at(i);
-        else if (i % 2 == 1)
+        } else if (i % 2 == 1) {
             evaluate_integral += 4 * data_table.at(i);
-        else
+        } else {
             evaluate_integral += 2 * data_table.at(i);
+        }
     }
 
     // Multiply by the coefficient h/3
@@ -170,7 +172,7 @@ int main(int argc, char** argv) {
                           /// interval. MUST BE EVEN
     double a = 1, b = 3;  /// Starting and ending point of the integration in
                           /// the real axis
-    double h;             /// Step, calculated by a, b and N
+    double h = NAN;       /// Step, calculated by a, b and N
 
     bool used_argv_parameters =
         false;  // If argv parameters are used then the assert must be omitted
@@ -180,18 +182,20 @@ int main(int argc, char** argv) {
     // displaying messages)
     if (argc == 4) {
         N = std::atoi(argv[1]);
-        a = (double)std::atof(argv[2]);
-        b = (double)std::atof(argv[3]);
+        a = std::atof(argv[2]);
+        b = std::atof(argv[3]);
         // Check if a<b else abort
         assert(a < b && "a has to be less than b");
         assert(N > 0 && "N has to be > 0");
-        if (N < 16 || a != 1 || b != 3)
+        if (N < 16 || a != 1 || b != 3) {
             used_argv_parameters = true;
+        }
         std::cout << "You selected N=" << N << ", a=" << a << ", b=" << b
                   << std::endl;
-    } else
+    } else {
         std::cout << "Default N=" << N << ", a=" << a << ", b=" << b
                   << std::endl;
+    }
 
     // Find the step
     h = (b - a) / N;

numerical_methods/fast_fourier_transform.cpp

@@ -6,7 +6,8 @@
  * discrete Fourier transform (DFT) of a sequence, or its inverse (IDFT).
  * @details
  * This
- * algorithm has application in use case scenario where a user wants to find points of a
+ * algorithm has application in use case scenario where a user wants to find
+ points of a
  * function
  * in a short time by just using the coefficients of the polynomial
  * function.
@@ -56,8 +57,9 @@ std::complex<double> *FastFourierTransform(std::complex<double> *p, uint8_t n) {
         if (j % 2 == 0) {
             pe[k1++] = p[j];  /// Assigning values of even Coefficients
 
-        } else
+        } else {
             po[k2++] = p[j];  /// Assigning value of odd Coefficients
+        }
     }
 
     std::complex<double> *ye =
@@ -80,11 +82,9 @@ std::complex<double> *FastFourierTransform(std::complex<double> *p, uint8_t n) {
         k2++;
     }
 
-    if(n!=2){
-     
+    if (n != 2) {
         delete[] pe;
         delete[] po;
-        
     }
 
     delete[] ye;  /// Deleting dynamic array ye
@@ -123,9 +123,11 @@ static void test() {
         {10, 0}, {-2, -2}, {-2, 0}, {-2, 2}};  /// True Answer for test case 2
 
     std::complex<double> *o1 = numerical_methods::FastFourierTransform(t1, n1);
-    std::complex<double> *t3=o1;  /// Temporary variable used to delete memory location of o1
+    std::complex<double> *t3 =
+        o1;  /// Temporary variable used to delete memory location of o1
     std::complex<double> *o2 = numerical_methods::FastFourierTransform(t2, n2);
-    std::complex<double> *t4=o2; /// Temporary variable used to delete memory location of o2
+    std::complex<double> *t4 =
+        o2;  /// Temporary variable used to delete memory location of o2
     for (uint8_t i = 0; i < n1; i++) {
         assert((r1[i].real() - o1->real() < 0.000000000001) &&
                (r1[i].imag() - o1->imag() <
@@ -142,7 +144,6 @@ static void test() {
         o2++;
     }
 
-    
     delete[] t1;
     delete[] t2;
     delete[] t3;
@@ -160,6 +161,6 @@ static void test() {
 
 int main(int argc, char const *argv[]) {
     test();  //  run self-test implementations
-              //  with 2 defined test cases
+             //  with 2 defined test cases
     return 0;
 }