Merge remote-tracking branch 'upstream/master'

Author: jiegillet

.editorconfig

@@ -1,14 +1,10 @@
 root = true
 
-# This file
-[.editorconfig]
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-# Pretty much everything should trim whitespace and have a final EOL
-[*.{c,clj,cpp,cs,css,elm,go,hs,html,jl,js,md,py,rs}]
+# Base for all text files
+[*]
 trim_trailing_whitespace = true
 insert_final_newline = true
+end_of_line = lf
 
 # C
 [*.c]
@@ -35,6 +31,11 @@ indent_size = 4
 indent_style = space
 indent_size = 2
 
+# D
+[*.d]
+indent_style = space
+indent_size = 4
+
 # Elm
 [*.elm]
 indent_style = space
@@ -54,6 +55,11 @@ indent_size = 2
 indent_style = space
 indent_size = 2
 
+# Java
+[*.java]
+indent_style = space
+indent_size = 4
+
 # Julia
 [*.jl]
 indent_style = space
@@ -69,6 +75,11 @@ indent_size = 2
 indent_style = space
 indent_size = 2
 
+# OCAML
+[*.ml]
+indent_style = space
+indent_size = 2
+
 # Python
 [*.py]
 indent_style = space

.gitattributes

@@ -0,0 +1,2 @@
+# Force all text files to have LF line endings
+* text=auto eol=lf

CONTRIBUTORS.md

@@ -3,4 +3,8 @@ Nicole Mazzuca
 Marius Becker
 Gathros
 Jeremie Gillet (- Jie -)
-Salim Khatib
+Salim Khatib
+Hitesh C
+Maxime Dherbécourt
+Jess 3Jane
+Pen Pal

README.md

@@ -1,15 +1,17 @@
 # The Arcane Algorithm Archive
-The Arcane Algorithm Archive is a collaborative effort to create a guide for all important algorithms in all languages. 
+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.algorithm-archive.org/.
 The github repository can be found here: https://github.com/algorithm-archivists/algorithm-archive.
 Most algorithms have been covered on the youtube channel LeiosOS: https://www.youtube.com/user/LeiosOS
-and livecoded on Twitch: https://www.twitch.tv/simuleios
+and livecoded on Twitch: https://www.twitch.tv/simuleios.
+If you would like to communicate more directly, please feel free to go to our discord: https://discord.gg/Pr2E9S6.
 
-Note that the this project is is essentially a book about algorithms collaboratively written by an online community. 
+
+Note that the this project is is essentially a book about algorithms collaboratively written by an online community.
 Fortunately, there are a lot of algorithms out there, which means that there is a lot of content material available.
 Unfortunately, this means that we will probably never cover every algorithm ever created and instead need to focus on what the community sees as useful and necessary.
-That said, we'll still cover a few algorithms for fun that have very litte, if any practical purpose.
+That said, we'll still cover a few algorithms for fun that have very little, if any practical purpose.
 
 If you would like to contribute, feel free to go to any chapter with code associated with it and implement that algorithm in your favorite language,
 and then submit the code via pull request, following the submission guidelines found in `chapters/how_to_contribute.md` (or [here](chapters/how_to_contribute.md) if you are reading this on gitbook).

SUMMARY.md

@@ -28,6 +28,7 @@
 * [Tree Traversal](chapters/tree_traversal/tree_traversal.md)
 * [Euclidean Algorithm](chapters/euclidean_algorithm/euclidean.md)
 * [Multiplication](chapters/multiplication/multiplication.md)
+* [Monte Carlo](chapters/monte_carlo/monte_carlo.md)
 * [Matrix Methods](chapters/matrix_methods/matrix_methods.md)
     * [Gaussian Elimination](chapters/matrix_methods/gaussian_elimination/gaussian_elimination.md)
     * [Thomas Algorithm](chapters/matrix_methods/thomas/thomas.md)

TODO.md

@@ -22,8 +22,8 @@ I'll try to keep this list updated as I write more sections
 
 Here are points of discussion that need to be had about the Algorithm Archive before it gets too big and becomes too difficult to revise everything
 
-* **Should community-submitted code be clean or efficeint?** When it comes to writing code, I often feel readability is the most important factor to keep in mind; however, with the code submitted to this archive, there will be psudocode available to guide new folks through the process of writing the algorithm for the first time. For this reason, it might be best for the community to submit the most efficient code they can write in their own languages, commenting in any tricks to improve performance.
-* **Is the current method of writing optimal?** When I originally envisioned this project, I thought that I would do all the writing and the community would do (most of) the coding. That said, I am becoming more open to the idea of letting community members write for the Archive. The advantage to this is obvious: The book gets written faster. The disadvantage is also obvious: We lose focus and consistency throughout the book. 
-* **We need a Logo.**  I have no idea how to go about this. Maybe a logo contest at 16384 subscribers on youtube? The project will be large enough at that point to warrant a good logo. I really want something simple, though, like a [Trefoil Knot](https://en.wikipedia.org/wiki/Trefoil_knot#/media/File:Trefoil_knot_left.svg) or something. It kinda looks like 3 A's if you look at it the right way, and we'll definitely cover knot algorithms at some point because they are fascinating! 
+* **Should community-submitted code be clean or efficient?** When it comes to writing code, I often feel readability is the most important factor to keep in mind; however, with the code submitted to this archive, there will be pseudocode available to guide new folks through the process of writing the algorithm for the first time. For this reason, it might be best for the community to submit the most efficient code they can write in their own languages, commenting in any tricks to improve performance.
+* **Is the current method of writing optimal?** When I originally envisioned this project, I thought that I would do all the writing and the community would do (most of) the coding. That said, I am becoming more open to the idea of letting community members write for the Archive. The advantage to this is obvious: The book gets written faster. The disadvantage is also obvious: We lose focus and consistency throughout the book.
+* **We need a Logo.**  I have no idea how to go about this. Maybe a logo contest at 16384 subscribers on youtube? The project will be large enough at that point to warrant a good logo. I really want something simple, though, like a [Trefoil Knot](https://en.wikipedia.org/wiki/Trefoil_knot#/media/File:Trefoil_knot_left.svg) or something. It kinda looks like 3 A's if you look at it the right way, and we'll definitely cover knot algorithms at some point because they are fascinating!
 
 Anyway, let me know what you think. I love the community we have here and appreciate all the conversations we've had so far!

book.json

@@ -25,7 +25,7 @@
 				},
 				{
 					"lang": "cs",
-					"name": "C#"	
+					"name": "C#"
 				},
 				{
 					"lang": "cpp",
@@ -78,8 +78,12 @@
 				{
 					"lang": "LabVIEW",
 					"name": "LabVIEW"
+				},
+				{
+					"lang": "d",
+					"name": "D"
 				}
-                                
+
 			],
 			"split": false
         }

book_ace.json

@@ -18,14 +18,14 @@
 				},
 				{
 					"lang": "cs",
-					"name": "C#"	
+					"name": "C#"
 				},
 				{
 					"lang": "c",
-					"name": "C"	
+					"name": "C"
 				}
 			],
-			"split": true 
+			"split": true
 		},
 		"include-codeblock": {
 			"template": "ace",

chapters/FFT/code/c/fft.c

@@ -1,10 +1,21 @@
 #include <complex.h>
 #include <math.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <time.h>
-#include <stdio.h>
 
-#define PI 3.1415926535897932384626
+void dft(double complex *X, const size_t N) {
+    double complex tmp[N];
+    for (size_t i = 0; i < N; ++i) {
+        tmp[i] = 0;
+        for (size_t j = 0; j < N; ++j) {
+            tmp[i] += X[j] * cexp(-2.0 * M_PI * I * j * i / N);
+        }
+    }
+
+    memcpy(X, tmp, N * sizeof(*X));
+}
 
 void cooley_tukey(double complex *X, const size_t N) {
     if (N >= 2) {
@@ -21,38 +32,40 @@ void cooley_tukey(double complex *X, const size_t N) {
         cooley_tukey(X + N / 2, N / 2);
 
         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 + 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 bit_reverse(double complex *X, size_t N) {
-        double complex temp;
-        unsigned int b;
+    for (int i = 0; i < N; ++i) {
+        int n = i;
+        int a = i;
+        int count = (int)log2((double)N) - 1;
 
-        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) {
-                        temp = X[b];
-                        X[b] = X[i];
-                        X[i] = temp;
-                }
+        n >>= 1;
+        while (n > 0) {
+            a = (a << 1) | (n & 1);
+            count--;
+            n >>= 1;
         }
+        n = (a << count) & ((1 << (int)log2((double)N)) - 1);
+
+        if (n > i) {
+            double complex tmp = X[i];
+            X[i] = X[n];
+            X[n] = tmp;
+        }
+    }
 }
 
 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);
+        double complex w = cexp(-2.0 * I * M_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) {

chapters/FFT/code/julia/fft.jl

@@ -5,7 +5,7 @@ function DFT(x)
     # We want two vectors here for real space (n) and frequency space (k)
     n = 0:N-1
     k = n'
-    transform_matrix = exp.(-2im * pi *n *k / N)
+    transform_matrix = exp.(-2im*pi*n*k/N)
     return transform_matrix*x
 
 end
@@ -22,11 +22,10 @@ function cooley_tukey(x)
         x_even = x[2]
     end
     n = 0:N-1
-    #n = n'
     half = div(N,2)
     factor = exp.(-2im*pi*n/N)
     return vcat(x_odd + x_even .* factor[1:half],
-                x_odd - x_even .* factor[1:half]) 
+                x_odd - x_even .* factor[1:half])
 
 end
 
@@ -85,7 +84,7 @@ function iterative_cooley_tukey(x)
            for k = 1:length(y)
                z[start_index+k-1] = y[k]
            end
-       end 
+       end
        bnum = div(bnum,2)
     end