added a file to allow merge

Author: jiegillet

CONTRIBUTORS.md

@@ -3,3 +3,5 @@ Nicole Mazzuca
 Marius Becker
 Gathros
 Jeremie Gillet (- Jie -)
+Salim Khatib
+Hitesh C

README.md

@@ -1,10 +1,12 @@
 # The Arcane Algorithm Archive
 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.
+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. 
 Fortunately, there are a lot of algorithms out there, which means that there is a lot of content material available.

SUMMARY.md

@@ -1,6 +1,6 @@
 # Summary
 
-* [README](README.md)
+* [Algorithm Archive](README.md)
 * [TODO](TODO.md)
 * [Introduction](chapters/introduction.md)
 * [A Personal Note](chapters/getting_started.md)
@@ -46,5 +46,8 @@
 * [Physics Solvers](chapters/physics_solvers/physics_solvers.md)
     * [Verlet Integration](chapters/physics_solvers/verlet/verlet.md)
     * [Barnes-Hut](chapters/physics_solvers/barnes_hut.md)
+    * [Quantum Systems](chapters/physics_solvers/quantum/quantum.md)
+        * [Split-Operator Method](chapters/physics_solvers/quantum/split-op/split-op.md)
 * [Data Compression](chapters/data_compression/data_compression.md)
     * [Huffman Encoding](chapters/data_compression/huffman/huffman.md)
+* [Quantum Information](chapters/QI/QI.md)

book.json

@@ -1,6 +1,6 @@
 {
     "gitbook": "3.x.x",
-    "plugins": ["mathjax", "bibtex-cite", "creativecommons", "wordcount", "theme-api", "include-codeblock"],
+    "plugins": ["mathjax", "bibtex-cite", "creativecommons", "wordcount", "theme-api", "include-codeblock", "ga"],
     "lunr": {
         "maxIndexSize": 1000000000
     },
@@ -9,6 +9,9 @@
 			"fixlang": true,
 			"unindent": true
 		},
+                "ga": {
+                     "token": "UA-118252470-1"
+                 },
 		"theme-api": {
 			"languages": [
 				{

book_ace.json

@@ -0,0 +1,36 @@
+{
+
+    "plugins": ["mathjax", "bibtex-cite", "creativecommons", "wordcount", "theme-api", "include-codeblock", "ace"],
+    "lunr": {
+        "maxIndexSize": 1000000000
+    },
+	"pluginsConfig": {
+		"theme-api": {
+			"languages": [
+				{
+					"lang": "pseudo",
+					"name": "Pseudocode",
+					"default": true
+				},
+				{
+					"lang": "jl",
+					"name": "julia"
+				},
+				{
+					"lang": "cs",
+					"name": "C#"	
+				},
+				{
+					"lang": "c",
+					"name": "C"	
+				}
+			],
+			"split": true 
+		},
+		"include-codeblock": {
+			"template": "ace",
+			"unindent": true,
+			"theme": "coffee"
+		}
+	}
+}

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,7 +22,6 @@ 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],

chapters/FFT/cooley_tukey.md

@@ -1,26 +1,3 @@
-<script>
-MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
-</script>
-$$ 
-\newcommand{\d}{\mathrm{d}}
-\newcommand{\bff}{\boldsymbol{f}}
-\newcommand{\bfg}{\boldsymbol{g}}
-\newcommand{\bfp}{\boldsymbol{p}}
-\newcommand{\bfq}{\boldsymbol{q}}
-\newcommand{\bfx}{\boldsymbol{x}}
-\newcommand{\bfu}{\boldsymbol{u}}
-\newcommand{\bfv}{\boldsymbol{v}}
-\newcommand{\bfA}{\boldsymbol{A}}
-\newcommand{\bfB}{\boldsymbol{B}}
-\newcommand{\bfC}{\boldsymbol{C}}
-\newcommand{\bfM}{\boldsymbol{M}}
-\newcommand{\bfJ}{\boldsymbol{J}}
-\newcommand{\bfR}{\boldsymbol{R}}
-\newcommand{\bfT}{\boldsymbol{T}}
-\newcommand{\bfomega}{\boldsymbol{\omega}}
-\newcommand{\bftau}{\boldsymbol{\tau}}
-$$
-
 ## What Makes a Fourier Transform Fast?
 
 If there were ever an algorithm to radically change the landscape of computer science and engineering by making seemingly impossible problems possible, it would be the Fast Fourier Transform (FFT). 
@@ -95,7 +72,7 @@ For some reason, though, putting code to this transformation really helped me fi
 {% sample lang="jl" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
-[import:2-11, lang:"julia"](code/julia/fft.jl)
+[import:7-19, lang:"c_cpp"](code/c/fft.c)
 {% sample lang="cpp" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="hs" %}
@@ -140,7 +117,7 @@ In the end, the code looks like:
 {% sample lang="jl" %}
 [import:14-31, lang:"julia"](code/julia/fft.jl)
 {% sample lang="c" %}
-[import:9-28, lang:"c_cpp"](code/c/fft.c)
+[import:21-40, lang:"c_cpp"](code/c/fft.c)
 {% sample lang="cpp" %}
 [import:27-57, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
@@ -261,3 +238,27 @@ Note: I implemented this in Julia because the code seems more straightforward in
 Some rather impressive scratch code was submitted by Jie and can be found here: https://scratch.mit.edu/projects/37759604/#editor
 {% endmethod %}
 
+ 
+<script>
+MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+</script>
+$$ 
+\newcommand{\d}{\mathrm{d}}
+\newcommand{\bff}{\boldsymbol{f}}
+\newcommand{\bfg}{\boldsymbol{g}}
+\newcommand{\bfp}{\boldsymbol{p}}
+\newcommand{\bfq}{\boldsymbol{q}}
+\newcommand{\bfx}{\boldsymbol{x}}
+\newcommand{\bfu}{\boldsymbol{u}}
+\newcommand{\bfv}{\boldsymbol{v}}
+\newcommand{\bfA}{\boldsymbol{A}}
+\newcommand{\bfB}{\boldsymbol{B}}
+\newcommand{\bfC}{\boldsymbol{C}}
+\newcommand{\bfM}{\boldsymbol{M}}
+\newcommand{\bfJ}{\boldsymbol{J}}
+\newcommand{\bfR}{\boldsymbol{R}}
+\newcommand{\bfT}{\boldsymbol{T}}
+\newcommand{\bfomega}{\boldsymbol{\omega}}
+\newcommand{\bftau}{\boldsymbol{\tau}}
+$$
+

chapters/QI/QI.md

@@ -0,0 +1,30 @@
+# Quantum Information
+
+Quantum information theory is... intense. 
+It requires a strong and fundamental understanding of classical information theory and quantum mechanics.
+It is not obvious in any way and deserves many textbooks on it's own.
+In fact, there are numerous textbooks on the subject already.
+The purpose of this section isn't to outdo any of that fundamental knowledge.
+Instead, we will attempt to distill the knowledge into a short, intuitive summary, with the hopes of helping people to understand more about the topic and pursue it further on their own.
+
+At the time of writing, true quantum computers do not exist.
+We do have some systems that are able to simulate qubits, they are not truly universal quantum computers.
+The closest market-ready system we currently have is D-WAVE, which boasts an impressive 128 qubits!
+
+There are many places to start an introduction to quantum information theory, so we'll go through it one step at a time:
+
+1. **Quantum bitlogic:** what is a qubit and how is it different than a classical bit?
+2. **Quantum gates and quantum circuits:** How do you fundamentally build a quantum algorithm?
+3. **Quantum computers in the wild:** Current experimental techniques to create a quantum computer and what makes them ill-suited as real quantum computers
+4. **A survey of current quantum algorithms:** There are a number of algorithms that promise fantastic advantages when performed on quantum computers and should really shake up the industry when they are finally experimentally realized.
+
+As a note, item 3 might seem out of place for a book on algorithms, and I would tend to agree; however, at this point there is a phenominal amount of research being done to realize the first truly quantum computer and there are a number of potential systems that could work for this purpose.
+These systems will change how we think about and interface with quantum computation in the future and it is important to discuss where the field might be heading and when we can expect quantum computers at home.
+
+Now, there are not too many languages that can compile quantum code.
+A while ago, we tried to make a quantum circuit compiler, which was modelled after the SPICE circuit simulator, but this was far from a computer language.
+At this point in time, it is impossible to tell what quantum computing languages will look like when we finally have a truly quantum machine, so for the time being, we will not ask for community code for the chapters related to quantum information.
+
+basically, it's hard to imagine how to would adequately implement Shor's algorithm in C.
+As always, this section will be updated as we add more algorithms to the list.
+

chapters/computational_geometry/computational_geometry.md

@@ -1,3 +1,9 @@
+# Computational Geometry
+When it comes to the different sectors of computational mathematics, there are none that bring me more joy than computational geometry.
+In some sense, it is the foundation for almost every area of automatically generated two and three dimensional graphics.
+If you have time to spend poring through some interesting research, I would definitely recommend going to the [arXiv.org section for computational geometry](https://arxiv.org/list/cs.CG/recent). 
+We will add more to this section as the Archive evolves, so let me know of any algorithms that you would like to cover in the future!
+
 <script>
 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
 </script>
@@ -20,9 +26,3 @@ $$
 \newcommand{\bfomega}{\boldsymbol{\omega}}
 \newcommand{\bftau}{\boldsymbol{\tau}}
 $$
-
-# Computational Geometry
-When it comes to the different sectors of computational mathematics, there are none that bring me more joy than computational geometry.
-In some sense, it is the foundation for almost every area of automatically generated two and three dimensional graphics.
-If you have time to spend poring through some interesting research, I would definitely recommend going to the [arXiv.org section for computational geometry](https://arxiv.org/list/cs.CG/recent). 
-We will add more to this section as the Archive evolves, so let me know of any algorithms that you would like to cover in the future!

chapters/computational_geometry/gift_wrapping/gift_wrapping.md

@@ -1,3 +1,11 @@
+# Gift Wrapping
+If given a "gift", here defined as a random distribution of points in two or three dimensions, gift-wrapping algorithms allow programmers to find its convex hull -- the smallest convex shape that holds all interior points.
+This is one of the many cases where the leap from two to three dimensions leads to an incredibly more complicated code.
+That said, there is a rich history of algorithms to solve this problem.
+
+To be fair, only the Jarvis March is classified as *the* gift wrapping algorithm; however, it's a neat name to give algorithms that solve for the convex hull of a distribution of points.
+Strictly speaking, though, the term is not entirely accurate for all convex hull methods.
+
 <script>
 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
 </script>
@@ -21,10 +29,3 @@ $$
 \newcommand{\bftau}{\boldsymbol{\tau}}
 $$
 
-# Gift Wrapping
-If given a "gift", here defined as a random distribution of points in two or three dimensions, gift-wrapping algorithms allow programmers to find its convex hull -- the smallest convex shape that holds all interior points.
-This is one of the many cases where the leap from two to three dimensions leads to an incredibly more complicated code.
-That said, there is an rich history of algorithms to solve this problem.
-
-To be fair, only the Jarvis March is classified as *the* gift wrapping algorithm; however, it's a neat name to give algorithms that solve for the convex hull of a distribution of points.
-Strictly speaking, though, the term is not entirely accurate for all convex hull methods.