diff --git a/ciphers/uint128_t.hpp b/ciphers/uint128_t.hpp index 917d4a954..d50cb4ffb 100644 --- a/ciphers/uint128_t.hpp +++ b/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; diff --git a/ciphers/uint256_t.hpp b/ciphers/uint256_t.hpp index ad300ed37..a776d4cb0 100644 --- a/ciphers/uint256_t.hpp +++ b/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; diff --git a/data_structures/reverse_a_linked_list.cpp b/data_structures/reverse_a_linked_list.cpp index e7ce44ee0..de92065b4 100644 --- a/data_structures/reverse_a_linked_list.cpp +++ b/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 diff --git a/numerical_methods/babylonian_method.cpp b/numerical_methods/babylonian_method.cpp index b18bc0dc4..a70fa993e 100644 --- a/numerical_methods/babylonian_method.cpp +++ b/numerical_methods/babylonian_method.cpp @@ -9,11 +9,10 @@ * @author [Ameya Chawla](https://github.com/ameyachawlaggsipu) */ -#include /// for assert +#include /// for assert +#include #include /// for IO operations -#include "math.h" - /** * @namespace numerical_methods * @brief Numerical algorithms/methods diff --git a/numerical_methods/composite_simpson_rule.cpp b/numerical_methods/composite_simpson_rule.cpp index 9a5e8c180..2ca58cbe4 100644 --- a/numerical_methods/composite_simpson_rule.cpp +++ b/numerical_methods/composite_simpson_rule.cpp @@ -35,8 +35,9 @@ * */ -#include /// for assert -#include /// for math functions +#include /// for assert +#include /// for math functions +#include #include /// for integer allocation #include /// for std::atof #include /// 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 func) { + const std::function& func) { std::map 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 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; diff --git a/numerical_methods/fast_fourier_transform.cpp b/numerical_methods/fast_fourier_transform.cpp index 86e9d6d79..23a6c8a1f 100644 --- a/numerical_methods/fast_fourier_transform.cpp +++ b/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 *FastFourierTransform(std::complex *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 *ye = @@ -79,12 +81,10 @@ std::complex *FastFourierTransform(std::complex *p, uint8_t n) { k1++; 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 *o1 = numerical_methods::FastFourierTransform(t1, n1); - std::complex *t3=o1; /// Temporary variable used to delete memory location of o1 + std::complex *t3 = + o1; /// Temporary variable used to delete memory location of o1 std::complex *o2 = numerical_methods::FastFourierTransform(t2, n2); - std::complex *t4=o2; /// Temporary variable used to delete memory location of o2 + std::complex *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() < @@ -141,8 +143,7 @@ static void test() { /// values for test case 2 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; } diff --git a/numerical_methods/inverse_fast_fourier_transform.cpp b/numerical_methods/inverse_fast_fourier_transform.cpp index d2248be7b..0970d40cd 100644 --- a/numerical_methods/inverse_fast_fourier_transform.cpp +++ b/numerical_methods/inverse_fast_fourier_transform.cpp @@ -4,10 +4,10 @@ * (IFFT)](https://www.geeksforgeeks.org/python-inverse-fast-fourier-transformation/) * is an algorithm that computes the inverse fourier transform. * @details - * This algorithm has an application in use case scenario where a user wants find coefficients of - * a function in a short time by just using points generated by DFT. - * Time complexity - * this algorithm computes the IDFT in O(nlogn) time in comparison to traditional O(n^2). + * This algorithm has an application in use case scenario where a user wants + * find coefficients of a function in a short time by just using points + * generated by DFT. Time complexity this algorithm computes the IDFT in + * O(nlogn) time in comparison to traditional O(n^2). * @author [Ameya Chawla](https://github.com/ameyachawlaggsipu) */ @@ -23,14 +23,15 @@ */ namespace numerical_methods { /** - * @brief InverseFastFourierTransform is a recursive function which returns list of - * complex numbers + * @brief InverseFastFourierTransform is a recursive function which returns list + * of complex numbers * @param p List of Coefficents in form of complex numbers * @param n Count of elements in list p * @returns p if n==1 * @returns y if n!=1 */ -std::complex *InverseFastFourierTransform(std::complex *p, uint8_t n) { +std::complex *InverseFastFourierTransform(std::complex *p, + uint8_t n) { if (n == 1) { return p; /// Base Case To return } @@ -39,9 +40,9 @@ std::complex *InverseFastFourierTransform(std::complex *p, uint8 std::complex om = std::complex( cos(2 * pi / n), sin(2 * pi / n)); /// Calculating value of omega - - om.real(om.real()/n); /// One change in comparison with DFT - om.imag(om.imag()/n); /// One change in comparison with DFT + + om.real(om.real() / n); /// One change in comparison with DFT + om.imag(om.imag() / n); /// One change in comparison with DFT auto *pe = new std::complex[n / 2]; /// Coefficients of even power @@ -52,8 +53,9 @@ std::complex *InverseFastFourierTransform(std::complex *p, uint8 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 *ye = @@ -75,12 +77,10 @@ std::complex *InverseFastFourierTransform(std::complex *p, uint8 k1++; k2++; } - - if(n!=2){ - + + if (n != 2) { delete[] pe; delete[] po; - } delete[] ye; /// Deleting dynamic array ye @@ -118,16 +118,17 @@ static void test() { std::vector> r2 = { {1, 0}, {2, 0}, {3, 0}, {4, 0}}; /// True Answer for test case 2 - std::complex *o1 = numerical_methods::InverseFastFourierTransform(t1, n1); - - std::complex *o2 = numerical_methods::InverseFastFourierTransform(t2, n2); + std::complex *o1 = + numerical_methods::InverseFastFourierTransform(t1, n1); + + std::complex *o2 = + numerical_methods::InverseFastFourierTransform(t2, n2); for (uint8_t i = 0; i < n1; i++) { assert((r1[i].real() - o1[i].real() < 0.000000000001) && (r1[i].imag() - o1[i].imag() < 0.000000000001)); /// Comparing for both real and imaginary /// values for test case 1 - } for (uint8_t i = 0; i < n2; i++) { @@ -135,10 +136,8 @@ static void test() { (r2[i].imag() - o2[i].imag() < 0.000000000001)); /// Comparing for both real and imaginary /// values for test case 2 - } - - + delete[] t1; delete[] t2; delete[] o1;