Merge remote-tracking branch 'upstream/master'

Author: jiegillet

README.md

@@ -1,5 +1,6 @@
 # The Arcane Algorithm Archive
-The Arcane Algorithm Archive for all our adventures on LeiosOS / simuleios <br/>
+The Arcane Algorithm Archive is a collaborative effort to create a guide for all important algorithms in all languages. 
+This goal is obviously too ambitious for a book of any size, but it is a great project to learn from and work on and will hopefully become an incredible resource for programmers in the future.
 The book can be found here: https://www.gitbook.com/book/leios/algorithm-archive/details.
 The github repository can be found here: https://github.com/leios/algorithm-archive.
 Most algorithms have been covered on the youtube channel LeiosOS: https://www.youtube.com/user/LeiosOS

book.json

@@ -71,7 +71,12 @@
 				{
 					"lang": "elm",
 					"name": "Elm"
+				},
+				{
+					"lang": "LabVIEW",
+					"name": "LabVIEW"
 				}
+                                
 			],
 			"split": false
         }

chapters/FFT/code/c/fft.c

@@ -1,105 +1,88 @@
-// written by Gathros.
-
 #include <complex.h>
 #include <math.h>
-
-// These headers are for presentation not for the algorithm.
 #include <stdlib.h>
 #include <time.h>
 #include <stdio.h>
 
 #define PI 3.1415926535897932384626
 
-void cooley_tukey(double complex *X, const size_t N){
-	if(N >= 2){
-		// Splits the array, so the top half are the odd elements and the bottom half are the even ones.
-		double complex tmp [N/2];
-		for(size_t i = 0; i < N/2; ++i){
-			tmp[i] = X[2*i + 1];
-			X[i] = X[2*i];
-		}
-		for(size_t i = 0; i < N/2; ++i){
-			X[i + N/2] = tmp[i];
-		}
+void cooley_tukey(double complex *X, const size_t N) {
+    if (N >= 2) {
+        double complex tmp [N / 2];
+        for (size_t i = 0; i < N / 2; ++i) {
+            tmp[i] = X[2*i + 1];
+            X[i] = X[2*i];
+        }
+        for (size_t i = 0; i < N / 2; ++i) {
+            X[i + N / 2] = tmp[i];
+        }
 
-		// Recursion.
-		cooley_tukey(X, N/2);
-		cooley_tukey(X + N/2, N/2);
+        cooley_tukey(X, N / 2);
+        cooley_tukey(X + N / 2, N / 2);
 
-		// Combine.
-		for(size_t i = 0; i < N/2; ++i){
-			X[i + N/2] = X[i] - cexp(-2.0*I*PI*i/N)*X[i + N/2];
-			X[i] -= (X[i + N/2]-X[i]);
-		}
-	}
+        for (size_t i = 0; i < N / 2; ++i) {
+            X[i + N / 2] = X[i] - cexp(-2.0 * I * PI * i / N) * X[i + N / 2];
+            X[i] -= (X[i + N / 2]-X[i]);
+        }
+    }
 }
 
-void bit_reverse(double complex *X, size_t N){
-        // Bit reverses the array X[] but only if the size of the array is less then 2^32.
-		double complex temp;
+void bit_reverse(double complex *X, size_t N) {
+        double complex temp;
         unsigned int b;
 
-        for(unsigned int i = 0; i < N; ++i){
+        for (unsigned int i = 0; i < N; ++i) {
                 b = i;
                 b = (((b & 0xaaaaaaaa) >> 1) | ((b & 0x55555555) << 1));
                 b = (((b & 0xcccccccc) >> 2) | ((b & 0x33333333) << 2));
                 b = (((b & 0xf0f0f0f0) >> 4) | ((b & 0x0f0f0f0f) << 4));
                 b = (((b & 0xff00ff00) >> 8) | ((b & 0x00ff00ff) << 8));
-                b = ((b >> 16) | (b << 16)) >> (32 - (unsigned int) log2((double)N));
-                if(b > i){
+                b = ((b >> 16) | (b << 16)) >>
+                        (32 - (unsigned int) log2((double)N));
+                if (b > i) {
                         temp = X[b];
                         X[b] = X[i];
                         X[i] = temp;
                 }
         }
 }
 
-void iterative_cooley_tukey(double complex *X, size_t N){
-	int stride;
-	double complex v,w;
-
-	// Bit reverse the array.
-	bit_reverse(X, N);
-
-	// Preform the butterfly on the array.
-	for(int i = 1; i <= log2((double)N); ++i){
-		stride = pow(2, i);
-		w = cexp(-2.0*I*PI/stride);
-		for(size_t j = 0; j < N; j += stride){
-			v = 1.0;
-			for(size_t k = 0; k < stride/2; k++){
-				X[k + j + stride/2] = X[k + j] - v*X[k + j + stride/2];
-				X[k + j] -= (X[k + j + stride/2] - X[k + j]);
-				v *= w;
-			}
-		}
-	}
+void iterative_cooley_tukey(double complex *X, size_t N) {
+    bit_reverse(X, N);
+
+    for (int i = 1; i <= log2((double)N); ++i) {
+        int stride = pow(2, i);
+        double complex w = cexp(-2.0 * I * PI / stride);
+        for (size_t j = 0; j < N; j += stride) {
+            double complex v = 1.0;
+            for (size_t k = 0; k < stride / 2; ++k) {
+                X[k + j + stride / 2] = X[k + j] - v * X[k + j + stride / 2];
+                X[k + j] -= (X[k + j + stride / 2] - X[k + j]);
+                v *= w;
+            }
+        }
+    }
 }
 
-void approx(double complex *X, double complex *Y, size_t N){
-	// This is to show that the arrays are approximate.
-	for(size_t i = 0; i < N; ++i){
-		printf("%f\n", cabs(X[i]) - cabs(Y[i]));
-	}
+void approx(double complex *X, double complex *Y, size_t N) {
+    for (size_t i = 0; i < N; ++i) {
+        printf("%f\n", cabs(X[i]) - cabs(Y[i]));
+    }
 }
 
-int main(){
-	// Initalizing the arrays for FFT.
-	srand(time(NULL));
-	const size_t N = 64;
-	double complex x[N], y[N], z[N];
-	for(size_t i = 0; i < N; ++i){
-		x[i] = rand() / (double) RAND_MAX;
-		y[i] = x[i];
-		z[i] = x[i];
-	}
+int main() {
+    srand(time(NULL));
+    double complex x[64], y[64], z[64];
+    for (size_t i = 0; i < 64; ++i) {
+        x[i] = rand() / (double) RAND_MAX;
+        y[i] = x[i];
+        z[i] = x[i];
+    }
 
-	// Preform FFT.
-	cooley_tukey(y, N);
-	iterative_cooley_tukey(z, N);
+    cooley_tukey(y, 64);
+    iterative_cooley_tukey(z, 64);
 
-	// Check if the different methods are approximate.
-	approx(y, z, N);
+    approx(y, z, 64);
 
-	return 0;
+    return 0;
 }

chapters/FFT/cooley_tukey.md

@@ -51,7 +51,9 @@ If we take a sum sinusoidal functions (like $$\sin(\omega t)$$ or $$\cos(\omega
 Each constituent wave can be described by only one value: $$\omega$$.
 So, instead of representing these curves as seen above, we could instead describe them as peaks in frequency space, as shown below. 
 
-![Fourier Example](res/FT_example.png)
+<p align="center">
+    <img src="res/FT_example.png" width="500" height="250" />
+</p>
 
 This is what the Fourier Transform does! 
 After performing the transform, it is now much, much easier to understand precisely which frequencies are in our waveform, which is essential to most areas of signal processing.
@@ -138,9 +140,9 @@ In the end, the code looks like:
 {% sample lang="jl" %}
 [import:14-31, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
-[import:13-35, lang:"c_cpp"](code/c/fft.c)
+[import:9-28, lang:"c_cpp"](code/c/fft.c)
 {% sample lang="cpp" %}
-[import:19-44, lang:"c_cpp"](code/c++/fft.cpp)
+[import:27-57, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
 [import:6-19, lang:"haskell"](code/hs/fft.hs)
 {% sample lang="py2" %}
@@ -170,7 +172,9 @@ And at each step, we use the appropriate term.
 For example, imagine we need to perform an FFT of an array of only 2 elements. 
 We can represent this addition with the following (radix-2) butterfly:
 
-![Radix-2, positive W](res/radix-2screen_positive.jpg)
+<p align="center">
+    <img src="res/radix-2screen_positive.jpg" width="400" height="225" />
+</p>
 
 Here, the diagram means the following:
 
@@ -182,7 +186,9 @@ $$
 
 However, it turns out that the second half of our array of $$\omega$$ values is always the negative of the first half, so $$\omega_2^0 = -\omega_2^1$$, so we can use the following butterfly diagram:
 
-![Radix-2](res/radix-2screen.jpg)
+<p align="center">
+    <img src="res/radix-2screen.jpg" width="400" />
+</p>
 
 With the following equations:
 
@@ -197,14 +203,18 @@ Now imagine we need to combine more elements.
 In this case, we start with simple butterflies, as shown above, and then sum butterflies of butterflies.
 For example, if we have 8 elements, this might look like this:
 
-![Radix-8](res/radix-8screen.jpg)
+<p align="center">
+    <img src="res/radix-8screen.jpg" width="500" height="500" />
+</p>
 
 Note that we can perform a DFT directly before using any butterflies, if we so desire, but we need to be careful with how we shuffle our array if that's the case.
 In the code snippet provided in the previous section, the subdivision was performed in the same function as the concatenation, so the ordering was always correct; however, if we were to re-order with bit-reversal, this might not be the case.
 
 For example, take a look at the ordering of FFT ([found on wikipedia](https://en.wikipedia.org/wiki/Butterfly_diagram)) that performs the DFT shortcut:
 
-![Butterfly Diagram](res/butterfly_diagram.png)
+<p align="center">
+    <img src="res/butterfly_diagram.png" width="600" height="500" />
+</p>
 
 Here, the ordering of the array was simply divided into even and odd elements once, but they did not recursively divide the arrays of even and odd elements again because they knew they would perform a DFT soon thereafter.
 

chapters/convolutions/code/c/convolutions.c

@@ -5,50 +5,49 @@
 
 #include <math.h>
 
-void fft(double complex *X, size_t N){
-    if(N >= 2){
-        // Splits the array, so the top half are the odd elements and the bottom half are the even ones.
-        double complex tmp [N/2];
-        for(size_t i = 0; i < N/2; ++i){
-            tmp[i] = X[2*i + 1];
-            X[i] = X[2*i];
+void fft(double complex *X, size_t N) {
+    if (N >= 2) {
+        double complex tmp [N / 2];
+        for (size_t i = 0; i < N / 2; ++i) {
+            tmp[i] = X[2 * i + 1];
+            X[i] = X[2 * i];
         }
-        for(size_t i = 0; i < N/2; ++i){
-            X[i + N/2] = tmp[i];
+
+        for (size_t i = 0; i < N / 2; ++i) {
+            X[i + N / 2] = tmp[i];
         }
 
-        // Recursion.
-        fft(X, N/2);
-        fft(X + N/2, N/2);
+        fft(X, N / 2);
+        fft(X + N / 2, N / 2);
 
-        // Combine.
-        for(size_t i = 0; i < N/2; ++i){
-            X[i + N/2] = X[i] - cexp(-2.0*I*M_PI*i/N)*X[i + N/2];
-            X[i] -= (X[i + N/2]-X[i]);
+        for (size_t i = 0; i < N / 2; ++i) {
+            X[i + N/2] = X[i] - cexp(-2.0 * I * M_PI * i / N) * X[i + N / 2];
+            X[i] -= (X[i + N / 2] - X[i]);
         }
     }
 }
 
-void ifft(double complex *x, size_t n){
-    for(size_t i = 0; i < n; i++){
+void ifft(double complex *x, size_t n) {
+    for (size_t i = 0; i < n; ++i) {
         x[i] = conj(x[i]);
     }
 
     fft(x, n);
 
-    for(size_t i = 0; i < n; i++){
-        x[i] = conj(x[i])/n;
+    for (size_t i = 0; i < n; ++i) {
+        x[i] = conj(x[i]) / n;
     }
 }
 
 // This section is a part of the algorithm
 
-void conv(double complex *signal1, double complex *signal2, double complex* out, size_t n1, size_t n2){
+void conv(double complex *signal1, double complex *signal2, double complex* out,
+            size_t n1, size_t n2) {
     double complex sum = 0;
 
-    for(size_t i = 0; i < (n1 < n2? n2 : n1); i++){
-        for(size_t j = 0; j < i; j++){
-            if(j < n1){
+    for (size_t i = 0; i < (n1 < n2? n2 : n1); ++i) {
+        for (size_t j = 0; j < i; ++j) {
+            if (j < n1) {
                 sum += signal1[j] * signal2[i-j];
             }
         }
@@ -57,22 +56,24 @@ void conv(double complex *signal1, double complex *signal2, double complex* out,
     }
 }
 
-void conv_fft(double complex *signal1, double complex *signal2, double complex* out, size_t n){
+void conv_fft(double complex *signal1, double complex *signal2,
+                double complex* out, size_t n) {
     fft(signal1, n);
     fft(signal2, n);
 
-    for(size_t i = 0; i < n; i++){
-        out[i] = signal1[i]*signal2[i];
+    for (size_t i = 0; i < n; ++i) {
+        out[i] = signal1[i] * signal2[i];
     }
 
     ifft(out, n);
 }
 
-int main(){
-    double complex signal1[64], signal2[64], signal3[128], signal4[128], out1[128], out2[128];
+int main() {
+    double complex signal1[64], signal2[64], signal3[128], signal4[128],
+                    out1[128], out2[128];
 
-    for(size_t i = 0; i < 128; i++){
-        if(i >= 16 && i < 48){
+    for (size_t i = 0; i < 128; ++i) {
+        if (i >= 16 && i < 48) {
             signal1[i] = 1.0;
             signal2[i] = 1.0;
             signal3[i] = 1.0;
@@ -97,8 +98,9 @@ int main(){
     conv(signal1, signal2, out1, 64, 64);
     conv_fft(signal3, signal4, out2, 128);
 
-    for(size_t i = 0; i < 64; i++){
-        printf("%zu %f %+fi\n", i, creal(out1[i]) - creal(out2[i]), cimag(out1[i]) - cimag(out2[i]));
+    for (size_t i = 0; i < 64; ++i) {
+        printf("%zu %f %+fi\n", i, creal(out1[i]) - creal(out2[i]),
+                cimag(out1[i]) - cimag(out2[i]));
     }
 
     return 0;