-
+
- Generated on Sun Jun 28 2020 15:07:08 for Algorithms_in_C by
+
+
1.8.18
+
|
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
| C_big_int | |
| C_large_num | |
| Cadaline | |
| Carray_3d | |
| CAVLnode | |
| CBSTIterator | |
| CCArray | |
| Ccontour | |
| Cdata | |
| CDict | |
| Cdynamic_array | |
| CEdge | |
| Celem | |
| CGraph | |
| CGraphRep | |
| Chash_set_t | |
| CL | |
| Cmax_heap | |
| Cmin_heap | |
| CNode | |
| Cnode | |
| Cpid | |
| Cqueue | |
| CQueueRep | |
| CStack | |
| Csubset | |
| CT | |
| Ctnode | |
| CTrieNode | |
| Cword_count_word |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
|
+contour | +GraphRep | +node | +tnode | +|||
|
+
|
+
|
+TrieNode | +||||
| _big_int | +
|
+||||||
| _large_num | +data | +hash_set_t | +pid | +||||
|
+Dict | +
|
+
|
+word_count_word | +|||
| dynamic_array | +|||||||
| adaline | +
|
+L | +queue | +||||
| array_3d | +
|
+QueueRep | +|||||
| AVLnode | +Edge | +
|
+|||||
|
+elem | +max_heap | +|||||
|
+min_heap | +Stack | +|||||
| BSTIterator | +
|
+subset | +|||||
|
+Graph | +
|
+|||||
| Node | +|||||||
| CArray | +T | +||||||
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +float | kP |
| +float | kI |
| +float | kD |
| +float | lastError |
| +float | integral |
PID Controller
+The PID controller is a linear control algorithm that has three terms:
Terms of the controller can be removed by setting their gain to 0, creating a PI (kD = 0) or PD (kI = 0) controller. Depending on the control problem at hand, some terms may not increase the performance of the system, or may have a negative effect.
+For a more mathematical expanation of the PID Controller, see https://en.wikipedia.org/wiki/PID_controller
+Limitations of this implementation:
Inputs: e(t) - Current error at time t. For example, how far a servo is off the desired angle Output: u(t) - Controller output at time t.
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Kohonen self organizing map (data tracing) +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Macros | |
| #define | _USE_MATH_DEFINES |
| #define | max(a, b) (((a) > (b)) ? (a) : (b)) |
| #define | min(a, b) (((a) < (b)) ? (a) : (b)) |
+Functions | |
| double | _random (double a, double b) |
| int | save_nd_data (const char *fname, double **X, int num_points, int num_features) |
| void | get_min_1d (double const *X, int N, double *val, int *idx) |
| void | update_weights (double const *x, double *const *W, double *D, int num_out, int num_features, double alpha, int R) |
| void | kohonen_som_tracer (double **X, double *const *W, int num_samples, int num_features, int num_out, double alpha_min) |
| void | test_circle (double *const *data, int N) |
| void | test1 () |
| void | test_lamniscate (double *const *data, int N) |
| void | test2 () |
| void | test_3d_classes (double *const *data, int N) |
| void | test3 () |
| double | get_clock_diff (clock_t start_t, clock_t end_t) |
| int | main (int argc, char **argv) |
Kohonen self organizing map (data tracing)
+ +This example implements a powerful self organizing map algorithm. The algorithm creates a connected network of weights that closely follows the given data points. This this creates a chain of nodes that resembles the given input shape.
| #define _USE_MATH_DEFINES | +
required for MS Visual C
+ +| #define max | +( | ++ | a, | +
| + | + | + | b | +
| + | ) | +(((a) > (b)) ? (a) : (b)) | +
shorthand for maximum value \
+ +| #define min | +( | ++ | a, | +
| + | + | + | b | +
| + | ) | +(((a) < (b)) ? (a) : (b)) | +
shorthand for minimum value \
+ +| double _random | +( | +double | +a, | +
| + | + | double | +b | +
| + | ) | ++ |
Helper function to generate a random number in a given interval.
+ Steps:
r1 = rand() % 100 gets a random number between 0 and 99r2 = r1 / 100 converts random number to be between 0 and 0.99+\[ y = (b - a) \times \frac{\text{(random number between 0 and RAND_MAX)} \; \text{mod}\; 100}{100} + a \] +
+| [in] | a | lower limit |
| [in] | b | upper limit |
| double get_clock_diff | +( | +clock_t | +start_t, | +
| + | + | clock_t | +end_t | +
| + | ) | ++ |
| void get_min_1d | +( | +double const * | +X, | +
| + | + | int | +N, | +
| + | + | double * | +val, | +
| + | + | int * | +idx | +
| + | ) | ++ |
Get minimum value and index of the value in a vector
| [in] | x | vector to search |
| [in] | N | number of points in the vector |
| [out] | val | minimum value found |
| [out] | idx | index where minimum value was found |
| void kohonen_som_tracer | +( | +double ** | +X, | +
| + | + | double *const * | +W, | +
| + | + | int | +num_samples, | +
| + | + | int | +num_features, | +
| + | + | int | +num_out, | +
| + | + | double | +alpha_min | +
| + | ) | ++ |
Apply incremental algorithm with updating neighborhood and learning rates on all samples in the given datset.
+| [in] | X | data set |
| [in,out] | W | weights matrix |
| [in] | D | temporary vector to store distances |
| [in] | num_samples | number of output points |
| [in] | num_features | number of features per input sample |
| [in] | num_out | number of output points |
| [in] | alpha_min | terminal value of alpha |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
| int save_nd_data | +( | +const char * | +fname, | +
| + | + | double ** | +X, | +
| + | + | int | +num_points, | +
| + | + | int | +num_features | +
| + | ) | ++ |
Save a given n-dimensional data martix to file.
+| [in] | fname | filename to save in (gets overwriten without confirmation) |
| [in] | X | matrix to save |
| [in] | num_points | rows in the matrix = number of points |
| [in] | num_features | columns in the matrix = dimensions of points |
| void test1 | +( | +) | ++ |
Test that creates a random set of points distributed near the circumference of a circle and trains an SOM that finds that circular pattern. The following CSV files are created to validate the execution:
test1.csv: random test samples points with a circular patternw11.csv: initial random mapw12.csv: trained SOM mapThe outputs can be readily plotted in gnuplot using the following snippet
| void test2 | +( | +) | ++ |
Test that creates a random set of points distributed near the locus of the Lamniscate of Gerono and trains an SOM that finds that circular pattern. The following CSV files are created to validate the execution:
test2.csv: random test samples points with a lamniscate patternw21.csv: initial random mapw22.csv: trained SOM mapThe outputs can be readily plotted in gnuplot using the following snippet
| void test3 | +( | +) | ++ |
Test that creates a random set of points distributed in six clusters in 3D space. The following CSV files are created to validate the execution:
test3.csv: random test samples points with a circular patternw31.csv: initial random mapw32.csv: trained SOM mapThe outputs can be readily plotted in gnuplot using the following snippet
| void test_3d_classes | +( | +double *const * | +data, | +
| + | + | int | +N | +
| + | ) | ++ |
Creates a random set of points distributed in four clusters in 3D space with centroids at the points
| [out] | data | matrix to store data in |
| [in] | N | number of points required |
| void test_circle | +( | +double *const * | +data, | +
| + | + | int | +N | +
| + | ) | ++ |
Creates a random set of points distributed near the circumference of a circle and trains an SOM that finds that circular pattern. The generating function is
+\begin{eqnarray*} r &\in& [1-\delta r, 1+\delta r)\\ \theta &\in& [0, 2\pi)\\ x &=& r\cos\theta\\ y &=& r\sin\theta \end{eqnarray*} +
+| [out] | data | matrix to store data in |
| [in] | N | number of points required |
| void test_lamniscate | +( | +double *const * | +data, | +
| + | + | int | +N | +
| + | ) | ++ |
Creates a random set of points distributed near the locus of the Lamniscate of Gerono.
+\begin{eqnarray*} \delta r &=& 0.2\\ \delta x &\in& [-\delta r, \delta r)\\ \delta y &\in& [-\delta r, \delta r)\\ \theta &\in& [0, \pi)\\ x &=& \delta x + \cos\theta\\ y &=& \delta y + \frac{\sin(2\theta)}{2} \end{eqnarray*} +
+| [out] | data | matrix to store data in |
| [in] | N | number of points required |
| void update_weights | +( | +double const * | +x, | +
| + | + | double *const * | +W, | +
| + | + | double * | +D, | +
| + | + | int | +num_out, | +
| + | + | int | +num_features, | +
| + | + | double | +alpha, | +
| + | + | int | +R | +
| + | ) | ++ |
Update weights of the SOM using Kohonen algorithm
+| [in] | X | data point |
| [in,out] | W | weights matrix |
| [in,out] | D | temporary vector to store distances |
| [in] | num_out | number of output points |
| [in] | num_features | number of features per input sample |
| [in] | alpha | learning rate \(0<\alpha\le1\) |
| [in] | R | neighborhood range |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>+Functions | |
| int | is_palindromic (unsigned int n) |
| int | main (void) |
Problem 4 solution
+| int is_palindromic | +( | +unsigned int | +n | ) | ++ |
Check if number is palindromic
| [in] | n | number to check |
| int main | +( | +void | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 10 solution +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>+Functions | |
| char | is_prime (unsigned long n) |
| unsigned long long | sum_of_primes (unsigned long N) |
| int | main (int argc, char *argv[]) |
Problem 10 solution
+ +| char is_prime | +( | +unsigned long | +n | ) | ++ |
| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main function
+| unsigned long long sum_of_primes | +( | +unsigned long | +N | ) | ++ |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>+Functions | |
| int | main () |
Problem 2 solution
+Problem:
+Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 1,2,3,5,8,13,21,34,55,89,.. By considering the terms in the Fibonacci sequence whose values do not exceed n, find the sum of the even-valued terms. e.g. for n=10, we have {2,8}, sum is 10.
| int main | +( | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| int | dim1 |
| int | dim2 |
| int | dim3 |
| double * | data |
to store info regarding 3D arrays
+| double* array_3d::data | +
pointer to data
+ +| int array_3d::dim1 | +
lengths of first dimension
+ +| int array_3d::dim2 | +
lengths of second dimension
+ +| int array_3d::dim3 | +
lengths of thirddimension
+ + 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +unsigned | capacity |
| +unsigned | length |
| +void ** | values |
| +void ** | keys |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
This is a modular generic stack data-structure. The stack is self growing.
+You need to only import the stack.h
+Initializes the stack with a capacity of 10 elements.
+pushs the argument onto the stack
+pop: pops the top element of the stack from the stack.
assumes: stack not empty. +
gets the number of elements of the stack.
+returns 1 if stack is empty otherwise 0.
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>#include <stdlib.h>+Functions | |
| int | main (void) |
Problem 7 solution
+| int main | +( | +void | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Solve a multivariable first order ordinary differential equation (ODEs) using midpoint Euler method +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Macros | |
| #define | order 2 |
+Functions | |
| void | problem (const double *x, double *y, double *dy) |
| Problem statement for a system with first-order differential equations. Updates the system differential variables. More... | |
| void | exact_solution (const double *x, double *y) |
| Exact solution of the problem. Used for solution comparison. More... | |
| void | midpoint_euler_step (double dx, double *x, double *y, double *dy) |
| Compute next step approximation using the midpoint-Euler method. More... | |
| double | midpoint_euler (double dx, double x0, double x_max, double *y, char save_to_file) |
| Compute approximation using the midpoint-Euler method in the given limits. More... | |
| int | main (int argc, char *argv[]) |
Solve a multivariable first order ordinary differential equation (ODEs) using midpoint Euler method
+ +The ODE being solved is:
+\begin{eqnarray*} \dot{u} &=& v\\ \dot{v} &=& -\omega^2 u\\ \omega &=& 1\\ [x_0, u_0, v_0] &=& [0,1,0]\qquad\ldots\text{(initial values)} \end{eqnarray*} +
+The exact solution for the above problem is:
+\begin{eqnarray*} u(x) &=& \cos(x)\\ v(x) &=& -\sin(x)\\ \end{eqnarray*} +
+ The computation results are stored to a text file midpoint_euler.csv and the exact soltuion results in exact.csv for comparison. 
To implement Van der Pol oscillator, change the problem function to:
| #define order 2 | +
number of dependent variables in problem
+ +| void exact_solution | +( | +const double * | +x, | +
| + | + | double * | +y | +
| + | ) | ++ |
| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main Function
+| double midpoint_euler | +( | +double | +dx, | +
| + | + | double | +x0, | +
| + | + | double | +x_max, | +
| + | + | double * | +y, | +
| + | + | char | +save_to_file | +
| + | ) | ++ |
Compute approximation using the midpoint-Euler method in the given limits.
+| [in] | dx | step size |
| [in] | x0 | initial value of independent variable |
| [in] | x_max | final value of independent variable |
| [in,out] | y | take \(y_n\) and compute \(y_{n+1}\) |
| [in] | save_to_file | flag to save results to a CSV file (1) or not (0) |
| void midpoint_euler_step | +( | +double | +dx, | +
| + | + | double * | +x, | +
| + | + | double * | +y, | +
| + | + | double * | +dy | +
| + | ) | ++ |
Compute next step approximation using the midpoint-Euler method.
++\[y_{n+1} = y_n + dx\, f\left(x_n+\frac{1}{2}dx, y_n + \frac{1}{2}dx\,f\left(x_n,y_n\right)\right)\] +
+| [in] | dx | step size |
| [in,out] | x | take \(x_n\) and compute \(x_{n+1}\) |
| [in,out] | y | take \(y_n\) and compute \(y_{n+1}\) |
| [in,out] | dy | compute \(y_n+\frac{1}{2}dx\,f\left(x_n,y_n\right)\) |
| void problem | +( | +const double * | +x, | +
| + | + | double * | +y, | +
| + | + | double * | +dy | +
| + | ) | ++ |
Problem statement for a system with first-order differential equations. Updates the system differential variables.
+| [in] | x | independent variable(s) |
| [in,out] | y | dependent variable(s) |
| [in,out] | dy | first-derivative of dependent variable(s) |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 26 solution +More...
+#include <stdio.h>#include <stdlib.h>#include <string.h>#include <time.h>+Macros | |
| #define | MAX_DENO 2000 |
| #define | MAX_LEN (MAX_DENO + 10) |
+Functions | |
| int | compare (const void *a, const void *b) |
| int | main (int argc, char *argv[]) |
Problem 26 solution
+ +| #define MAX_DENO 2000 | +
limit of unit fractions
+ +| #define MAX_LEN (MAX_DENO + 10) | +
length of resulting recurring fraction number
+ +| int compare | +( | +const void * | +a, | +
| + | + | const void * | +b | +
| + | ) | ++ |
| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +int | items [SIZE] |
| +int | front |
| +int | rear |
| +struct node * | front |
| +struct node * | rear |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>#include <stdlib.h>#include <string.h>+Functions | |
| int | main (int argc, char *argv[]) |
Problem 8 solution
+ +| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +double | eta |
| learning rate of the algorithm | |
| +double * | weights |
| weights of the neural network | |
| +int | num_weights |
| number of weights of the neural network | |
structure to hold adaline model parameters
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>+Functions | |
| int | main () |
Problem 1 solution
+If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3,5,6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below N.
+This solution is based on the pattern that the successive numbers in the series follow: 0+3,+2,+1,+3,+1,+2,+3.
+| int main | +( | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>+Functions | |
| int | main () |
Problem 3 solution
+Problem:
+The prime factors of 13195 are 5,7,13 and 29. What is the largest prime factor of a given number N? e.g. for 10, largest prime factor = 5. For 17, largest prime factor = 17.
+| int main | +( | +) | ++ |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Kohonen self organizing map (topological map) +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Data Structures | |
| struct | array_3d |
+Macros | |
| #define | _USE_MATH_DEFINES |
| #define | max(a, b) (((a) > (b)) ? (a) : (b)) |
| #define | min(a, b) (((a) < (b)) ? (a) : (b)) |
+Functions | |
| double * | data_3d (const struct array_3d *arr, int x, int y, int z) |
| double | _random (double a, double b) |
| int | save_2d_data (const char *fname, double **X, int num_points, int num_features) |
| int | save_u_matrix (const char *fname, struct array_3d *W) |
| void | get_min_2d (double **X, int N, double *val, int *x_idx, int *y_idx) |
| double | update_weights (const double *X, struct array_3d *W, double **D, int num_out, int num_features, double alpha, int R) |
| void | kohonen_som (double **X, struct array_3d *W, int num_samples, int num_features, int num_out, double alpha_min) |
| void | test_2d_classes (double *const *data, int N) |
| void | test1 () |
| void | test_3d_classes1 (double *const *data, int N) |
| void | test2 () |
| void | test_3d_classes2 (double *const *data, int N) |
| void | test3 () |
| double | get_clock_diff (clock_t start_t, clock_t end_t) |
| int | main (int argc, char **argv) |
Kohonen self organizing map (topological map)
+
| #define _USE_MATH_DEFINES | +
required for MS Visual C
+ +| #define max | +( | ++ | a, | +
| + | + | + | b | +
| + | ) | +(((a) > (b)) ? (a) : (b)) | +
shorthand for maximum value \
+ +| #define min | +( | ++ | a, | +
| + | + | + | b | +
| + | ) | +(((a) < (b)) ? (a) : (b)) | +
shorthand for minimum value \
+ +| double _random | +( | +double | +a, | +
| + | + | double | +b | +
| + | ) | ++ |
Helper function to generate a random number in a given interval.
+ Steps:
r1 = rand() % 100 gets a random number between 0 and 99r2 = r1 / 100 converts random number to be between 0 and 0.99+\[ y = (b - a) \times \frac{\text{(random number between 0 and RAND_MAX)} \; \text{mod}\; 100}{100} + a \] +
+| [in] | a | lower limit |
| [in] | b | upper limit |
| double* data_3d | +( | +const struct array_3d * | +arr, | +
| + | + | int | +x, | +
| + | + | int | +y, | +
| + | + | int | +z | +
| + | ) | ++ |
Function that returns the pointer to (x, y, z) ^th location in the linear 3D array given by:
+\[ X_{i,j,k} = i\times M\times N + j\times N + k \] +
+where \(L\), \(M\) and \(N\) are the 3D matrix dimensions.
| [in] | arr | pointer to array_3d structure |
| [in] | x | first index |
| [in] | y | second index |
| [in] | z | third index |
| double get_clock_diff | +( | +clock_t | +start_t, | +
| + | + | clock_t | +end_t | +
| + | ) | ++ |
| void get_min_2d | +( | +double ** | +X, | +
| + | + | int | +N, | +
| + | + | double * | +val, | +
| + | + | int * | +x_idx, | +
| + | + | int * | +y_idx | +
| + | ) | ++ |
Get minimum value and index of the value in a matrix
| [in] | X | matrix to search |
| [in] | N | number of points in the vector |
| [out] | val | minimum value found |
| [out] | idx_x | x-index where minimum value was found |
| [out] | idx_y | y-index where minimum value was found |
| void kohonen_som | +( | +double ** | +X, | +
| + | + | struct array_3d * | +W, | +
| + | + | int | +num_samples, | +
| + | + | int | +num_features, | +
| + | + | int | +num_out, | +
| + | + | double | +alpha_min | +
| + | ) | ++ |
Apply incremental algorithm with updating neighborhood and learning rates on all samples in the given datset.
+| [in] | X | data set |
| [in,out] | W | weights matrix |
| [in] | D | temporary vector to store distances |
| [in] | num_samples | number of output points |
| [in] | num_features | number of features per input sample |
| [in] | num_out | number of output points |
| [in] | alpha_min | terminal value of alpha |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
| int save_2d_data | +( | +const char * | +fname, | +
| + | + | double ** | +X, | +
| + | + | int | +num_points, | +
| + | + | int | +num_features | +
| + | ) | ++ |
Save a given n-dimensional data martix to file.
+| [in] | fname | filename to save in (gets overwriten without confirmation) |
| [in] | X | matrix to save |
| [in] | num_points | rows in the matrix = number of points |
| [in] | num_features | columns in the matrix = dimensions of points |
| int save_u_matrix | +( | +const char * | +fname, | +
| + | + | struct array_3d * | +W | +
| + | ) | ++ |
Create the distance matrix or U-matrix from the trained weights and save to disk.
+| [in] | fname | filename to save in (gets overwriten without confirmation) |
| [in] | W | model matrix to save |
| void test1 | +( | +) | ++ |
Test that creates a random set of points distributed in four clusters in 2D space and trains an SOM that finds the topological pattern. The following CSV files are created to validate the execution:
test1.csv: random test samples points with a circular patternw11.csv: initial random U-matrixw12.csv: trained SOM U-matrix | void test2 | +( | +) | ++ |
Test that creates a random set of points distributed in 4 clusters in 3D space and trains an SOM that finds the topological pattern. The following CSV files are created to validate the execution:
test2.csv: random test samples pointsw21.csv: initial random U-matrixw22.csv: trained SOM U-matrix | void test3 | +( | +) | ++ |
Test that creates a random set of points distributed in eight clusters in 3D space and trains an SOM that finds the topological pattern. The following CSV files are created to validate the execution:
test3.csv: random test samples pointsw31.csv: initial random U-matrixw32.csv: trained SOM U-matrix | void test_2d_classes | +( | +double *const * | +data, | +
| + | + | int | +N | +
| + | ) | ++ |
Creates a random set of points distributed in four clusters in 3D space with centroids at the points
| [out] | data | matrix to store data in |
| [in] | N | number of points required |
| void test_3d_classes1 | +( | +double *const * | +data, | +
| + | + | int | +N | +
| + | ) | ++ |
Creates a random set of points distributed in four clusters in 3D space with centroids at the points
| [out] | data | matrix to store data in |
| [in] | N | number of points required |
| void test_3d_classes2 | +( | +double *const * | +data, | +
| + | + | int | +N | +
| + | ) | ++ |
Creates a random set of points distributed in four clusters in 3D space with centroids at the points
| [out] | data | matrix to store data in |
| [in] | N | number of points required |
| double update_weights | +( | +const double * | +X, | +
| + | + | struct array_3d * | +W, | +
| + | + | double ** | +D, | +
| + | + | int | +num_out, | +
| + | + | int | +num_features, | +
| + | + | double | +alpha, | +
| + | + | int | +R | +
| + | ) | ++ |
Update weights of the SOM using Kohonen algorithm
+| [in] | X | data point |
| [in,out] | W | weights matrix |
| [in,out] | D | temporary vector to store distances |
| [in] | num_out | number of output points |
| [in] | num_features | number of features per input sample |
| [in] | alpha | learning rate \(0<\alpha\le1\) |
| [in] | R | neighborhood range |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| char * | digits |
| unsigned int | num_digits |
dynamically large number
+| char* _large_num::digits | +
array to store individual digits
+ +| unsigned int _large_num::num_digits | +
number of digits in the number
+ + 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +int * | values |
| +int | CurrentIndex |
| +int | NumberOfNodes |
Definition for a binary tree node. struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; };
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Solve a multivariable first order ordinary differential equation (ODEs) using forward Euler method +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Macros | |
| #define | order 2 |
+Functions | |
| void | problem (const double *x, double *y, double *dy) |
| Problem statement for a system with first-order differential equations. Updates the system differential variables. More... | |
| void | exact_solution (const double *x, double *y) |
| Exact solution of the problem. Used for solution comparison. More... | |
| void | forward_euler_step (const double dx, const double *x, double *y, double *dy) |
| Compute next step approximation using the forward-Euler method. More... | |
| double | forward_euler (double dx, double x0, double x_max, double *y, char save_to_file) |
| Compute approximation using the forward-Euler method in the given limits. More... | |
| int | main (int argc, char *argv[]) |
Solve a multivariable first order ordinary differential equation (ODEs) using forward Euler method
+ +The ODE being solved is:
+\begin{eqnarray*} \dot{u} &=& v\\ \dot{v} &=& -\omega^2 u\\ \omega &=& 1\\ [x_0, u_0, v_0] &=& [0,1,0]\qquad\ldots\text{(initial values)} \end{eqnarray*} +
+The exact solution for the above problem is:
+\begin{eqnarray*} u(x) &=& \cos(x)\\ v(x) &=& -\sin(x)\\ \end{eqnarray*} +
+ The computation results are stored to a text file forward_euler.csv and the exact soltuion results in exact.csv for comparison. 
To implement Van der Pol oscillator, change the problem function to:
| #define order 2 | +
number of dependent variables in problem
+ +| void exact_solution | +( | +const double * | +x, | +
| + | + | double * | +y | +
| + | ) | ++ |
| double forward_euler | +( | +double | +dx, | +
| + | + | double | +x0, | +
| + | + | double | +x_max, | +
| + | + | double * | +y, | +
| + | + | char | +save_to_file | +
| + | ) | ++ |
Compute approximation using the forward-Euler method in the given limits.
+| [in] | dx | step size |
| [in] | x0 | initial value of independent variable |
| [in] | x_max | final value of independent variable |
| [in,out] | y | take \(y_n\) and compute \(y_{n+1}\) |
| [in] | save_to_file | flag to save results to a CSV file (1) or not (0) |
| void forward_euler_step | +( | +const double | +dx, | +
| + | + | const double * | +x, | +
| + | + | double * | +y, | +
| + | + | double * | +dy | +
| + | ) | ++ |
Compute next step approximation using the forward-Euler method.
++\[y_{n+1}=y_n + dx\cdot f\left(x_n,y_n\right)\] +
+| [in] | dx | step size |
| [in,out] | x | take \(x_n\) and compute \(x_{n+1}\) |
| [in,out] | y | take \(y_n\) and compute \(y_{n+1}\) |
| [in,out] | dy | compute \(f\left(x_n,y_n\right)\) |
| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main Function
+| void problem | +( | +const double * | +x, | +
| + | + | double * | +y, | +
| + | + | double * | +dy | +
| + | ) | ++ |
Problem statement for a system with first-order differential equations. Updates the system differential variables.
+| [in] | x | independent variable(s) |
| [in,out] | y | dependent variable(s) |
| [in,out] | dy | first-derivative of dependent variable(s) |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +int * | array |
| +int | size |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Library functions to compute QR decomposition of a given matrix. +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>Go to the source code of this file.
++Functions | |
| void | print_matrix (double **A, int M, int N) |
| double | vector_dot (double *a, double *b, int L) |
| double | vector_mag (double *vector, int L) |
| double * | vector_proj (double *a, double *b, double *out, int L) |
| double * | vector_sub (double *a, double *b, double *out, int L) |
| void | qr_decompose (double **A, double **Q, double **R, int M, int N) |
Library functions to compute QR decomposition of a given matrix.
+ +| void print_matrix | +( | +double ** | +A, | +
| + | + | int | +M, | +
| + | + | int | +N | +
| + | ) | ++ |
function to display matrix on stdout
+| A | matrix to print |
| M | number of rows of matrix |
| N | number of columns of matrix |
| void qr_decompose | +( | +double ** | +A, | +
| + | + | double ** | +Q, | +
| + | + | double ** | +R, | +
| + | + | int | +M, | +
| + | + | int | +N | +
| + | ) | ++ |
Decompose matrix \(A\) using Gram-Schmidt process.
++\begin{eqnarray*} \text{given that}\quad A &=& *\left[\mathbf{a}_1,\mathbf{a}_2,\ldots,\mathbf{a}_{N-1},\right]\\ \text{where}\quad\mathbf{a}_i &=& *\left[a_{0i},a_{1i},a_{2i},\ldots,a_{(M-1)i}\right]^T\quad\ldots\mbox{(column *vectors)}\\ \text{then}\quad\mathbf{u}_i &=& \mathbf{a}_i *-\sum_{j=0}^{i-1}\text{proj}_{\mathbf{u}_j}\mathbf{a}_i\\ \mathbf{e}_i &=&\frac{\mathbf{u}_i}{\left|\mathbf{u}_i\right|}\\ Q &=& \begin{bmatrix}\mathbf{e}_0 & \mathbf{e}_1 & \mathbf{e}_2 & \dots & *\mathbf{e}_{N-1}\end{bmatrix}\\ R &=& \begin{bmatrix}\langle\mathbf{e}_0\,,\mathbf{a}_0\rangle & *\langle\mathbf{e}_1\,,\mathbf{a}_1\rangle & *\langle\mathbf{e}_2\,,\mathbf{a}_2\rangle & \dots \\ 0 & \langle\mathbf{e}_1\,,\mathbf{a}_1\rangle & *\langle\mathbf{e}_2\,,\mathbf{a}_2\rangle & \dots\\ 0 & 0 & \langle\mathbf{e}_2\,,\mathbf{a}_2\rangle & \dots\\ \vdots & \vdots & \vdots & \ddots \end{bmatrix}\\ \end{eqnarray*} +
+| A | input matrix to decompose |
| Q | output decomposed matrix |
| R | output decomposed matrix |
| M | number of rows of matrix A |
| N | number of columns of matrix A |
| double vector_dot | +( | +double * | +a, | +
| + | + | double * | +b, | +
| + | + | int | +L | +
| + | ) | ++ |
Compute dot product of two vectors of equal lengths
+If \(\vec{a}=\left[a_0,a_1,a_2,...,a_L\right]\) and \(\vec{b}=\left[b_0,b_1,b_1,...,b_L\right]\) then \(\vec{a}\cdot\vec{b}=\displaystyle\sum_{i=0}^L a_i\times b_i\)
+| double vector_mag | +( | +double * | +vector, | +
| + | + | int | +L | +
| + | ) | ++ |
Compute magnitude of vector.
+If \(\vec{a}=\left[a_0,a_1,a_2,...,a_L\right]\) then \(\left|\vec{a}\right|=\sqrt{\displaystyle\sum_{i=0}^L a_i^2}\)
+| double* vector_proj | +( | +double * | +a, | +
| + | + | double * | +b, | +
| + | + | double * | +out, | +
| + | + | int | +L | +
| + | ) | ++ |
Compute projection of vector \(\vec{a}\) on \(\vec{b}\) defined as
+\[\text{proj}_\vec{b}\vec{a}=\frac{\vec{a}\cdot\vec{b}}{\left|\vec{b}\right|^2}\vec{b}\] +
+check for division by zero
+| double* vector_sub | +( | +double * | +a, | +
| + | + | double * | +b, | +
| + | + | double * | +out, | +
| + | + | int | +L | +
| + | ) | ++ |
Compute vector subtraction
+\(\vec{c}=\vec{a}-\vec{b}\)
+| a | minuend |
| b | subtrahend |
| out | resultant vector |
| L | length of vectors |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 401 solution - Sum of squares of divisors +More...
+#include <stdint.h>#include <stdio.h>#include <stdlib.h>#include <time.h>#include <inttypes.h>+Macros | |
| +#define | __STDC_FORMAT_MACROS |
| #define | MOD (uint64_t)1e9 |
| #define | MAX_L 5000 |
+Functions | |
| char | is_in (uint64_t N, uint64_t *D, uint64_t L) |
| uint64_t | get_divisors (uint64_t N, uint64_t *D) |
| uint64_t | sigma2 (uint64_t N) |
| uint64_t | sigma (uint64_t N) |
| int | main (int argc, char **argv) |
Problem 401 solution - Sum of squares of divisors
+ +| #define MAX_L 5000 | +
chunk size of array allocation
+ +| #define MOD (uint64_t)1e9 | +
modulo limit
+ +| uint64_t get_divisors | +( | +uint64_t | +N, | +
| + | + | uint64_t * | +D | +
| + | ) | ++ |
Get all integer divisors of a number
| [in] | N | number to find divisors for |
| [out] | D | array to store divisors in |
| char is_in | +( | +uint64_t | +N, | +
| + | + | uint64_t * | +D, | +
| + | + | uint64_t | +L | +
| + | ) | ++ |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+| uint64_t sigma | +( | +uint64_t | +N | ) | ++ |
sum of squares of factors of numbers from 1 thru N
+| uint64_t sigma2 | +( | +uint64_t | +N | ) | ++ |
compute sum of squares of all integer factors of a number
| [in] | N |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Compute \(m^{mth}\) Fibonacci number using the formulae: +More...
+#include <locale.h>#include <stdio.h>#include <stdlib.h>+Functions | |
| void | fib (unsigned long n, unsigned long *C, unsigned long *D) |
| int | main (int argc, char *argv[]) |
Compute \(m^{mth}\) Fibonacci number using the formulae:
+ ++\begin{eqnarray*} F_{2n-1} &=& F_n^2 + F_{n-1}^2 \\ F_{2n} &=& F_n\left(2F_{n-1} + F_n\right) \end{eqnarray*} +
+| void fib | +( | +unsigned long | +n, | +
| + | + | unsigned long * | +C, | +
| + | + | unsigned long * | +D | +
| + | ) | ++ |
Returns the \(n^{th}\) and \(n+1^{th}\) Fibonacci number. The return variables are C & D respectively.
+| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Solve a multivariable first order ordinary differential equation (ODEs) using semi implicit Euler method +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Macros | |
| #define | order 2 |
+Functions | |
| void | problem (const double *x, double *y, double *dy) |
| Problem statement for a system with first-order differential equations. Updates the system differential variables. More... | |
| void | exact_solution (const double *x, double *y) |
| Exact solution of the problem. Used for solution comparison. More... | |
| void | semi_implicit_euler_step (double dx, double *x, double *y, double *dy) |
| Compute next step approximation using the semi-implicit-Euler method. More... | |
| double | semi_implicit_euler (double dx, double x0, double x_max, double *y, char save_to_file) |
| Compute approximation using the semi-implicit-Euler method in the given limits. More... | |
| int | main (int argc, char *argv[]) |
Solve a multivariable first order ordinary differential equation (ODEs) using semi implicit Euler method
+ +The ODE being solved is:
+\begin{eqnarray*} \dot{u} &=& v\\ \dot{v} &=& -\omega^2 u\\ \omega &=& 1\\ [x_0, u_0, v_0] &=& [0,1,0]\qquad\ldots\text{(initial values)} \end{eqnarray*} +
+The exact solution for the above problem is:
+\begin{eqnarray*} u(x) &=& \cos(x)\\ v(x) &=& -\sin(x)\\ \end{eqnarray*} +
+ The computation results are stored to a text file semi_implicit_euler.csv and the exact soltuion results in exact.csv for comparison. 
To implement Van der Pol oscillator, change the problem function to:
| #define order 2 | +
number of dependent variables in problem
+ +| void exact_solution | +( | +const double * | +x, | +
| + | + | double * | +y | +
| + | ) | ++ |
| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main Function
+| void problem | +( | +const double * | +x, | +
| + | + | double * | +y, | +
| + | + | double * | +dy | +
| + | ) | ++ |
Problem statement for a system with first-order differential equations. Updates the system differential variables.
+| [in] | x | independent variable(s) |
| [in,out] | y | dependent variable(s) |
| [in,out] | dy | first-derivative of dependent variable(s) |
| double semi_implicit_euler | +( | +double | +dx, | +
| + | + | double | +x0, | +
| + | + | double | +x_max, | +
| + | + | double * | +y, | +
| + | + | char | +save_to_file | +
| + | ) | ++ |
Compute approximation using the semi-implicit-Euler method in the given limits.
+| [in] | dx | step size |
| [in] | x0 | initial value of independent variable |
| [in] | x_max | final value of independent variable |
| [in,out] | y | take \(y_n\) and compute \(y_{n+1}\) |
| [in] | save_to_file | flag to save results to a CSV file (1) or not (0) |
| void semi_implicit_euler_step | +( | +double | +dx, | +
| + | + | double * | +x, | +
| + | + | double * | +y, | +
| + | + | double * | +dy | +
| + | ) | ++ |
Compute next step approximation using the semi-implicit-Euler method.
+| [in] | dx | step size |
| [in,out] | x | take \(x_n\) and compute \(x_{n+1}\) |
| [in,out] | y | take \(y_n\) and compute \(y_{n+1}\) |
| [in,out] | dy | compute \(y_n+\frac{1}{2}dx\,f\left(x_n,y_n\right)\) |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 23 solution - optimization using look-up array +More...
+#include <stdio.h>#include <stdlib.h>#include <time.h>+Functions | |
| char | get_perfect_number (unsigned long N) |
| char | is_abundant (unsigned long N) |
| unsigned long | get_next_abundant (unsigned long N) |
| char | is_sum_of_abundant (unsigned long N) |
| int | main (int argc, char **argv) |
+Variables | |
| long | MAX_N = 28123 |
| char * | abundant_flags = NULL |
Problem 23 solution - optimization using look-up array
+ +Optimization applied - compute & store abundant numbers once into a look-up array.
+| unsigned long get_next_abundant | +( | +unsigned long | +N | ) | ++ |
Find the next abundant number after N and not including N
+| char get_perfect_number | +( | +unsigned long | +N | ) | ++ |
| char is_abundant | +( | +unsigned long | +N | ) | ++ |
Is the given number an abundant number (1) or not (0)
+| char is_sum_of_abundant | +( | +unsigned long | +N | ) | ++ |
check if a given number can be represented as a sum of two abundant numbers.
optimized logic: i + j = N where both i and j should be abundant hence we can simply check for j = N - i as we loop through i
+| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+byte array to store flags to identify abundant numbers the flags are identified by bits
+| char* abundant_flags = NULL | +
This is the global array to be used to store a flag to identify if a particular number is abundant (1) or not (0). Using a whole byte to store a binary info would be redundant. We will use each byte to represent 8 numbers by relying on bits. This saves memory required by 1/8
+ +| long MAX_N = 28123 | +
Limit of numbers to check
+ + 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Overview files hash.h and hash.c
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +int | vertexNum |
| +int | edgeNum |
| +struct Edge * | edges |
| +int | numVertices |
| +struct node ** | adjLists |
| +int * | visited |
| +int ** | edges |
| +int | V |
| +int | E |
| +struct Edge * | edge |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 14 solution +More...
+#include <stdio.h>#include <stdlib.h>+Functions | |
| long long | collatz (long long start_num) |
| int | main (int argc, char **argv) |
Problem 14 solution
+ +Since the computational values for each iteration step are independent, we can compute them in parallel. However, the maximum values should be updated in synchrony so that we do not get into a "race condition".
+To compile with supporintg gcc or clang, the flag "-fopenmp" should be passes while with Microsoft C compiler, the flag "/fopenmp" should be used. If you are using the provided CMAKE compilation, it will automatically detect OPENMP and compile with it for you.
+Automatically detects for OPENMP using the _OPENMP macro.
+| long long collatz | +( | +long long | +start_num | ) | ++ |
Computes the length of collatz sequence for a given starting number
+ +| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +void * | elements [MAXELEMENTS] |
| +int | number_of_elements |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Program to compute the QR decomposition of a given matrix. +More...
+#include "qr_decompose.h"#include <math.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Functions | |
| int | main (void) |
Program to compute the QR decomposition of a given matrix.
+ +| int main | +( | +void | +) | ++ |
main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +struct node * | left |
| +struct node * | right |
| +int | data |
| +struct node * | leftNode |
| +struct node * | rightNode |
| +int | val |
| +struct node * | par |
| +int | color |
| +int | vertex |
| +struct node * | next |
| +int | info |
| +struct node * | link |
| +struct node * | pre |
| +char | data |
Kyler Smith, 2017 Stack data structure implementation.
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +int | src |
| +int | dst |
| +int | weight |
| +Vertex | v |
| +Vertex | w |
| +int | dest |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>+Functions | |
| int | main () |
Problem 1 solution
+An Efficient code to print all the sum of all numbers that are multiples of 3 & 5 below N.
+| int main | +( | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Compute factorial of arbitrarily large numbers by storing individual digits in a byte. +More...
+#include <stdio.h>#include <stdlib.h>#include <time.h>+Data Structures | |
| struct | _large_num |
+Typedefs | |
| typedef struct _large_num | large_num |
+Functions | |
| large_num * | new_number (void) |
| void | delete_number (large_num *num) |
| void | add_digit (large_num *num, unsigned int value) |
| void | multiply (large_num *num, unsigned long n) |
| int | main (int argc, char *argv[]) |
Compute factorial of arbitrarily large numbers by storing individual digits in a byte.
+ +| typedef struct _large_num large_num | +
dynamically large number
+ +| void add_digit | +( | +large_num * | +num, | +
| + | + | unsigned int | +value | +
| + | ) | ++ |
add a digit to the large number
| [in,out] | num | |
| [in] | value | value of the digit to insert |
| void delete_number | +( | +large_num * | +num | ) | ++ |
delete all memory allocated for large number
| [in] | num | pointer to large_num to delete |
| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
main function
+| void multiply | +( | +large_num * | +num, | +
| + | + | unsigned long | +n | +
| + | ) | ++ |
multiply large number with another integer and store the result in the same large number
+| large_num* new_number | +( | +void | +) | ++ |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +void ** | items |
| +unsigned | size |
| +unsigned | capacity |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 16 solution +More...
+#include <math.h>#include <stdint.h>#include <stdio.h>#include <stdlib.h>+Functions | |
| int | main (int argc, char **argv) |
Problem 16 solution
+ +| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 1 solution. This solution is based on the pattern that the successive numbers in the series follow: 0+3,+2,+1,+3,+1,+2,+3. +More...
+#include <stdio.h>+Functions | |
| int | main () |
Problem 1 solution. This solution is based on the pattern that the successive numbers in the series follow: 0+3,+2,+1,+3,+1,+2,+3.
+If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3,5,6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below N.
+| int main | +( | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Shell sort algorithm implementation. +More...
+#include <stdio.h>#include <stdlib.h>#include <time.h>+Macros | |
| +#define | ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0])) |
+Functions | |
| void | show_data (int *arr, long len) |
| void | swap (int *a, int *b) |
| void | shell_sort (int *array, long LEN) |
| int | main (int argc, char *argv[]) |
Shell sort algorithm implementation.
+ +| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main function
+| void shell_sort | +( | +int * | +array, | +
| + | + | long | +LEN | +
| + | ) | ++ |
Optimized algorithm - takes half the time as other
+| void show_data | +( | +int * | +arr, | +
| + | + | long | +len | +
| + | ) | ++ |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 12 solution +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>+Functions | |
| long | count_divisors (long long n) |
| int | main (int argc, char **argv) |
Problem 12 solution
+ +| long count_divisors | +( | +long long | +n | ) | ++ |
Get number of divisors of a given number
+If \(x = a \times b\), then both \(a\) and \(b\) are divisors of \(x\). Since multiplication is commutative, we only need to search till a maximum of \(a=b = a^2\) i.e., till \(\sqrt{x}\). At every integer till then, there are eaxctly 2 divisors and at \(a=b\), there is only one divisor.
+ +| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Compute real eigen values and eigen vectors of a symmetric matrix using QR decomposition method. +More...
+#include "qr_decompose.h"#include <assert.h>#include <math.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Macros | |
| #define | LIMS 9 |
| #define | EPSILON 1e-10 |
+Functions | |
| void | create_matrix (double **A, int N) |
| double ** | mat_mul (double **A, double **B, double **OUT, int R1, int C1, int R2, int C2) |
| double | eigen_values (double **A, double *eigen_vals, int mat_size, char debug_print) |
| void | test1 () |
| void | test2 () |
| int | main (int argc, char **argv) |
Compute real eigen values and eigen vectors of a symmetric matrix using QR decomposition method.
+ +| #define EPSILON 1e-10 | +
accuracy tolerance limit
+ +| #define LIMS 9 | +
limit of range of matrix values
+ +| void create_matrix | +( | +double ** | +A, | +
| + | + | int | +N | +
| + | ) | ++ |
create a square matrix of given size with random elements
| [out] | A | matrix to create (must be pre-allocated in memory) |
| [in] | N | matrix size |
| double eigen_values | +( | +double ** | +A, | +
| + | + | double * | +eigen_vals, | +
| + | + | int | +mat_size, | +
| + | + | char | +debug_print | +
| + | ) | ++ |
Compute eigen values using iterative shifted QR decomposition algorithm as follows:
| [in,out] | A | matrix to compute eigen values for |
| [out] | eig_vals | resultant vector containing computed eigen values |
| [in] | mat_size | matrix size |
| [in] | debug_print | 1 to print intermediate Q & R matrices, 0 for not to |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
main function
+| double** mat_mul | +( | +double ** | +A, | +
| + | + | double ** | +B, | +
| + | + | double ** | +OUT, | +
| + | + | int | +R1, | +
| + | + | int | +C1, | +
| + | + | int | +R2, | +
| + | + | int | +C2 | +
| + | ) | ++ |
Perform multiplication of two matrices.
| [in] | A | first matrix to multiply |
| [in] | B | second matrix to multiply |
| [out] | OUT | output matrix (must be pre-allocated) |
| [in] | R1 | number of rows of first matrix |
| [in] | C1 | number of columns of first matrix |
| [in] | R2 | number of rows of second matrix |
| [in] | C2 | number of columns of second matrix |
| void test1 | +( | +) | ++ |
test function to compute eigen values of a 2x2 matrix
+\[\begin{bmatrix} 5 & 7\\ 7 & 11 \end{bmatrix}\] +
+which are approximately, {15.56158, 0.384227}
+| void test2 | +( | +) | ++ |
test function to compute eigen values of a 2x2 matrix
+\[\begin{bmatrix} -4& 4& 2& 0& -3\\ 4& -4& 4& -3& -1\\ 2& 4& 4& 3& -3\\ 0& -3& 3& -1&-1\\ -3& -1& -3& -3& 0 \end{bmatrix}\] +
+which are approximately, {9.27648, -9.26948, 2.0181, -1.03516, -5.98994}
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 15 solution +More...
+#include <stdint.h>#include <stdio.h>#include <stdlib.h>+Functions | |
| unsigned long long | number_of_paths (int N) |
| int | main (int argc, char **argv) |
Problem 15 solution
+ +| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
| unsigned long long number_of_paths | +( | +int | +N | ) | ++ |
At every node, there are 2 possible ways to move -> down or right. Since it is a square grid, there are in all, 2N steps with N down and N right options, without preference for order. Hence, the path can be be traced in N out of 2N number of ways. This is the same as binomial coeeficient.
+ + 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <math.h>#include <stdio.h>+Functions | |
| char | isprime (int no) |
| int | main () |
Problem 3 solution
+Problem:
+The prime factors of 13195 are 5,7,13 and 29. What is the largest prime factor of a given number N? e.g. for 10, largest prime factor = 5. For 17, largest prime factor = 17.
+| char isprime | +( | +int | +no | ) | ++ |
Check if the given number is prime
+ +| int main | +( | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Recoding the original atoi function in stdlib.h. +More...
+#include <assert.h>#include <stdio.h>#include <stdlib.h>#include <string.h>+Functions | |
| int | c_atoi (const char *str) |
| int | test_c_atoi () |
| int | main (int argc, char **argv) |
Recoding the original atoi function in stdlib.h.
+ +| int c_atoi | +( | +const char * | +str | ) | ++ |
the function take a string and return an integer
| [out] | str | pointer to a char address |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
the main function take one argument of type char* example : ./program 123
+| int test_c_atoi | +( | +) | ++ |
test the function implementation
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 23 solution +More...
+#include <stdio.h>#include <stdlib.h>#include <time.h>+Functions | |
| char | get_perfect_number (unsigned long N) |
| unsigned long | is_abundant (unsigned long N) |
| unsigned long | get_next_abundant (unsigned long N) |
| char | is_sum_of_abundant (unsigned long N) |
| int | main (int argc, char **argv) |
+Variables | |
| unsigned long | MAX_N = 28123 |
Problem 23 solution
+ +| unsigned long get_next_abundant | +( | +unsigned long | +N | ) | ++ |
Find the next abundant number after N and not including N
+| char get_perfect_number | +( | +unsigned long | +N | ) | ++ |
Returns: -1 if N is deficient 1 if N is abundant 0 if N is perfect
+| unsigned long is_abundant | +( | +unsigned long | +N | ) | ++ |
Is the given number an abundant number (1) or not (0)
+| char is_sum_of_abundant | +( | +unsigned long | +N | ) | ++ |
check if a given number can be represented as a sum of two abundant numbers.
optimized logic: i + j = N where both i and j should be abundant hence we can simply check for j = N - i as we loop through i
+| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+| unsigned long MAX_N = 28123 | +
upper limit of numbers to check
+ + 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 25 solution implemented using arbitrarily large numbers represented as arrays +More...
+#include <stdint.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <time.h>+Macros | |
| #define | MAX_DIGITS 1000 |
+Functions | |
| unsigned int | add_numbers (unsigned char *a, unsigned char *b, unsigned char *c, int N) |
| int | print_number (unsigned char *number, int N) |
| unsigned int | get_digits (unsigned char *number) |
| int | main (int argc, char *argv[]) |
Problem 25 solution implemented using arbitrarily large numbers represented as arrays
+ +| #define MAX_DIGITS 1000 | +
maximum number of digits
+ +| unsigned int add_numbers | +( | +unsigned char * | +a, | +
| + | + | unsigned char * | +b, | +
| + | + | unsigned char * | +c, | +
| + | + | int | +N | +
| + | ) | ++ |
Function to add arbitraty length decimal integers stored in an array.
+a + b = c = new b
| unsigned int get_digits | +( | +unsigned char * | +number | ) | ++ |
Get number of digits in a large number
+| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main function
+| int print_number | +( | +unsigned char * | +number, | +
| + | + | int | +N | +
| + | ) | ++ |
Print a large number
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problems are taken from https://projecteuler.net/.
+Project Euler is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve. Project Euler is ideal for mathematicians who are learning to code.
+Here the efficiency of your code is also checked. I've tried to provide all the best possible solutions.
+PROBLEMS:
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>#include <stdlib.h>+Functions | |
| int | main (void) |
Problem 9 solution
+ +Problem Statement: A Pythagorean triplet is a set of three natural numbers, \(a < b < c\), for which, \(a^2 + b^2 = c^2\). For example, \(3^2 + 4^2 = 9 + 16 = 25 = 5^2\). There exists exactly one Pythagorean triplet for which \(a + b + c = 1000\). Find the product abc.
+Given \(a^2 + b^2 = c^2\) and \(a+b+c = n\), we can write:
+\begin{eqnarray*} b &=& \frac{n^2 - 2an}{2n - 2a}\\ c &=& n - a - b \end{eqnarray*} +
+| int main | +( | +void | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Simple array of integers. With I/O functions, Sort Functions and Search Functions.
+#Sort Function
+The Sort function sorts the elements in the range in a particular order. The different types of sorting methods are Bubble Sort, Selection Sort, Merge Sort and Quick Sort. Bubble Sort repeatedly sorts the adjacent elements if they are in wrong order.
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 10 solution +More...
+#include <math.h>#include <stdio.h>#include <stdlib.h>+Functions | |
| int | main (int argc, char *argv[]) |
Problem 10 solution
+ +| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>+Functions | |
| int | main () |
Problem 1 solution
+An Efficient code to print all the sum of all numbers that are multiples of 3 & 5 below N.
+| int main | +( | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Compute all possible approximate roots of any given polynomial using Durand Kerner algorithm +More...
+#include <complex.h>#include <limits.h>#include <math.h>#include <stdio.h>#include <stdlib.h>#include <string.h>#include <time.h>+Macros | |
| #define | ACCURACY 1e-10 |
+Functions | |
| long double complex | poly_function (double *coeffs, unsigned int degree, long double complex x) |
| const char * | complex_str (long double complex x) |
| char | check_termination (long double delta) |
| int | main (int argc, char **argv) |
Compute all possible approximate roots of any given polynomial using Durand Kerner algorithm
+ +Test the algorithm online: https://gist.github.com/kvedala/27f1b0b6502af935f6917673ec43bcd7
+Try the highly unstable Wilkinson's polynomial:
Sample implementation results to compute approximate roots of the equation \(x^4-1=0\):
+
| #define ACCURACY 1e-10 | +
maximum accuracy limit
+ +| char check_termination | +( | +long double | +delta | ) | ++ |
check for termination condition
| [in] | delta | point at which to evaluate the polynomial |
| const char* complex_str | +( | +long double complex | +x | ) | ++ |
create a textual form of complex number
| [in] | x | point at which to evaluate the polynomial |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
store intermediate values to a CSV file
+| long double complex poly_function | +( | +double * | +coeffs, | +
| + | + | unsigned int | +degree, | +
| + | + | long double complex | +x | +
| + | ) | ++ |
Evaluate the value of a polynomial with given coefficients
| [in] | coeffs | coefficients of the polynomial |
| [in] | degree | degree of polynomial |
| [in] | x | point at which to evaluate the polynomial |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 13 solution +More...
+#include <stdint.h>#include <stdio.h>#include <stdlib.h>#include <string.h>+Macros | |
| #define | N 10 |
| #define | N2 (N + 10) |
+Functions | |
| int | get_number (FILE *fp, char *buffer, uint8_t *out_int) |
| int | add_numbers (uint8_t *a, uint8_t *b, uint8_t N) |
| int | print_number (uint8_t *number, uint8_t N, int8_t num_digits_to_print) |
| int | main (void) |
Problem 13 solution
+ +| #define N 10 | +
number of digits of the large number
+ +| #define N2 (N + 10) | +
number of digits in output number
+ +| int add_numbers | +( | +uint8_t * | +a, | +
| + | + | uint8_t * | +b, | +
| + | + | uint8_t | +N | +
| + | ) | ++ |
Function to add arbitraty length decimal integers stored in an array. a + b = c = new b
+| int get_number | +( | +FILE * | +fp, | +
| + | + | char * | +buffer, | +
| + | + | uint8_t * | +out_int | +
| + | ) | ++ |
Function to read the number from a file and store it in array.
+ index 0 of output buffer => units place
+ index 1 of output buffer => tens place and so on i.e., index i => 10^i th place
| int main | +( | +void | +) | ++ |
Main function
+| int print_number | +( | +uint8_t * | +number, | +
| + | + | uint8_t | +N, | +
| + | + | int8_t | +num_digits_to_print | +
| + | ) | ++ |
Function to print a long number
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 20 solution +More...
+#include <stdio.h>#include <stdlib.h>#include <time.h>+Data Structures | |
| struct | _big_int |
+Typedefs | |
| typedef struct _big_int | big_int |
+Functions | |
| big_int * | add_digit (big_int *digit, char value) |
| char | remove_digits (big_int *digit, int N) |
| int | main (int argc, char **argv) |
Problem 20 solution
+ +Implementation uses a custom big_int structure that can store arbitrarilty large integer numbers.
store arbitratily large integer values as a linked list of digits.
+ +Function that allocates memory to add another digit at the MSB
+| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+sum digits on the last iteration this avoid having another loop over all digits
+Notice that in the loop above, we make sure that at the end of the loop, ptr is pointing to the last digit. Thus we can avoid using another loop.
+| char remove_digits | +( | +big_int * | +digit, | +
| + | + | int | +N | +
| + | ) | ++ |
Function to remove digits preceeding the current digit.
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| int | data |
| struct Node * | llink |
| struct Node * | rlink |
| +struct Node * | next |
Node, the basic data structure of the tree
+| int Node::data | +
stores the number
+ +| struct Node* Node::llink | +
link to left child
+ +| struct Node* Node::rlink | +
link to right child
+ + 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
LU decomposition of a square matrix +More...
+#include <stdio.h>#include <stdlib.h>#include <time.h>+Functions | |
| int | lu_decomposition (double **A, double **L, double **U, int mat_size) |
| void | display (double **A, int N) |
| int | main (int argc, char **argv) |
LU decomposition of a square matrix
+ +| void display | +( | +double ** | +A, | +
| + | + | int | +N | +
| + | ) | ++ |
| int lu_decomposition | +( | +double ** | +A, | +
| + | + | double ** | +L, | +
| + | + | double ** | +U, | +
| + | + | int | +mat_size | +
| + | ) | ++ |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Compute statistics for data entered in rreal-time. +More...
+#include <assert.h>#include <math.h>#include <stdio.h>+Functions | |
| void | stats_computer1 (float x, float *mean, float *variance, float *std) |
| void | stats_computer2 (float x, float *mean, float *variance, float *std) |
| void | test_function (const float *test_data, const int number_of_samples) |
| int | main (int argc, char **argv) |
Compute statistics for data entered in rreal-time.
+ +This algorithm is really beneficial to compute statistics on data read in realtime. For example, devices reading biometrics data. The algorithm is simple enough to be easily implemented in an embedded system.
+| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+| void stats_computer1 | +( | +float | +x, | +
| + | + | float * | +mean, | +
| + | + | float * | +variance, | +
| + | + | float * | +std | +
| + | ) | ++ |
continuous mean and variance computance using first value as an approximation for the mean. If the first number is much far form the mean, the algorithm becomes very inaccurate to compute variance and standard deviation.
| [in] | x | new value added to data set |
| [out] | mean | if not NULL, mean returns mean of data set |
| [out] | variance | if not NULL, mean returns variance of data set |
| [out] | std | if not NULL, mean returns standard deviation of data set |
| void stats_computer2 | +( | +float | +x, | +
| + | + | float * | +mean, | +
| + | + | float * | +variance, | +
| + | + | float * | +std | +
| + | ) | ++ |
continuous mean and variance computance using Welford's algorithm (very accurate)
| [in] | x | new value added to data set |
| [out] | mean | if not NULL, mean returns mean of data set |
| [out] | variance | if not NULL, mean returns variance of data set |
| [out] | std | if not NULL, mean returns standard deviation of data set |
| void test_function | +( | +const float * | +test_data, | +
| + | + | const int | +number_of_samples | +
| + | ) | ++ |
Test the algorithm implementation
| [in] | test_data | array of data to test the algorithms |
| [in] | number_of_samples | number of samples of data |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>#include <stdlib.h>+Functions | |
| long long int | get_product (FILE *fp, long start_pos, int num_digits) |
| int | main (int argc, char *argv[]) |
Problem 8 solution
+ +| long long int get_product | +( | +FILE * | +fp, | +
| + | + | long | +start_pos, | +
| + | + | int | +num_digits | +
| + | ) | ++ |
Compute the product of two numbers in a file
+| [in] | fp | pointer to file that is already open |
| [in] | start_pos | line number of the first numer |
| [in] | num_digits | number of digits on the line to multiply |
| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Please orient on this guide before you sent a pull request.
+
Please write a simple user interface for your programs. Not a blinking cursor!
+ What does the program do?
+ What want the program an user informations?
+
See here
+ Don't push all code in one line!
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +char | value |
| struct _big_int * | next_digit |
| struct _big_int * | prev_digit |
store arbitratily large integer values as a linked list of digits.
+| struct _big_int* _big_int::next_digit | +
tens place (single digit)
+ +| struct _big_int* _big_int::prev_digit | +
hundreds place
+ + 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Implementation of Collatz' conjecture +More...
+#include <stdio.h>#include <stdlib.h>+Functions | |
| int | main (int argc, char *argv[]) |
Implementation of Collatz' conjecture
+Collatz conjecture: a series for a number \(n\) in which if \(n\) even then the next number is \(\frac{n}{2}\) ,but if n is odd then the next number is \(3n+1\). This series continues till \(n\) reaches 1
+| int main | +( | +int | +argc, | +
| + | + | char * | +argv[] | +
| + | ) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Find approximate solution for \(f(x) = 0\) using Newton-Raphson interpolation algorithm. +More...
+#include <complex.h>#include <limits.h>#include <math.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Macros | |
| #define | ACCURACY 1e-10 |
+Functions | |
| double complex | func (double complex x) |
| double complex | d_func (double complex x) |
| int | main (int argc, char **argv) |
Find approximate solution for \(f(x) = 0\) using Newton-Raphson interpolation algorithm.
+ +| #define ACCURACY 1e-10 | +
solution accuracy
+ +| double complex d_func | +( | +double complex | +x | ) | ++ |
| double complex func | +( | +double complex | +x | ) | ++ |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 22 solution +More...
+#include <stdio.h>#include <stdlib.h>#include <string.h>#include <time.h>+Macros | |
| #define | MAX_NAMES 6000 |
| #define | MAX_NAME_LEN 20 |
+Functions | |
| void | shell_sort (char data[][MAX_NAME_LEN], int LEN) |
| void | lazy_sort (char data[][MAX_NAME_LEN], int LEN) |
| int | main (int argc, char **argv) |
Problem 22 solution
+ +| #define MAX_NAME_LEN 20 | +
Maximum length of each name
+ +| #define MAX_NAMES 6000 | +
Maximum number of names to store
+ +| void lazy_sort | +( | +char | +data[][MAX_NAME_LEN], | +
| + | + | int | +LEN | +
| + | ) | ++ |
Alphabetical sorting using 'lazy sort' algorithm
+| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+| void shell_sort | +( | +char | +data[][MAX_NAME_LEN], | +
| + | + | int | +LEN | +
| + | ) | ++ |
Alphabetical sorting using 'shell sort' algorithm
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Adaptive Linear Neuron (ADALINE) implementation +More...
+#include <assert.h>#include <limits.h>#include <math.h>#include <stdbool.h>#include <stdio.h>#include <stdlib.h>#include <time.h>+Data Structures | |
| struct | adaline |
+Macros | |
| +#define | MAX_ITER 500 |
| +#define | ACCURACY 1e-5 |
| convergence accuracy \(=1\times10^{-5}\) | |
+Functions | |
| struct adaline | new_adaline (const int num_features, const double eta) |
| void | delete_adaline (struct adaline *ada) |
| int | activation (double x) |
| char * | get_weights_str (struct adaline *ada) |
| int | predict (struct adaline *ada, const double *x, double *out) |
| double | fit_sample (struct adaline *ada, const double *x, const int y) |
| void | fit (struct adaline *ada, double **X, const int *y, const int N) |
| void | test1 (double eta) |
| void | test2 (double eta) |
| void | test3 (double eta) |
| int | main (int argc, char **argv) |
Adaptive Linear Neuron (ADALINE) implementation
+ +
source ADALINE is one of the first and simplest single layer artificial neural network. The algorithm essentially implements a linear function
+\[ f\left(x_0,x_1,x_2,\ldots\right) = \sum_j x_jw_j+\theta \] +
+where \(x_j\) are the input features of a sample, \(w_j\) are the coefficients of the linear function and \(\theta\) is a constant. If we know the \(w_j\), then for any given set of features, \(y\) can be computed. Computing the \(w_j\) is a supervised learning algorithm wherein a set of features and their corresponding outputs are given and weights are computed using stochastic gradient descent method.
+| int activation | +( | +double | +x | ) | ++ |
| void delete_adaline | +( | +struct adaline * | +ada | ) | ++ |
delete dynamically allocated memory
| [in] | ada | model from which the memory is to be freeed. |
| void fit | +( | +struct adaline * | +ada, | +
| + | + | double ** | +X, | +
| + | + | const int * | +y, | +
| + | + | const int | +N | +
| + | ) | ++ |
Update the weights of the model using supervised learning for an array of vectors.
+| [in] | ada | adaline model to train |
| [in] | X | array of feature vector |
| [in] | y | known output value for each feature vector |
| [in] | N | number of training samples |
| double fit_sample | +( | +struct adaline * | +ada, | +
| + | + | const double * | +x, | +
| + | + | const int | +y | +
| + | ) | ++ |
Update the weights of the model using supervised learning for one feature vector
+| [in] | ada | adaline model to fit |
| [in] | x | feature vector |
| [in] | y | known output value |
| char* get_weights_str | +( | +struct adaline * | +ada | ) | ++ |
Operator to print the weights of the model
+| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+| struct adaline new_adaline | +( | +const int | +num_features, | +
| + | + | const double | +eta | +
| + | ) | ++ |
Default constructor
| [in] | num_features | number of features present |
| [in] | eta | learning rate (optional, default=0.1) |
| int predict | +( | +struct adaline * | +ada, | +
| + | + | const double * | +x, | +
| + | + | double * | +out | +
| + | ) | ++ |
predict the output of the model for given set of features
+| [in] | ada | adaline model to predict |
| [in] | x | input vector |
| [out] | out | optional argument to return neuron output before applying activation function (NULL to ignore) |
| void test1 | +( | +double | +eta | ) | ++ |
test function to predict points in a 2D coordinate system above the line \(x=y\) as +1 and others as -1. Note that each point is defined by 2 values or 2 features.
| [in] | eta | learning rate (optional, default=0.01) |
| void test2 | +( | +double | +eta | ) | ++ |
test function to predict points in a 2D coordinate system above the line \(x+3y=-1\) as +1 and others as -1. Note that each point is defined by 2 values or 2 features. The function will create random sample points for training and test purposes.
| [in] | eta | learning rate (optional, default=0.01) |
| void test3 | +( | +double | +eta | ) | ++ |
test function to predict points in a 3D coordinate system lying within the sphere of radius 1 and centre at origin as +1 and others as -1. Note that each point is defined by 3 values but we use 6 features. The function will create random sample points for training and test purposes. The sphere centred at origin and radius 1 is defined as: \(x^2+y^2+z^2=r^2=1\) and if the \(r^2<1\), point lies within the sphere else, outside.
+| [in] | eta | learning rate (optional, default=0.01) |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 19 solution +More...
+
#include <stdio.h>+Functions | |
| char | get_month_days (short month) |
| char | is_leap_year (short year) |
| int | main (int argc, char **argv) |
Problem 19 solution
+ +| char get_month_days | +( | +short | +month | ) | ++ |
returns number of days in a month. Month is identified by an integer -
+
++0 = Jan and 11 = December
+
+
For February, adjust for leap year outside the function.
+| char is_leap_year | +( | +short | +year | ) | ++ |
| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+Let us identify days i.e., Sunday thru Saturday with integers - 0 thru 6 respectively Jan 1 1901 was a Tuesday
+These two for-loops count the start of day for the next month. Hence, we have to skip the last December count
+Main Algorithm: every week has 7 days hence, the start of next day would be modulo 7 add to this, the current start date and ensure the result is still modulo 7!
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
This is simple and generic dictionary. You can instantiate multiple dictionaries with the constructor. See interface below.
+Each dictionary has space for 1000 elements.
+You need add the files dic.c and dic.h in your project directory. After that you include dic.h
+create_dict: is a simple constructor for creating a dictionary and setting up the member field 'number_of_elements' and prepares the inner array 'elements'
+add_item_label: adds item (void*) to the dictionary at given label returns 0 if adding was sucessful otherwise -1
+add_item_index: adds item (void*) to the dictionary at given index (int) returns 0 if adding was sucessful otherwise -1
+get_element: returns the element at given label
+get_element: returns the element at given index
+simple destructor function for avoiding memory leaks.
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 21 solution +More...
+#include <stdio.h>#include <stdlib.h>#include <time.h>+Functions | |
| unsigned long | sum_of_divisors (unsigned int N) |
| int | main (int argc, char **argv) |
Problem 21 solution
+ +| int main | +( | +int | +argc, | +
| + | + | char ** | +argv | +
| + | ) | ++ |
Main function
+< We use an array of flags to check if a number at the index was: not-processed = 0 is amicable = 1 not amicable = -1
+| unsigned long sum_of_divisors | +( | +unsigned int | +N | ) | ++ |
function to return the sum of proper divisors of N
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
This file is a simple implementation of a Threaded Binary Tree. +More...
+#include <stdio.h>#include <stdlib.h>+Data Structures | |
| struct | Node |
+Typedefs | |
| typedef struct Node | node |
+Functions | |
| node * | create_node (int data) |
| void | insert_bt (node **root, int data) |
| void | search (node *root, int ele) |
| void | inorder_display (node *curr) |
| void | postorder_display (node *curr) |
| void | preorder_display (node *curr) |
| void | delete_bt (node **root, int ele) |
| int | main () |
This file is a simple implementation of a Threaded Binary Tree.
+Threaded Binary Tree is a binary tree variant in which all left child pointers that are NULL (in Linked list representation) point to its in-order predecessor, and all right child pointers that are NULL (in Linked list representation) point to its in-order successor. It has the following functionalities:
-see binary_search_tree.c
+ +| node* create_node | +( | +int | +data | ) | ++ |
| void delete_bt | +( | +node ** | +root, | +
| + | + | int | +ele | +
| + | ) | ++ |
deletion of a node from the tree if the node isn't present in the tree, it takes no action. param[in,out] root pointer to node pointer to the topmost node of the tree param[in] ele value to be deleted from the tree
+| void inorder_display | +( | +node * | +curr | ) | ++ |
performs inorder traversal param[in] curr node pointer to the topmost node of the tree
+| void insert_bt | +( | +node ** | +root, | +
| + | + | int | +data | +
| + | ) | ++ |
inserts a node into the tree param[in,out] root pointer to node pointer to the topmost node of the tree param[in] data value to be inserted into the tree
+| int main | +( | +) | ++ |
main function
+| void postorder_display | +( | +node * | +curr | ) | ++ |
performs postorder traversal param[in] curr node pointer to the topmost node of the tree
+| void preorder_display | +( | +node * | +curr | ) | ++ |
performs preorder traversal param[in] curr node pointer to the topmost node of the tree
+| void search | +( | +node * | +root, | +
| + | + | int | +ele | +
| + | ) | ++ |
searches for the element
| [in] | root | node pointer to the topmost node of the tree |
| [in] | ele | value searched for |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Problem 9 solution - A naive implementation +More...
+#include <stdio.h>+Functions | |
| int | main (void) |
Problem 9 solution - A naive implementation
+ +| int main | +( | +void | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Data Fields | |
| +char | text [MAX_WORD_LENGTH] |
| +int | count |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
#include <stdio.h>+Functions | |
| unsigned long | gcd (unsigned long a, unsigned long b) |
| unsigned long | lcm (unsigned long a, unsigned long b) |
| int | main (void) |
Problem 5 solution
+| unsigned long gcd | +( | +unsigned long | +a, | +
| + | + | unsigned long | +b | +
| + | ) | ++ |
Compute Greatest Common Divisor (GCD) of two numbers using Euclids algorithm
+ +| unsigned long lcm | +( | +unsigned long | +a, | +
| + | + | unsigned long | +b | +
| + | ) | ++ |
Compute Least Common Multiple (LCM) of two numbers
+| int main | +( | +void | +) | ++ |
Main function
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 25 solution implemented using arbitrarily large numbers represented as arrays | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 19 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 10 solution | |
| file | sol2.c |
| Problem 10 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 26 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 16 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 22 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 15 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 401 solution - Sum of squares of divisors | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | adaline_learning.c |
| Adaptive Linear Neuron (ADALINE) implementation | |
| file | kohonen_som_topology.c |
| Kohonen self organizing map (topological map) | |
| file | kohonen_som_trace.c |
| Kohonen self organizing map (data tracing) | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 20 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | c_atoi_str_to_integer.c |
| Recoding the original atoi function in stdlib.h. | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | durand_kerner_roots.c |
| Compute all possible approximate roots of any given polynomial using Durand Kerner algorithm | |
| file | lu_decompose.c |
| LU decomposition of a square matrix | |
| file | newton_raphson_root.c |
| Find approximate solution for \(f(x) = 0\) using Newton-Raphson interpolation algorithm. | |
| file | ode_forward_euler.c |
| Solve a multivariable first order ordinary differential equation (ODEs) using forward Euler method | |
| file | ode_midpoint_euler.c |
| Solve a multivariable first order ordinary differential equation (ODEs) using midpoint Euler method | |
| file | ode_semi_implicit_euler.c |
| Solve a multivariable first order ordinary differential equation (ODEs) using semi implicit Euler method | |
| file | qr_decompose.h [code] |
| Library functions to compute QR decomposition of a given matrix. | |
| file | qr_decomposition.c |
| Program to compute the QR decomposition of a given matrix. | |
| file | qr_eigen_values.c |
| Compute real eigen values and eigen vectors of a symmetric matrix using QR decomposition method. | |
| file | realtime_stats.c |
| Compute statistics for data entered in rreal-time. | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | collatz.c |
| Implementation of Collatz' conjecture | |
| file | factorial_large_number.c |
| Compute factorial of arbitrarily large numbers by storing individual digits in a byte. | |
| file | fibonacci_fast.c |
| Compute \(m^{mth}\) Fibonacci number using the formulae: | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 14 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | shell_sort2.c |
| Shell sort algorithm implementation. | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 12 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 21 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | threaded_binary_trees.c |
| This file is a simple implementation of a Threaded Binary Tree. | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 23 solution | |
| file | sol2.c |
| Problem 23 solution - optimization using look-up array | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
+Files | |
| file | sol1.c |
| Problem 13 solution | |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
| ▼ conversions | |
| c_atoi_str_to_integer.c | Recoding the original atoi function in stdlib.h |
| ▼ data_structures | |
| ► array | |
| ► binary_trees | |
| ► dictionary | |
| ► dynamic_array | |
| ► graphs | |
| ► hash_set | |
| ► list | |
| ► stack | |
| ▼ exercism | |
| ► acronym | |
| ► hello_world | |
| ► isogram | |
| ► rna_transcription | |
| ► word_count | |
| ▼ hash | |
| hash.h | |
| ▼ machine_learning | |
| adaline_learning.c | Adaptive Linear Neuron (ADALINE) implementation |
| kohonen_som_topology.c | Kohonen self organizing map (topological map) |
| kohonen_som_trace.c | Kohonen self organizing map (data tracing) |
| ▼ misc | |
| collatz.c | Implementation of Collatz' conjecture |
| factorial_large_number.c | Compute factorial of arbitrarily large numbers by storing individual digits in a byte |
| fibonacci_fast.c | Compute \(m^{mth}\) Fibonacci number using the formulae: |
| ▼ numerical_methods | |
| durand_kerner_roots.c | Compute all possible approximate roots of any given polynomial using Durand Kerner algorithm |
| lu_decompose.c | LU decomposition of a square matrix |
| newton_raphson_root.c | Find approximate solution for \(f(x) = 0\) using Newton-Raphson interpolation algorithm |
| ode_forward_euler.c | Solve a multivariable first order ordinary differential equation (ODEs) using forward Euler method |
| ode_midpoint_euler.c | Solve a multivariable first order ordinary differential equation (ODEs) using midpoint Euler method |
| ode_semi_implicit_euler.c | Solve a multivariable first order ordinary differential equation (ODEs) using semi implicit Euler method |
| qr_decompose.h | Library functions to compute QR decomposition of a given matrix |
| qr_decomposition.c | Program to compute the QR decomposition of a given matrix |
| qr_eigen_values.c | Compute real eigen values and eigen vectors of a symmetric matrix using QR decomposition method |
| realtime_stats.c | Compute statistics for data entered in rreal-time |
| ▼ project_euler | |
| ► problem_1 | |
| ► problem_10 | |
| ► problem_12 | |
| ► problem_13 | |
| ► problem_14 | |
| ► problem_15 | |
| ► problem_16 | |
| ► problem_19 | |
| ► problem_2 | |
| ► problem_20 | |
| ► problem_21 | |
| ► problem_22 | |
| ► problem_23 | |
| ► problem_25 | |
| ► problem_26 | |
| ► problem_3 | |
| ► problem_4 | |
| ► problem_401 | |
| ► problem_5 | |
| ► problem_6 | |
| ► problem_7 | |
| ► problem_8 | |
| ► problem_9 | |
| ▼ sorting | |
| shell_sort2.c | Shell sort algorithm implementation |
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
This page explains how to interpret the graphs that are generated by doxygen.
+Consider the following example:
This will result in the following graph:
+The boxes in the above graph have the following meaning:
+The arrows have the following meaning:
+ 1.8.18 |
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
Click on Files menu to see the list of all the files documented with the code.
+All the code can be executed and tested online: 
The implementations are for learning purpose. They may be less efficient than the implementation in the standard library.
+Read our Contribution Guidelines before you contribute.
+ 1.8.18 
');
+}
+
+function showSyncOn(n,relpath)
+{
+ n.html('
');
+}
+
+function toggleSyncButton(relpath)
+{
+ var navSync = $('#nav-sync');
+ if (navSync.hasClass('sync')) {
+ navSync.removeClass('sync');
+ showSyncOff(navSync,relpath);
+ storeLink(stripPath2(pathName())+hashUrl());
+ } else {
+ navSync.addClass('sync');
+ showSyncOn(navSync,relpath);
+ deleteLink();
+ }
+}
+
+var loadTriggered = false;
+var readyTriggered = false;
+var loadObject,loadToRoot,loadUrl,loadRelPath;
+
+$(window).on('load',function(){
+ if (readyTriggered) { // ready first
+ navTo(loadObject,loadToRoot,loadUrl,loadRelPath);
+ showRoot();
+ }
+ loadTriggered=true;
+});
+
+function initNavTree(toroot,relpath)
+{
+ var o = new Object();
+ o.toroot = toroot;
+ o.node = new Object();
+ o.node.li = document.getElementById("nav-tree-contents");
+ o.node.childrenData = NAVTREE;
+ o.node.children = new Array();
+ o.node.childrenUL = document.createElement("ul");
+ o.node.getChildrenUL = function() { return o.node.childrenUL; };
+ o.node.li.appendChild(o.node.childrenUL);
+ o.node.depth = 0;
+ o.node.relpath = relpath;
+ o.node.expanded = false;
+ o.node.isLast = true;
+ o.node.plus_img = document.createElement("span");
+ o.node.plus_img.className = 'arrow';
+ o.node.plus_img.innerHTML = arrowRight;
+
+ if (localStorageSupported()) {
+ var navSync = $('#nav-sync');
+ if (cachedLink()) {
+ showSyncOff(navSync,relpath);
+ navSync.removeClass('sync');
+ } else {
+ showSyncOn(navSync,relpath);
+ }
+ navSync.click(function(){ toggleSyncButton(relpath); });
+ }
+
+ if (loadTriggered) { // load before ready
+ navTo(o,toroot,hashUrl(),relpath);
+ showRoot();
+ } else { // ready before load
+ loadObject = o;
+ loadToRoot = toroot;
+ loadUrl = hashUrl();
+ loadRelPath = relpath;
+ readyTriggered=true;
+ }
+
+ $(window).bind('hashchange', function(){
+ if (window.location.hash && window.location.hash.length>1){
+ var a;
+ if ($(location).attr('hash')){
+ var clslink=stripPath(pathName())+':'+hashValue();
+ a=$('.item a[class$="'+clslink.replace(/exercism.io", "d7/db5/md_exercism__r_e_a_d_m_e.html", null ],
+ [ "Hash algorithms", "d4/dcb/md_hash__r_e_a_d_m_e.html", null ],
+ [ "LeetCode", "df/d58/md_leetcode__r_e_a_d_m_e.html", null ],
+ [ "ProjectEuler", "d8/d81/md_project_euler__r_e_a_d_m_e.html", null ],
+ [ "Data Structures", "annotated.html", [
+ [ "Data Structures", "annotated.html", "annotated_dup" ],
+ [ "Data Structure Index", "classes.html", null ],
+ [ "Data Fields", "functions.html", [
+ [ "All", "functions.html", null ],
+ [ "Variables", "functions_vars.html", null ]
+ ] ]
+ ] ],
+ [ "Files", "files.html", [
+ [ "File List", "files.html", "files_dup" ],
+ [ "Globals", "globals.html", [
+ [ "All", "globals.html", null ],
+ [ "Functions", "globals_func.html", null ],
+ [ "Variables", "globals_vars.html", null ],
+ [ "Typedefs", "globals_type.html", null ],
+ [ "Macros", "globals_defs.html", null ]
+ ] ]
+ ] ]
+ ] ]
+];
+
+var NAVTREEINDEX =
+[
+"annotated.html",
+"d6/de3/sol3_8c.html",
+"pages.html"
+];
+
+var SYNCONMSG = 'click to disable panel synchronisation';
+var SYNCOFFMSG = 'click to enable panel synchronisation';
\ No newline at end of file
diff --git a/navtreeindex0.js b/navtreeindex0.js
new file mode 100644
index 00000000..0ad5be26
--- /dev/null
+++ b/navtreeindex0.js
@@ -0,0 +1,253 @@
+var NAVTREEINDEX0 =
+{
+"annotated.html":[10,0],
+"classes.html":[10,1],
+"d0/d10/struct_queue_rep.html":[10,0,30],
+"d0/d10/struct_queue_rep.html#a5ca79e0a97550d8938331d90ce585a35":[10,0,30,2],
+"d0/d10/struct_queue_rep.html#aad9e10b8e2e0a821d374a154240e22c6":[10,0,30,1],
+"d0/d10/struct_queue_rep.html#ad4f9f3b0f81ea8c768d4c45548a590de":[10,0,30,0],
+"d0/d43/structpid.html":[10,0,28],
+"d0/d43/structpid.html#a3c54185f7b4867281786eff640443a00":[10,0,28,0],
+"d0/d43/structpid.html#a5a7b54866748e12568f9b9599b31f8eb":[10,0,28,3],
+"d0/d43/structpid.html#a65e8bc146e02bad2702a0286d37b81bc":[10,0,28,2],
+"d0/d43/structpid.html#a6c721a7983511fb9f91777ae45481473":[10,0,28,1],
+"d0/d43/structpid.html#ad661092f21ab1e0e6aa35fbcfcf6f161":[10,0,28,4],
+"d0/d46/kohonen__som__trace_8c.html":[11,0,4,2],
+"d0/d46/kohonen__som__trace_8c.html#a0283886819c7c140a023582b7269e2d0":[11,0,4,2,10],
+"d0/d46/kohonen__som__trace_8c.html#a0a292ebd954c568934b1fd06666d27e6":[11,0,4,2,5],
+"d0/d46/kohonen__som__trace_8c.html#a107f00650b8041f77767927073ddddb8":[11,0,4,2,13],
+"d0/d46/kohonen__som__trace_8c.html#a1440a7779ac56f47a3f355ce4a8c7da0":[11,0,4,2,9],
+"d0/d46/kohonen__som__trace_8c.html#a2256c10b16edba377b64a44b6c656908":[11,0,4,2,4],
+"d0/d46/kohonen__som__trace_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,4,2,7],
+"d0/d46/kohonen__som__trace_8c.html#a41ae16442e3e5b891a58d2e5932a2cd0":[11,0,4,2,12],
+"d0/d46/kohonen__som__trace_8c.html#a525335710b53cb064ca56b936120431e":[11,0,4,2,0],
+"d0/d46/kohonen__som__trace_8c.html#a6d0455dd5c30adda100e95f0423c786e":[11,0,4,2,11],
+"d0/d46/kohonen__som__trace_8c.html#a7b84b14e60f47812b581d1f93057c85a":[11,0,4,2,8],
+"d0/d46/kohonen__som__trace_8c.html#a9c98203f55242ff7a8f45a6370840e66":[11,0,4,2,15],
+"d0/d46/kohonen__som__trace_8c.html#aa2246f940155472084ee461f3685d614":[11,0,4,2,14],
+"d0/d46/kohonen__som__trace_8c.html#ac6afabdc09a49a433ee19d8a9486056d":[11,0,4,2,2],
+"d0/d46/kohonen__som__trace_8c.html#aeaeffbff2be4d5d15b0d4f10f846abde":[11,0,4,2,6],
+"d0/d46/kohonen__som__trace_8c.html#af5ce14f026d6d231bef29161bac2b485":[11,0,4,2,3],
+"d0/d46/kohonen__som__trace_8c.html#affe776513b24d84b39af8ab0930fef7f":[11,0,4,2,1],
+"d0/d6b/structelem.html":[10,0,19],
+"d0/d6b/structelem.html#a738173725677dc7ccc8529cc8537c50d":[10,0,19,1],
+"d0/d6b/structelem.html#ab9cf5c2e1c9a0ec2938275b90d39d5ca":[10,0,19,0],
+"d0/d6c/problem__4_2sol_8c.html":[11,0,7,16,0],
+"d0/d6c/problem__4_2sol_8c.html#a840291bc02cba5474a4cb46a9b9566fe":[11,0,7,16,0,1],
+"d0/d6c/problem__4_2sol_8c.html#adf9bea8d35848959bde5b3f277edf0c4":[11,0,7,16,0,0],
+"d0/d6d/problem__10_2sol1_8c.html":[11,0,7,1,0],
+"d0/d6d/problem__10_2sol1_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,7,1,0,1],
+"d0/d6d/problem__10_2sol1_8c.html#acc871ab6bfead702e983a7f9c412915f":[11,0,7,1,0,0],
+"d0/d6d/problem__10_2sol1_8c.html#ae3d987cb2ad0ddb0c3caa4c2506a20e5":[11,0,7,1,0,2],
+"d0/d7f/so1_8c.html":[11,0,7,8,0],
+"d0/d7f/so1_8c.html#ae66f6b31b5ad750f1fe042a706a4e3d4":[11,0,7,8,0,0],
+"d0/d8a/structmax__heap.html":[10,0,24],
+"d0/d8a/structmax__heap.html#a1b632c34e7304f9e0720834200696340":[10,0,24,1],
+"d0/d8a/structmax__heap.html#a917b63797e1857ce994dd5e6cfcebf1e":[10,0,24,0],
+"d0/d8a/structmax__heap.html#ac4d520821651b109fd2ba2a99c6c6015":[10,0,24,2],
+"d0/dc8/structarray__3d.html":[10,0,10],
+"d0/dc8/structarray__3d.html#aa431cc0a41fd379270dbd2b0e3ac1b45":[10,0,10,2],
+"d0/dc8/structarray__3d.html#ac8967b2c72769f839c09fb4cebb4339f":[10,0,10,0],
+"d0/dc8/structarray__3d.html#ad5d3ee546eea3c05dc8f0dc90ec194f4":[10,0,10,1],
+"d0/dc8/structarray__3d.html#ad823bd5424a0fc158da52a0497d8c10a":[10,0,10,3],
+"d0/df1/structhash__set__t.html":[10,0,22],
+"d0/df1/structhash__set__t.html#a1b52c6b78642e398f574c2ec9ed22e8a":[10,0,22,1],
+"d0/df1/structhash__set__t.html#a5fd11ba3c74b2cc7fd161696fb951b82":[10,0,22,2],
+"d0/df1/structhash__set__t.html#a66e37043817e37030d2e49fd5bf81d7f":[10,0,22,3],
+"d0/df1/structhash__set__t.html#a6f21e4fb262dbabac311dadc7936aa68":[10,0,22,0],
+"d1/d12/md_data_structures_stack__r_e_a_d_m_e.html":[4],
+"d1/d12/md_data_structures_stack__r_e_a_d_m_e.html#autotoc_md11":[3],
+"d1/d12/md_data_structures_stack__r_e_a_d_m_e.html#autotoc_md12":[4],
+"d1/d2f/problem__7_2sol_8c.html":[11,0,7,20,0],
+"d1/d2f/problem__7_2sol_8c.html#a840291bc02cba5474a4cb46a9b9566fe":[11,0,7,20,0,0],
+"d1/dc2/ode__midpoint__euler_8c.html":[11,0,6,4],
+"d1/dc2/ode__midpoint__euler_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,6,4,2],
+"d1/dc2/ode__midpoint__euler_8c.html#a148003d8b261d040c1c41e73b40af1dd":[11,0,6,4,3],
+"d1/dc2/ode__midpoint__euler_8c.html#a8caee977b26888d34040b122e0e28e3a":[11,0,6,4,1],
+"d1/dc2/ode__midpoint__euler_8c.html#a97075291390a68c262ed66e157a57eb4":[11,0,6,4,5],
+"d1/dc2/ode__midpoint__euler_8c.html#a9ceb646336224ee890a269d0b4600d09":[11,0,6,4,0],
+"d1/dc2/ode__midpoint__euler_8c.html#affe6cc2ab040b94a29e6c41782f72d51":[11,0,6,4,4],
+"d1/df9/problem__26_2sol1_8c.html":[11,0,7,14,0],
+"d1/df9/problem__26_2sol1_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,7,14,0,3],
+"d1/df9/problem__26_2sol1_8c.html#a619eec3220cebd7c5e455edbb14e9b12":[11,0,7,14,0,0],
+"d1/df9/problem__26_2sol1_8c.html#aabf4f709c8199e41cf279c77112345fe":[11,0,7,14,0,1],
+"d1/df9/problem__26_2sol1_8c.html#ac70138609ef6aa6fabca57aca8681e83":[11,0,7,14,0,2],
+"d2/d36/structqueue.html":[10,0,29],
+"d2/d36/structqueue.html#a0da4061b8634159fd21e72b34f289e01":[10,0,29,2],
+"d2/d36/structqueue.html#a473ab80725514ce07817f87ed1fb136f":[10,0,29,3],
+"d2/d36/structqueue.html#a6c50c7c8bcd9c5962996ed8b1be8771c":[10,0,29,0],
+"d2/d36/structqueue.html#aa5eb0f1e96748486046b9543ace2082a":[10,0,29,4],
+"d2/d36/structqueue.html#ade1be9c3ada77e8e182ee4fe1e1fff05":[10,0,29,1],
+"d2/d6a/struct_graph_rep.html":[10,0,21],
+"d2/d6a/struct_graph_rep.html#a081038f30741c196b7d84fe79b4732c9":[10,0,21,2],
+"d2/d6a/struct_graph_rep.html#aaf306e1727ca6c84cc03635ef4ac4888":[10,0,21,1],
+"d2/d6a/struct_graph_rep.html#aeb803dced884357ef0c7ea59525e382b":[10,0,21,0],
+"d2/d71/struct_a_v_lnode.html":[10,0,11],
+"d2/d71/struct_a_v_lnode.html#a91349e8b477c6e9d45187997ca2e2a50":[10,0,11,2],
+"d2/d71/struct_a_v_lnode.html#aaf07c08df1ee92ae2512869a178a14d9":[10,0,11,3],
+"d2/d71/struct_a_v_lnode.html#ab3391d72c5ace9f85889430ce18383ef":[10,0,11,1],
+"d2/d71/struct_a_v_lnode.html#af7b887a7fffb15778d53e167a95e40d9":[10,0,11,0],
+"d2/d89/structcontour.html":[10,0,14],
+"d2/d89/structcontour.html#a37ee431bf2d840798656489101dbaaf3":[10,0,14,1],
+"d2/d89/structcontour.html#a6acf2aeeb306adbed73b797d810ded37":[10,0,14,2],
+"d2/d89/structcontour.html#acff4c6a80e7d8b15a27f42add6dff976":[10,0,14,0],
+"d2/d93/problem__8_2sol2_8c.html":[11,0,7,21,1],
+"d2/d93/problem__8_2sol2_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,7,21,1,0],
+"d2/daa/structadaline.html":[10,0,9],
+"d2/daa/structadaline.html#a32e58c03fd9258709eae6138ad0ec657":[10,0,9,2],
+"d2/daa/structadaline.html#a53314e737a0a5ff4552a03bcc9dafbc1":[10,0,9,1],
+"d2/daa/structadaline.html#a85dbd7cce6195d11ebb388220b96bde2":[10,0,9,0],
+"d2/dae/problem__1_2sol2_8c.html":[11,0,7,0,1],
+"d2/dae/problem__1_2sol2_8c.html#ae66f6b31b5ad750f1fe042a706a4e3d4":[11,0,7,0,1,0],
+"d2/dbc/problem__3_2sol2_8c.html":[11,0,7,15,1],
+"d2/dbc/problem__3_2sol2_8c.html#ae66f6b31b5ad750f1fe042a706a4e3d4":[11,0,7,15,1,0],
+"d2/dc3/carray_8h_source.html":[11,0,1,0,0],
+"d2/df6/kohonen__som__topology_8c.html":[11,0,4,1],
+"d2/df6/kohonen__som__topology_8c.html#a0283886819c7c140a023582b7269e2d0":[11,0,4,1,13],
+"d2/df6/kohonen__som__topology_8c.html#a1440a7779ac56f47a3f355ce4a8c7da0":[11,0,4,1,12],
+"d2/df6/kohonen__som__topology_8c.html#a1983dc0f35e734015772e9f8c0ff19f5":[11,0,4,1,8],
+"d2/df6/kohonen__som__topology_8c.html#a2256c10b16edba377b64a44b6c656908":[11,0,4,1,6],
+"d2/df6/kohonen__som__topology_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,4,1,9],
+"d2/df6/kohonen__som__topology_8c.html#a525335710b53cb064ca56b936120431e":[11,0,4,1,1],
+"d2/df6/kohonen__som__topology_8c.html#a5bb02a8322d717ead1b11182c5f02a3a":[11,0,4,1,17],
+"d2/df6/kohonen__som__topology_8c.html#a6824dc6d973eb3339af7aef5fea78b0c":[11,0,4,1,10],
+"d2/df6/kohonen__som__topology_8c.html#a6d0455dd5c30adda100e95f0423c786e":[11,0,4,1,14],
+"d2/df6/kohonen__som__topology_8c.html#a7237d2cf3b3f9d034477268c1d6631da":[11,0,4,1,5],
+"d2/df6/kohonen__som__topology_8c.html#ac6afabdc09a49a433ee19d8a9486056d":[11,0,4,1,3],
+"d2/df6/kohonen__som__topology_8c.html#ad139de302fa8135a433d9c1bf971b13b":[11,0,4,1,18],
+"d2/df6/kohonen__som__topology_8c.html#ad9e25202bb8b481461f932668f249dbc":[11,0,4,1,16],
+"d2/df6/kohonen__som__topology_8c.html#adb5ded007be1fd666fab9affe6764018":[11,0,4,1,15],
+"d2/df6/kohonen__som__topology_8c.html#adc22d512c00a9f5799ee067f4fb90b4b":[11,0,4,1,7],
+"d2/df6/kohonen__som__topology_8c.html#adee1bc3871c881f6e04cb9e0b1d01158":[11,0,4,1,11],
+"d2/df6/kohonen__som__topology_8c.html#af5ce14f026d6d231bef29161bac2b485":[11,0,4,1,4],
+"d2/df6/kohonen__som__topology_8c.html#affe776513b24d84b39af8ab0930fef7f":[11,0,4,1,2],
+"d3/d5a/struct__large__num.html":[10,0,8],
+"d3/d5a/struct__large__num.html#a3fd11c0b413bbabfb8737d4ae73e5aa0":[10,0,8,1],
+"d3/d5a/struct__large__num.html#afaf353a072cf050ac86ac6e39868bcc9":[10,0,8,0],
+"d4/d02/struct_b_s_t_iterator.html":[10,0,12],
+"d4/d02/struct_b_s_t_iterator.html#a29a6586bff08dc6985b29abb50ddc2ff":[10,0,12,2],
+"d4/d02/struct_b_s_t_iterator.html#a7b13dbbbe1bcbb12ec0bbe9949c66c5b":[10,0,12,0],
+"d4/d02/struct_b_s_t_iterator.html#ae02c531c71091f43880fd7eb8f13cc53":[10,0,12,1],
+"d4/d07/ode__forward__euler_8c.html":[11,0,6,3],
+"d4/d07/ode__forward__euler_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,6,3,4],
+"d4/d07/ode__forward__euler_8c.html#a8caee977b26888d34040b122e0e28e3a":[11,0,6,3,1],
+"d4/d07/ode__forward__euler_8c.html#a97075291390a68c262ed66e157a57eb4":[11,0,6,3,5],
+"d4/d07/ode__forward__euler_8c.html#a9ceb646336224ee890a269d0b4600d09":[11,0,6,3,0],
+"d4/d07/ode__forward__euler_8c.html#aaf88ad8f9f7c39fc38f3f03d6fea9df9":[11,0,6,3,2],
+"d4/d07/ode__forward__euler_8c.html#ae6c9413953c8d9d4bc9e374b29586350":[11,0,6,3,3],
+"d4/d2d/struct_c_array.html":[10,0,13],
+"d4/d2d/struct_c_array.html#a53c08029937d9e4c45defcbf9c8898ae":[10,0,13,0],
+"d4/d2d/struct_c_array.html#a7f7310046fa06b26a1ff7772500724ee":[10,0,13,1],
+"d4/d68/qr__decompose_8h.html":[11,0,6,6],
+"d4/d68/qr__decompose_8h.html#a3a584b79941a43d775f9d4ce446dbe05":[11,0,6,6,2],
+"d4/d68/qr__decompose_8h.html#a45c7640d9d22c89c11beb1f567843c56":[11,0,6,6,1],
+"d4/d68/qr__decompose_8h.html#a6b6a0e75e75ff7919057dd275bb69145":[11,0,6,6,5],
+"d4/d68/qr__decompose_8h.html#a82b20e027437df768d7e994cf4cae29f":[11,0,6,6,4],
+"d4/d68/qr__decompose_8h.html#a90562ce8c3707401e9c5809dece68d6a":[11,0,6,6,0],
+"d4/d68/qr__decompose_8h.html#abeec1f78a7a7e7251687e75340331212":[11,0,6,6,3],
+"d4/d68/qr__decompose_8h_source.html":[11,0,6,6],
+"d4/d7b/problem__6_2sol_8c.html":[11,0,7,19,0],
+"d4/d7b/problem__6_2sol_8c.html#a840291bc02cba5474a4cb46a9b9566fe":[11,0,7,19,0,0],
+"d4/d83/problem__401_2sol1_8c.html":[11,0,7,17,0],
+"d4/d83/problem__401_2sol1_8c.html#a236548478af932f1115a71f601a68788":[11,0,7,17,0,7],
+"d4/d83/problem__401_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,17,0,5],
+"d4/d83/problem__401_2sol1_8c.html#a4441a6d27134cf3aed05727800d99456":[11,0,7,17,0,4],
+"d4/d83/problem__401_2sol1_8c.html#a7380e14d595d560007b02ce516b6b215":[11,0,7,17,0,3],
+"d4/d83/problem__401_2sol1_8c.html#aacbb9e1f38be71e22df1584a37c56693":[11,0,7,17,0,0],
+"d4/d83/problem__401_2sol1_8c.html#aaf964739be92adc2f500e7da11e3f6be":[11,0,7,17,0,6],
+"d4/d83/problem__401_2sol1_8c.html#aca7d5718ab8c38506adb3bef2469b319":[11,0,7,17,0,2],
+"d4/d83/problem__401_2sol1_8c.html#adf2a0717e3307419a9d7c52707f5631e":[11,0,7,17,0,1],
+"d4/d99/fibonacci__fast_8c.html":[11,0,5,2],
+"d4/d99/fibonacci__fast_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,5,2,1],
+"d4/d99/fibonacci__fast_8c.html#a7a3d55bd19854075cba2eed6b63cb2d3":[11,0,5,2,0],
+"d4/d99/ode__semi__implicit__euler_8c.html":[11,0,6,5],
+"d4/d99/ode__semi__implicit__euler_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,6,5,2],
+"d4/d99/ode__semi__implicit__euler_8c.html#a720b7e995d2bbc615f94a2c7dbcf84eb":[11,0,6,5,5],
+"d4/d99/ode__semi__implicit__euler_8c.html#a8caee977b26888d34040b122e0e28e3a":[11,0,6,5,1],
+"d4/d99/ode__semi__implicit__euler_8c.html#a97075291390a68c262ed66e157a57eb4":[11,0,6,5,3],
+"d4/d99/ode__semi__implicit__euler_8c.html#a9ceb646336224ee890a269d0b4600d09":[11,0,6,5,0],
+"d4/d99/ode__semi__implicit__euler_8c.html#ad80059877222f885b549f2d0a3dc6b55":[11,0,6,5,4],
+"d4/dbd/problem__23_2sol2_8c.html":[11,0,7,12,1],
+"d4/dbd/problem__23_2sol2_8c.html#a1aca7f530f82b27100262adba9e7556b":[11,0,7,12,1,1],
+"d4/dbd/problem__23_2sol2_8c.html#a34f4ad85151e3a43368ae67f42347f56":[11,0,7,12,1,2],
+"d4/dbd/problem__23_2sol2_8c.html#a3ab61b5a1c4f2288625d160aa0ea8478":[11,0,7,12,1,3],
+"d4/dbd/problem__23_2sol2_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,12,1,4],
+"d4/dbd/problem__23_2sol2_8c.html#a8c7ddb39906f281b801f2cd58d416c2b":[11,0,7,12,1,6],
+"d4/dbd/problem__23_2sol2_8c.html#ac5d600bf3077f4188afc4c5cd2c40eaf":[11,0,7,12,1,0],
+"d4/dbd/problem__23_2sol2_8c.html#af920a16d6ef69dd604b283f427892e06":[11,0,7,12,1,5],
+"d4/dcb/md_hash__r_e_a_d_m_e.html":[7],
+"d4/dd4/struct_graph.html":[10,0,20],
+"d4/dd4/struct_graph.html#a10ff9c6c323cf435f18e424dbb62235e":[10,0,20,3],
+"d4/dd4/struct_graph.html#a14b3734eb135c40cf4401f22bda5bb76":[10,0,20,2],
+"d4/dd4/struct_graph.html#a268ba18d421817ad8713c2e92f19d82a":[10,0,20,4],
+"d4/dd4/struct_graph.html#a2b722f7cfa7a21e4cb5fae488b3d4dcc":[10,0,20,7],
+"d4/dd4/struct_graph.html#a3535be2ce0d62152e54395951330da81":[10,0,20,5],
+"d4/dd4/struct_graph.html#a3ce250f958f7e96ffd9eb06780c21fbe":[10,0,20,1],
+"d4/dd4/struct_graph.html#a6afcd41564ea00294a4c089414979ca1":[10,0,20,8],
+"d4/dd4/struct_graph.html#a72bb0a04571b49a568e0eed371a35c33":[10,0,20,6],
+"d4/dd4/struct_graph.html#aa3f9278e0b50fbec06b93cda9c733dfe":[10,0,20,9],
+"d4/dd4/struct_graph.html#aaaffb7e0621115519a09be31a33c6cda":[10,0,20,0],
+"d4/dea/problem__14_2sol1_8c.html":[11,0,7,4,0],
+"d4/dea/problem__14_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,4,0,1],
+"d4/dea/problem__14_2sol1_8c.html#a81c1df5c17cb16bcc16e346fcff6fa80":[11,0,7,4,0,0],
+"d4/dfe/struct_dict.html":[10,0,16],
+"d4/dfe/struct_dict.html#a2e14d738e06c60eebcc2eac274e6676e":[10,0,16,0],
+"d4/dfe/struct_dict.html#add3f42ea66e92ce457a243d7534f5654":[10,0,16,1],
+"d5/d23/qr__decomposition_8c.html":[11,0,6,7],
+"d5/d23/qr__decomposition_8c.html#a840291bc02cba5474a4cb46a9b9566fe":[11,0,6,7,0],
+"d5/d7e/struct_t.html":[10,0,33],
+"d5/d7e/struct_t.html#a2023d2bb6a6cdf472b567b3ec5cf35d4":[10,0,33,0],
+"d5/d7e/struct_t.html#a5a06d4022d41bad87137ba3430abce8b":[10,0,33,1],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html":[5],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md14":[5,0],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md15":[5,1],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md16":[5,2],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md17":[5,3],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md18":[5,4],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md19":[5,5],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md20":[5,6],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md21":[5,7],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md22":[5,8],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md23":[5,9],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md24":[5,10],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md25":[5,11],
+"d5/d88/md__d_i_r_e_c_t_o_r_y.html#autotoc_md26":[5,12],
+"d5/da1/structnode.html":[10,0,27],
+"d5/da1/structnode.html#a111a569ab2765add9b91c9f94cf9f063":[10,0,27,7],
+"d5/da1/structnode.html#a1aa632fdf50713d86192a96f8191851b":[10,0,27,6],
+"d5/da1/structnode.html#a2783f1aec750191646305988f7e28756":[10,0,27,5],
+"d5/da1/structnode.html#a2d890bb9f6af0ffd73fe79b21124c2a2":[10,0,27,2],
+"d5/da1/structnode.html#a310a09cb5a882788781a5287096ad425":[10,0,27,0],
+"d5/da1/structnode.html#a51e160f22dc6064bac4a4f9f1d931c2c":[10,0,27,10],
+"d5/da1/structnode.html#a6f9100a3fe81d82776ce47ecdba94691":[10,0,27,1],
+"d5/da1/structnode.html#a707bf3f1eeeaf8974e7e8e90f7bfd6a1":[10,0,27,12],
+"d5/da1/structnode.html#a7f5750a90eac14a9a21d5b976cd8b8a7":[10,0,27,9],
+"d5/da1/structnode.html#a8139af7faac30d394e198365a999b54d":[10,0,27,8],
+"d5/da1/structnode.html#aaf2ec5ed1bb563465cbe2e9d16d74d1e":[10,0,27,11],
+"d5/da1/structnode.html#ab4b1f345158daee0725acecd5ba817b1":[10,0,27,13],
+"d5/da1/structnode.html#ac8973feda870a119ccdc25910254db0c":[10,0,27,3],
+"d5/da1/structnode.html#af7109e6ffd82cbbb705e486fd0ce92f0":[10,0,27,4],
+"d5/db4/struct_edge.html":[10,0,18],
+"d5/db4/struct_edge.html#a0c7bb90b11b1b795c665786317ca744d":[10,0,18,4],
+"d5/db4/struct_edge.html#a2449478938136b5ab7ef0e7d92e6990b":[10,0,18,1],
+"d5/db4/struct_edge.html#a4d58e1f4de38fa55549497175981ebab":[10,0,18,5],
+"d5/db4/struct_edge.html#a9a415f211c059647d1b3af8fcf7a0e30":[10,0,18,2],
+"d5/db4/struct_edge.html#ad7df434ff7710e69f28bb31e91a35f82":[10,0,18,0],
+"d5/db4/struct_edge.html#ae746ca841799f776a8add4d6fdfc19e9":[10,0,18,3],
+"d6/d1b/sol4_8c.html":[11,0,7,0,3],
+"d6/d1b/sol4_8c.html#ae66f6b31b5ad750f1fe042a706a4e3d4":[11,0,7,0,3,0],
+"d6/d3d/factorial__large__number_8c.html":[11,0,5,1],
+"d6/d3d/factorial__large__number_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,5,1,4],
+"d6/d3d/factorial__large__number_8c.html#ab54882961780c41a4929a6d390f6522d":[11,0,5,1,1],
+"d6/d3d/factorial__large__number_8c.html#ab5c854e0df76165c31899e69eceeeaae":[11,0,5,1,3],
+"d6/d3d/factorial__large__number_8c.html#ad398ddbd594ca69a5e6dfc894925341e":[11,0,5,1,5],
+"d6/d3d/factorial__large__number_8c.html#ad8101f58545bd891ae8b6e11caadd7eb":[11,0,5,1,6],
+"d6/d3d/factorial__large__number_8c.html#af2869d36c22a2b8f93d3166a84e124b3":[11,0,5,1,2],
+"d6/d42/structdynamic__array.html":[10,0,17],
+"d6/d42/structdynamic__array.html#a79c587474e35f99510ca3018bf700007":[10,0,17,2],
+"d6/d42/structdynamic__array.html#a7e3fbd203b3b86401c17dede7a33f781":[10,0,17,1],
+"d6/d42/structdynamic__array.html#a9ddb0f64ade5d5e74b7fd091158958e4":[10,0,17,0],
+"d6/d48/isogram_8h_source.html":[11,0,2,2,0],
+"d6/d88/problem__16_2sol1_8c.html":[11,0,7,6,0],
+"d6/d88/problem__16_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,6,0,0]
+};
diff --git a/navtreeindex1.js b/navtreeindex1.js
new file mode 100644
index 00000000..bd6eadc0
--- /dev/null
+++ b/navtreeindex1.js
@@ -0,0 +1,253 @@
+var NAVTREEINDEX1 =
+{
+"d6/de3/sol3_8c.html":[11,0,7,0,2],
+"d6/de3/sol3_8c.html#ae66f6b31b5ad750f1fe042a706a4e3d4":[11,0,7,0,2,0],
+"d6/ded/shell__sort2_8c.html":[11,0,8,0],
+"d6/ded/shell__sort2_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,8,0,1],
+"d6/ded/shell__sort2_8c.html#a4b9708d87be7a409eff20e5e7e8b43c8":[11,0,8,0,4],
+"d6/ded/shell__sort2_8c.html#a5bc16eaf3ffe6a6ab66780dd445904c0":[11,0,8,0,2],
+"d6/ded/shell__sort2_8c.html#a841615a63f4a3aa18337897953874909":[11,0,8,0,0],
+"d6/ded/shell__sort2_8c.html#aeccaf61ff47279384d1dba8d869d5c2f":[11,0,8,0,3],
+"d6/df3/graph_8h_source.html":[11,0,1,4,0],
+"d7/d1f/problem__12_2sol1_8c.html":[11,0,7,2,0],
+"d7/d1f/problem__12_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,2,0,1],
+"d7/d1f/problem__12_2sol1_8c.html#aa6ce6271f6156e219f9b290717f5a222":[11,0,7,2,0,0],
+"d7/d50/qr__eigen__values_8c.html":[11,0,6,8],
+"d7/d50/qr__eigen__values_8c.html#a002b2f4894492820fe708b1b7e7c5e70":[11,0,6,8,0],
+"d7/d50/qr__eigen__values_8c.html#a0283886819c7c140a023582b7269e2d0":[11,0,6,8,7],
+"d7/d50/qr__eigen__values_8c.html#a0d8ed79786d17df48396b333c09d05bb":[11,0,6,8,3],
+"d7/d50/qr__eigen__values_8c.html#a1440a7779ac56f47a3f355ce4a8c7da0":[11,0,6,8,6],
+"d7/d50/qr__eigen__values_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,6,8,4],
+"d7/d50/qr__eigen__values_8c.html#a741477692f001a805b0fea942c9dc2b9":[11,0,6,8,5],
+"d7/d50/qr__eigen__values_8c.html#a7d96c5e4ae1bd6d29791bcc23a4cb2b0":[11,0,6,8,2],
+"d7/d50/qr__eigen__values_8c.html#aee57a411f07599034f5ceb8cc7d65b40":[11,0,6,8,1],
+"d7/d90/rna__transcription_8h_source.html":[11,0,2,3,0],
+"d7/d91/problem__15_2sol1_8c.html":[11,0,7,5,0],
+"d7/d91/problem__15_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,5,0,0],
+"d7/d91/problem__15_2sol1_8c.html#a4650d1d3897633d84253f93433f601d6":[11,0,7,5,0,1],
+"d7/db5/md_exercism__r_e_a_d_m_e.html":[6],
+"d7/db5/md_exercism__r_e_a_d_m_e.html#autotoc_md28":[5],
+"d7/dd3/problem__3_2sol1_8c.html":[11,0,7,15,0],
+"d7/dd3/problem__3_2sol1_8c.html#aa0f4796aa2e89c327f827bd55f5cb305":[11,0,7,15,0,0],
+"d7/dd3/problem__3_2sol1_8c.html#ae66f6b31b5ad750f1fe042a706a4e3d4":[11,0,7,15,0,1],
+"d7/dd8/c__atoi__str__to__integer_8c.html":[11,0,0,0],
+"d7/dd8/c__atoi__str__to__integer_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,0,0,1],
+"d7/dd8/c__atoi__str__to__integer_8c.html#abef225390e0b6e84ddfcb18fe573d9c5":[11,0,0,0,2],
+"d7/dd8/c__atoi__str__to__integer_8c.html#ad19049ebfc2088bc1e75e7e958f7b60f":[11,0,0,0,0],
+"d7/ddb/problem__23_2sol1_8c.html":[11,0,7,12,0],
+"d7/ddb/problem__23_2sol1_8c.html#a1aca7f530f82b27100262adba9e7556b":[11,0,7,12,0,1],
+"d7/ddb/problem__23_2sol1_8c.html#a337e545af040d754dc012b42523ee1ee":[11,0,7,12,0,5],
+"d7/ddb/problem__23_2sol1_8c.html#a3ab61b5a1c4f2288625d160aa0ea8478":[11,0,7,12,0,3],
+"d7/ddb/problem__23_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,12,0,4],
+"d7/ddb/problem__23_2sol1_8c.html#a4f128410e6582fe26488e2316cc96e17":[11,0,7,12,0,2],
+"d7/ddb/problem__23_2sol1_8c.html#ac5d600bf3077f4188afc4c5cd2c40eaf":[11,0,7,12,0,0],
+"d7/de0/stack_8h_source.html":[11,0,1,7,1],
+"d8/d32/problem__25_2sol1_8c.html":[11,0,7,13,0],
+"d8/d32/problem__25_2sol1_8c.html#a001791a21d538b8b9176287ae60d9b61":[11,0,7,13,0,0],
+"d8/d32/problem__25_2sol1_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,7,13,0,3],
+"d8/d32/problem__25_2sol1_8c.html#a2b90df6bfbf0d18cd9a19c1a71453783":[11,0,7,13,0,2],
+"d8/d32/problem__25_2sol1_8c.html#abe5bc1f170b2108a19d0a16d30bd3235":[11,0,7,13,0,4],
+"d8/d32/problem__25_2sol1_8c.html#af9729befaffc1aab9ac9fedc4706e66c":[11,0,7,13,0,1],
+"d8/d38/queue_8h_source.html":[11,0,1,4,1],
+"d8/d7a/structtnode.html":[10,0,34],
+"d8/d7a/structtnode.html#a44127c1d017332403d91a96a1633a76a":[10,0,34,3],
+"d8/d7a/structtnode.html#ad302cb43ee1cab8a29581e8aaf76bbd4":[10,0,34,0],
+"d8/d7a/structtnode.html#ae1f202bf98d22f8316eeb71b68a59951":[10,0,34,1],
+"d8/d7a/structtnode.html#af7ce6341b8536c58a5a9ebdb4862a32a":[10,0,34,2],
+"d8/d7c/dict_8h_source.html":[11,0,1,2,0],
+"d8/d81/md_project_euler__r_e_a_d_m_e.html":[9],
+"d8/da2/dynamic__array_8h_source.html":[11,0,1,3,0],
+"d8/de0/problem__9_2sol2_8c.html":[11,0,7,22,1],
+"d8/de0/problem__9_2sol2_8c.html#a840291bc02cba5474a4cb46a9b9566fe":[11,0,7,22,1,0],
+"d9/d41/md_data_structures_array__r_e_a_d_m_e.html":[2],
+"d9/d41/md_data_structures_array__r_e_a_d_m_e.html#autotoc_md6":[2,0],
+"d9/d41/md_data_structures_array__r_e_a_d_m_e.html#autotoc_md7":[2,1],
+"d9/da7/problem__10_2sol2_8c.html":[11,0,7,1,1],
+"d9/da7/problem__10_2sol2_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,7,1,1,0],
+"da/d23/list_8h_source.html":[11,0,1,6,0],
+"da/d35/problem__1_2sol1_8c.html":[11,0,7,0,0],
+"da/d35/problem__1_2sol1_8c.html#ae66f6b31b5ad750f1fe042a706a4e3d4":[11,0,7,0,0,0],
+"da/d38/durand__kerner__roots_8c.html":[11,0,6,0],
+"da/d38/durand__kerner__roots_8c.html#a26d5695ebed0818a3e7cf4b10aacab52":[11,0,6,0,1],
+"da/d38/durand__kerner__roots_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,6,0,3],
+"da/d38/durand__kerner__roots_8c.html#adf4ae062a028c6faf2b96c9c1eb343af":[11,0,6,0,4],
+"da/d38/durand__kerner__roots_8c.html#af270a96662132d0385cb6b4637c5a689":[11,0,6,0,0],
+"da/d38/durand__kerner__roots_8c.html#afa5b04ce11475d67049cba8273741fb7":[11,0,6,0,2],
+"da/d90/stack__linked__list_2stack_8h_source.html":[11,0,1,7,0,0],
+"da/d9b/struct_trie_node.html":[10,0,35],
+"da/d9b/struct_trie_node.html#a8e9e3ac8a47ed2f730476945933722c1":[10,0,35,0],
+"da/d9b/struct_trie_node.html#a9dc2a9bc247486fac3e4b350c73a3060":[10,0,35,1],
+"da/d9b/struct_trie_node.html#ab2732ce1e141346865d997859836d663":[10,0,35,2],
+"db/d01/problem__13_2sol1_8c.html":[11,0,7,3,0],
+"db/d01/problem__13_2sol1_8c.html#a0240ac851181b84ac374872dc5434ee4":[11,0,7,3,0,0],
+"db/d01/problem__13_2sol1_8c.html#a248adc917818cc6666d8bc679a660319":[11,0,7,3,0,5],
+"db/d01/problem__13_2sol1_8c.html#a840291bc02cba5474a4cb46a9b9566fe":[11,0,7,3,0,4],
+"db/d01/problem__13_2sol1_8c.html#ac260f58785fb20eb09bb35385a7d47f8":[11,0,7,3,0,3],
+"db/d01/problem__13_2sol1_8c.html#acd864640121c7df2c19f61f7baa507e4":[11,0,7,3,0,1],
+"db/d01/problem__13_2sol1_8c.html#ad51742ca5a5c99e860bdf30299163bf2":[11,0,7,3,0,2],
+"db/d80/problem__20_2sol1_8c.html":[11,0,7,9,0],
+"db/d80/problem__20_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,9,0,3],
+"db/d80/problem__20_2sol1_8c.html#a54a02c4b963fdb16f24959e0137763f1":[11,0,7,9,0,4],
+"db/d80/problem__20_2sol1_8c.html#a62cbbd106aad52daadb9403a07d0da32":[11,0,7,9,0,1],
+"db/d80/problem__20_2sol1_8c.html#afc373c28da6b17636528edcc97fb5f86":[11,0,7,9,0,2],
+"db/d8b/struct_node.html":[10,0,26],
+"db/d8b/struct_node.html#a0ed3c7305b43527f0f237bbfd438b8f7":[10,0,26,3],
+"db/d8b/struct_node.html#a60b73f452505cef98795d2c8de3e72ef":[10,0,26,1],
+"db/d8b/struct_node.html#a772e2a82248c0d0dfc5cdf19d5b45df9":[10,0,26,2],
+"db/d8b/struct_node.html#a87c003c9f600e3fc58e6e90835f0b605":[10,0,26,0],
+"db/ddb/hello__world_8h_source.html":[11,0,2,1,0],
+"db/dfb/hash_8h_source.html":[11,0,3,0],
+"dc/d2e/lu__decompose_8c.html":[11,0,6,1],
+"dc/d2e/lu__decompose_8c.html#a0789beb8d3396582d77b7aedf5e5554a":[11,0,6,1,0],
+"dc/d2e/lu__decompose_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,6,1,2],
+"dc/d2e/lu__decompose_8c.html#aae40b90a8efd645c749128cf8072bbb4":[11,0,6,1,1],
+"dc/d47/realtime__stats_8c.html":[11,0,6,9],
+"dc/d47/realtime__stats_8c.html#a34be233a9200ee2065f6b7b27e2d9a96":[11,0,6,9,2],
+"dc/d47/realtime__stats_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,6,9,0],
+"dc/d47/realtime__stats_8c.html#a63ddcdaab24f722f0963fa2fbe0ae628":[11,0,6,9,1],
+"dc/d47/realtime__stats_8c.html#aa54c915581fcc495489175a4386d59fd":[11,0,6,9,3],
+"dc/d63/problem__8_2sol1_8c.html":[11,0,7,21,0],
+"dc/d63/problem__8_2sol1_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,7,21,0,1],
+"dc/d63/problem__8_2sol1_8c.html#a9ffc8845f17b01a353767a40a3adf7bd":[11,0,7,21,0,0],
+"dc/d64/md__coding_guidelines.html":[1],
+"dc/d64/md__coding_guidelines.html#autotoc_md2":[1,0],
+"dc/d64/md__coding_guidelines.html#autotoc_md4":[1,1],
+"dc/d77/struct__big__int.html":[10,0,7],
+"dc/d77/struct__big__int.html#a187538b984c86d7cfdb13e297e7f3564":[10,0,7,0],
+"dc/d77/struct__big__int.html#a273ee73fd755f2a99512cca5f0e09008":[10,0,7,2],
+"dc/d77/struct__big__int.html#ad8405989a924410942b39ec0e9fef30b":[10,0,7,1],
+"dc/d80/collatz_8c.html":[11,0,5,0],
+"dc/d80/collatz_8c.html#a0ddf1224851353fc92bfbff6f499fa97":[11,0,5,0,0],
+"dc/de3/hash__set_8h_source.html":[11,0,1,5,0],
+"dc/de5/structsubset.html":[10,0,32],
+"dc/de5/structsubset.html#a2cc3bbda6f758afb7bf8067eb8f07a10":[10,0,32,1],
+"dc/de5/structsubset.html#ad8f7d99dc56f8ce3f0c3aaf4a633373a":[10,0,32,0],
+"dd/d08/newton__raphson__root_8c.html":[11,0,6,2],
+"dd/d08/newton__raphson__root_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,6,2,3],
+"dd/d08/newton__raphson__root_8c.html#a72f87d423a488946b319627a454d3925":[11,0,6,2,2],
+"dd/d08/newton__raphson__root_8c.html#ae713a1fd0c275fbec7edf263ac2c0337":[11,0,6,2,1],
+"dd/d08/newton__raphson__root_8c.html#af270a96662132d0385cb6b4637c5a689":[11,0,6,2,0],
+"dd/d10/struct_stack.html":[10,0,31],
+"dd/d10/struct_stack.html#ad62fb36816185f3eef3a6f735a61f54a":[10,0,31,1],
+"dd/d10/struct_stack.html#ad9b9f0f414ea2dc2437fd42b6cc4321b":[10,0,31,0],
+"dd/d8b/problem__22_2sol1_8c.html":[11,0,7,11,0],
+"dd/d8b/problem__22_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,11,0,3],
+"dd/d8b/problem__22_2sol1_8c.html#a5bc3659aa0949ea33118c95b1dee5f63":[11,0,7,11,0,4],
+"dd/d8b/problem__22_2sol1_8c.html#a6cb9b08aacb61416795ee78bfceacd38":[11,0,7,11,0,1],
+"dd/d8b/problem__22_2sol1_8c.html#ae359b8a4656b164c91ef91a084c15c9d":[11,0,7,11,0,2],
+"dd/d8b/problem__22_2sol1_8c.html#afd709f201d7643c3909621f620ea648a":[11,0,7,11,0,0],
+"dd/d8c/adaline__learning_8c.html":[11,0,4,0],
+"dd/d8c/adaline__learning_8c.html#a00dc6134ca22a12e0fd9cac54d601c2d":[11,0,4,0,7],
+"dd/d8c/adaline__learning_8c.html#a05cc9a0acb524fde727a4d7b4a747ee6":[11,0,4,0,12],
+"dd/d8c/adaline__learning_8c.html#a355fda53c238a0c0c07f03dcc021caed":[11,0,4,0,5],
+"dd/d8c/adaline__learning_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,4,0,8],
+"dd/d8c/adaline__learning_8c.html#a3f37b9f073f7e57fd0b39d70718af1b1":[11,0,4,0,13],
+"dd/d8c/adaline__learning_8c.html#a4db1ba00a7f282100ea31a94e32bd7a3":[11,0,4,0,10],
+"dd/d8c/adaline__learning_8c.html#a6f35caa3084772cc126ac7b20f67f665":[11,0,4,0,4],
+"dd/d8c/adaline__learning_8c.html#a7b12b6513314c975303b5a698608322f":[11,0,4,0,3],
+"dd/d8c/adaline__learning_8c.html#ab4ecb3accf5d9e0263087e7265bbe3a9":[11,0,4,0,11],
+"dd/d8c/adaline__learning_8c.html#acd517c6f195c75b9dd0f3aad65326f3b":[11,0,4,0,2],
+"dd/d8c/adaline__learning_8c.html#acd88962c5f6341e43cbc69b4a7d3485b":[11,0,4,0,9],
+"dd/d8c/adaline__learning_8c.html#af270a96662132d0385cb6b4637c5a689":[11,0,4,0,1],
+"dd/d8c/adaline__learning_8c.html#afa953e811eaae199d121a7ddb619d604":[11,0,4,0,6],
+"dd/d95/word__count_8h_source.html":[11,0,2,4,0],
+"dd/df0/problem__19_2sol1_8c.html":[11,0,7,7,0],
+"dd/df0/problem__19_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,7,0,2],
+"dd/df0/problem__19_2sol1_8c.html#a6561b1adc8a19c092679b9874da24e2e":[11,0,7,7,0,1],
+"dd/df0/problem__19_2sol1_8c.html#ab7f9ad087f124b8e0615aa535b4c8a75":[11,0,7,7,0,0],
+"de/d20/md_data_structures_dictionary__r_e_a_d_m_e.html":[3],
+"de/d20/md_data_structures_dictionary__r_e_a_d_m_e.html#autotoc_md9":[2],
+"de/dce/structmin__heap.html":[10,0,25],
+"de/dce/structmin__heap.html#a456c6372c103c6d1bb430f581f5d3c71":[10,0,25,2],
+"de/dce/structmin__heap.html#a9fd34546dad4dfd9e6a456936b766123":[10,0,25,0],
+"de/dce/structmin__heap.html#ad960bfacd24fb843208db83f113ebc8f":[10,0,25,1],
+"df/d1a/problem__21_2sol1_8c.html":[11,0,7,10,0],
+"df/d1a/problem__21_2sol1_8c.html#a3c04138a5bfe5d72780bb7e82a18e627":[11,0,7,10,0,0],
+"df/d1a/problem__21_2sol1_8c.html#aacf4b7e708651d2164e86958f2c29c93":[11,0,7,10,0,1],
+"df/d3c/threaded__binary__trees_8c.html":[11,0,1,1,0],
+"df/d3c/threaded__binary__trees_8c.html#a284d683f74b6c884e79ba00d3d1c3317":[11,0,1,1,0,3],
+"df/d3c/threaded__binary__trees_8c.html#a306d567466f22e1e927aaed97d8bb58c":[11,0,1,1,0,9],
+"df/d3c/threaded__binary__trees_8c.html#a4c1e06b5f0876ec9c1bd6817f3b7eda7":[11,0,1,1,0,4],
+"df/d3c/threaded__binary__trees_8c.html#a5a82ae0ee13788be51ca4ba6cddb0719":[11,0,1,1,0,7],
+"df/d3c/threaded__binary__trees_8c.html#a8169ba0dfd5b8183672e444d1434bf9c":[11,0,1,1,0,8],
+"df/d3c/threaded__binary__trees_8c.html#a823432888332fc9f0aa6072cff28c3bb":[11,0,1,1,0,5],
+"df/d3c/threaded__binary__trees_8c.html#ab21d1d36d95001defbca2f6abd4d410c":[11,0,1,1,0,2],
+"df/d3c/threaded__binary__trees_8c.html#ad8ecdcce462dd8e170ae1f164935aaa6":[11,0,1,1,0,1],
+"df/d3c/threaded__binary__trees_8c.html#ae66f6b31b5ad750f1fe042a706a4e3d4":[11,0,1,1,0,6],
+"df/d58/md_leetcode__r_e_a_d_m_e.html":[8],
+"df/d58/md_leetcode__r_e_a_d_m_e.html#autotoc_md30":[6],
+"df/da5/problem__9_2sol1_8c.html":[11,0,7,22,0],
+"df/da5/problem__9_2sol1_8c.html#a840291bc02cba5474a4cb46a9b9566fe":[11,0,7,22,0,0],
+"df/db3/struct_l.html":[10,0,23],
+"df/db3/struct_l.html#a4d585643a6364fbf79f54de5fa49d17f":[10,0,23,1],
+"df/db3/struct_l.html#adbf91f5f6cc3047e13bb3dbbfb277be0":[10,0,23,0],
+"df/dc6/acronym_8h_source.html":[11,0,2,0,0],
+"df/ddb/structword__count__word.html":[10,0,36],
+"df/ddb/structword__count__word.html#a44e237e11196ffa56574b90ea807e8fc":[10,0,36,0],
+"df/ddb/structword__count__word.html#a9c018b5f83b2aeeefac5cc09e5f41efd":[10,0,36,1],
+"df/de7/problem__5_2sol_8c.html":[11,0,7,18,0],
+"df/de7/problem__5_2sol_8c.html#a59347107cbfdf48d51108e50280e760d":[11,0,7,18,0,0],
+"df/de7/problem__5_2sol_8c.html#a840291bc02cba5474a4cb46a9b9566fe":[11,0,7,18,0,2],
+"df/de7/problem__5_2sol_8c.html#ae9606f1867e9921867d6572f51377b4c":[11,0,7,18,0,1],
+"df/dea/structdata.html":[10,0,15],
+"df/dea/structdata.html#a7a7e33023945ddb393dc306c489c4049":[10,0,15,1],
+"df/dea/structdata.html#ab1464d70ed28af0a16cdd2ebaa64027c":[10,0,15,0],
+"dir_0472225043064b54f3dfff9011a9fae0.html":[11,0,1,7,0],
+"dir_079e1f799fb08a8a0b98cb030ab15687.html":[11,0,7,13],
+"dir_0bc3e2a5baf077fa21dadc079776fcac.html":[11,0,7,7],
+"dir_167af11096b7752ff31b3d4bec489317.html":[11,0,7,19],
+"dir_16b947d8e9a05fe119d0675493324331.html":[11,0,7,1],
+"dir_16e00c78ef36d1842d0d8a4afc46b852.html":[11,0,7,14],
+"dir_1833eb69ceee7a265ffba4c38c8243d2.html":[11,0,7,16],
+"dir_18cba55772148686552805a354a79093.html":[11,0,7,6],
+"dir_2176ba3565d8b1fe2a106d18679cc7bf.html":[11,0,1,7],
+"dir_2abe2c0880d3fb0dba0f784bee3fc9e0.html":[11,0,7,11],
+"dir_2b14f32f14b51065d3a322bea21da3c0.html":[11,0,7,5],
+"dir_2e746e9d06bf2d8ff842208bcc6ebcfc.html":[11,0,1],
+"dir_2f070f19f76dfadabbc24fe483d7e98d.html":[11,0,7,17],
+"dir_2fede762f95c9c526850a639b984c56b.html":[11,0,1,4],
+"dir_3343723ae086de42ee4ca9774da3a13f.html":[11,0,4],
+"dir_4500de955d1eddb82f69331d96e39ed9.html":[11,0,2,1],
+"dir_475f56e0a4ef6254f5610544d8d68aa3.html":[11,0,2,4],
+"dir_48bf5503321d91c557399989fed5dabd.html":[11,0,2],
+"dir_4991c92e00761dd3d764efa2906b4318.html":[11,0,7,9],
+"dir_4a15c8553efb9e59e3f1091cc0d3a27d.html":[11,0,7,21],
+"dir_4bae997a2671812c2140d5abfb6305a4.html":[11,0,7,20],
+"dir_607f15d36c772334f988bb9ef82d102c.html":[11,0,7,18],
+"dir_72aaf47615111200018c039a56ef48be.html":[11,0,3],
+"dir_7445e5a68245b48f3c03982b6d501815.html":[11,0,1,2],
+"dir_76784a7b04633629b9ecb5543b9ad889.html":[11,0,2,2],
+"dir_81f43aa0067826ea5befe80cd7aefcc5.html":[11,0,2,3],
+"dir_8c6743d405e8ed13cc39f42e382307fd.html":[11,0,7,0],
+"dir_955029374964e51cf770754b424e7d39.html":[11,0,1,5],
+"dir_9babc524d57e25f3d9f4179cabc3599e.html":[11,0,0],
+"dir_9c6faab82c22511b50177aa2e38e2780.html":[11,0,6],
+"dir_a52f4d3d586a58b02f3a4ddf0a992157.html":[11,0,5],
+"dir_aba97bf327db94061e830e9bc18e925d.html":[11,0,7,4],
+"dir_b2dbfa46230fd9f775c32c1836ed3764.html":[11,0,7,15],
+"dir_b3d331eabd4234f247030c297aaf021c.html":[11,0,7],
+"dir_b6018f60d424a2ef7e4c942ac681e38b.html":[11,0,1,6],
+"dir_bb1b521853a9c46347182a9d10420771.html":[11,0,8],
+"dir_bd4a7dd282074645ef41b1ea31ac813a.html":[11,0,1,3],
+"dir_c7ef0fcb2f2095a74f0a3a1634dfc798.html":[11,0,1,0],
+"dir_d4c35186c199e728d69dee6bf5b2473c.html":[11,0,7,22],
+"dir_d9112ab06cf4d4e5a25d385a268d1949.html":[11,0,7,2],
+"dir_d9e100c82ada2163abea49688a71e81c.html":[11,0,7,10],
+"dir_e39df94f82619fa5256f1786519937be.html":[11,0,1,1],
+"dir_eeeea13e3a5e5edad3499183767ce312.html":[11,0,7,8],
+"dir_f75ccd45e00436eafed446b9b2682984.html":[11,0,7,12],
+"dir_f7d3c03fcac84aef1b0c66cc497ed1ea.html":[11,0,7,3],
+"dir_fe5d69ed7d90cb356556070c2a2e5478.html":[11,0,2,0],
+"files.html":[11,0],
+"functions.html":[10,2,0],
+"functions_vars.html":[10,2,1],
+"globals.html":[11,1,0],
+"globals_defs.html":[11,1,4],
+"globals_func.html":[11,1,1],
+"globals_type.html":[11,1,3],
+"globals_vars.html":[11,1,2],
+"index.html":[0],
+"index.html":[],
+"index.html#autotoc_md32":[0],
+"index.html#autotoc_md33":[1]
+};
diff --git a/navtreeindex2.js b/navtreeindex2.js
new file mode 100644
index 00000000..ff144e94
--- /dev/null
+++ b/navtreeindex2.js
@@ -0,0 +1,4 @@
+var NAVTREEINDEX2 =
+{
+"pages.html":[]
+};
diff --git a/open.png b/open.png
new file mode 100644
index 0000000000000000000000000000000000000000..30f75c7efe2dd0c9e956e35b69777a02751f048b
GIT binary patch
literal 123
zcmeAS@N?(olHy`uVBq!ia0vp^oFL4>1|%O$WD@{VPM$7~Ar*{o?;hlAFyLXmaDC0y
znK1_#cQqJWPES%4Uujug^TE?jMft$}Eq^WaR~)%f)vSNs&gek&x%A9X9sM|
+ Algorithms_in_C
+ 1.0.0
+
+ Set of algorithms implemented in C.
+ |
+
1.8.18 
