removing principles of code chapter.

Author: leios

SUMMARY.md

@@ -1,33 +1,21 @@
 # Summary
 
 * [Algorithm Archive](README.md)
-* [TODO](TODO.md)
 * [Introduction](chapters/introduction/introduction.md)
-* [A Personal Note](chapters/introduction/my_introduction_to_hobby_programming.md)
 * [How To Contribute](chapters/introduction/how_to_contribute.md)
-* [Principles of Code](chapters/principles_of_code/principles_of_code.md)
-    * [Choosing A Language](chapters/principles_of_code/choosing_a_language/choosing_a_language.md)
-        * [Compiled Languages](chapters/principles_of_code/choosing_a_language/compiled/compiled.md)
-            * [Makefiles](chapters/principles_of_code/choosing_a_language/compiled/makefiles.md)
-            * [FORTRAN](chapters/principles_of_code/choosing_a_language/compiled/FORTRAN.md)
-    * [Building Blocks](chapters/principles_of_code/building_blocks/building_blocks.md)
-        * [Variables and Types](chapters/principles_of_code/building_blocks/variables.md)
-        * [Conditions](chapters/principles_of_code/building_blocks/conditions.md)
-        * [Loops](chapters/principles_of_code/building_blocks/loops.md)
-        * [Functions](chapters/principles_of_code/building_blocks/functions.md)
-        * [Classes](chapters/principles_of_code/building_blocks/classes.md)
-        * [Stacks and Queues](chapters/principles_of_code/building_blocks/stacks.md)
-        * [Bit Logic](chapters/principles_of_code/building_blocks/bitlogic.md)
-    * [Version Control](chapters/principles_of_code/version_control.md)
-    * [Complexity Notation](chapters/principles_of_code/notation/notation.md)
-* [Convolutions](chapters/algorithms/convolutions/convolutions.md)
-* [Taylor Series](chapters/general/taylor_series_expansion/taylor_series_expansion.md)
+* [Version Control](chapters/introduction/version_control.md)
+* [Data Structures](chapters/data_structures/data_structures.md)
+    * [Stacks and Queues](chapters/data_structures/stacks_and_queues/stacks_and_queues.md)
+* [Mathematical Background](chapters/mathematical_background/mathematical_background.md)
+    * [Complexity Notation](chapters/mathematical_background/notation/notation.md)
+    * [Bit Logic](chapters/mathematical_background/bitlogic/bitlogic.md)
+    * [Convolutions](chapters/mathematical_background/convolutions/convolutions.md)
+    * [Taylor Series](chapters/mathematical_background/taylor_series/taylor_series.md)
 * [Sorting and Searching](chapters/general/sorting_and_searching/sorting_and_searching.md)
     * [Bubble Sort](chapters/algorithms/bubble_sort/bubble_sort.md)
     * [Bogo Sort](chapters/algorithms/bogo_sort/bogo_sort.md)
 * [Tree Traversal](chapters/algorithms/tree_traversal/tree_traversal.md)
 * [Euclidean Algorithm](chapters/algorithms/euclidean_algorithm/euclidean_algorithm.md)
-* [Multiplication](chapters/general/multiplication/multiplication.md)
 * [Monte Carlo](chapters/algorithms/monte_carlo_integration/monte_carlo_integration.md)
 * [Matrix Methods](chapters/general/matrix_methods/matrix_methods.md)
     * [Gaussian Elimination](chapters/algorithms/gaussian_elimination/gaussian_elimination.md)
@@ -45,7 +33,6 @@
     * [Backward Euler Methods](chapters/algorithms/backward_euler_method/backward_euler_method.md)
 * [Physics Solvers](chapters/general/physics_solvers/physics_solvers.md)
     * [Verlet Integration](chapters/algorithms/verlet_integration/verlet_integration.md)
-    * [Barnes-Hut](chapters/algorithms/barnes_hut_algorithm/barnes_hut_algorithm.md)
     * [Quantum Systems](chapters/general/quantum_systems/quantum_systems.md)
         * [Split-Operator Method](chapters/algorithms/split-operator_method/split-operator_method.md)
 * [Data Compression](chapters/general/data_compression/data_compression.md)

TODO.md

@@ -0,0 +1,4 @@
+# Data Structures
+
+This is a book about algorithms.
+The fundamental building blocks of algorithms are data structures, and thus as more algorithms are added to the Archive, more data structures will be added to this section.

chapters/data_structures/data_structures.md

@@ -2,7 +2,7 @@
 
 The *Algorithm Archive* is an effort to learn about and teach algorithms as a community.
 As such, it requires a certain level of trust between community members.
-For the most part, the collaboration can be done via GitHub and gitbook, so it is important to understand the basics of [version control](../principles_of_code/version_control.md).
+For the most part, the collaboration can be done via GitHub and gitbook, so it is important to understand the basics of [version control](version_control.md).
 Ideally, all code provided by the community will be submitted via pull requests and discussed accordingly; however, I understand that many individuals are new to collaborative projects, so I will allow submissions by other means (comments, tweets, etc...).
 As this project grows in size, it will be harder and harder to facilitate these submissions.
 In addition, by submitting in any way other than pull requests, I cannot guarantee I will be able to list you as a collaborator (though I will certainly do my best to update the `CONTRIBUTORS.md` file accordingly).

chapters/principles_of_code/building_blocks/stacks.md renamed to chapters/data_structures/stacks_and_queues/stacks_and_queues.md

@@ -1,10 +1,10 @@
-### Bit Logic
+# Bit Logic
 
 We write code in a language that makes a little sense to us, but does not make sense at all to our computer without a compiler to transform the code we write into a language the computer can understand.
 In the end, whenever we write code, all of the data structures we write are transformed into binary strings of 1's and 0's to be interpreted by our computer.
 That said, it's not always obvious how this happens, so let's start the simple case of integer numbers.
 
-#### Integers
+## Integers
 For integer numbers, 0 is still 0 and 1 is still 1; however, for 2, we need to use 2 digits because binary only has 0's and 1's. When we get to 4, we'll need 3 digits and when we get to 8, we'll need 4. Ever time we cross a power of 2, we'll need to add a new digit. Here's a table of the first 10 integers in binary:
 
 | Integer Number | Binary Number |
@@ -45,7 +45,7 @@ Another method is to "roll over" to negative numbers when the bit count gets too
 
 Ultimately, integer numbers are not that difficult to deal with in binary, so let's move onto something more complicated: *floating-point numbers!*
 
-#### Floating-point Numbers
+## Floating-point Numbers
 Floats are numbers with a decimal point.
 9.125 is a float. 9.000 is a float. 9 is an integer.
 Here are a few floats and their integer representations:

chapters/introduction/how_to_contribute.md

@@ -0,0 +1,130 @@
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <complex>
+#include <cstdint>
+#include <iterator>
+#include <vector>
+
+// These headers are for presentation not for the algorithm.
+#include <iomanip>
+#include <iostream>
+#include <random>
+
+using std::begin;
+using std::end;
+using std::swap;
+
+using std::ptrdiff_t;
+using std::size_t;
+
+using c64 = std::complex<double>;
+template <typename T>
+constexpr T pi() {
+  return 3.14159265358979323846264338327950288419716;
+}
+
+// This section is not a part of the algorithm
+template <typename Iter>
+void fft(Iter const first, Iter const last) {
+  auto const size = last - first;
+  if (size >= 2) {
+    auto temp = std::vector<c64>(size / 2);
+    for (ptrdiff_t i = 0; i < size / 2; ++i) {
+      temp[i] = first[i * 2 + 1];
+      first[i] = first[i * 2];
+    }
+    for (ptrdiff_t i = 0; i < size / 2; ++i) {
+      first[i + size / 2] = temp[i];
+    }
+
+    auto const split = first + size / 2;
+    fft(first, split);
+    fft(split, last);
+
+    for (ptrdiff_t k = 0; k < size / 2; ++k) {
+      auto w = std::exp(c64(0, -2.0 * pi<double>() * k / size));
+
+      auto& bottom = first[k];
+      auto& top = first[k + size / 2];
+      top = bottom - w * top;
+      bottom -= top - bottom;
+    }
+  }
+}
+
+template <typename Iter>
+void inverse_fft(Iter const first, Iter const last) {
+  std::for_each(first, last, [](auto& it) { it = std::conj(it); });
+
+  fft(first, last);
+
+  auto const size = static_cast<c64>(last - first);
+  std::for_each(first, last, [&](auto& it) { it = std::conj(it) / size; });
+}
+
+// This section is a part of the algorithm
+
+template <typename S1, typename S2, typename Out>
+void conv(
+    S1 const s1,
+    S1 const s1_last,
+    S2 const s2,
+    S2 const s2_last,
+    Out const out) {
+  auto const size1 = s1_last - s1;
+  auto const size2 = s2_last - s2;
+  auto const size = size1 + size2;
+
+  for (ptrdiff_t i = 0; i < size; ++i) {
+    c64 sum = 0;
+    for (ptrdiff_t j = 0; j < i; ++j) {
+      if (j < size1) {
+        sum += s1[j] * s2[i - j];
+      }
+    }
+    out[i] = sum;
+  }
+}
+
+template <typename S1, typename S2, typename Out>
+void conv_fft(S1 const s1, S1 const s1_last, S2 const s2, Out const out) {
+  auto const size = s1_last - s1;
+
+  fft(s1, s1_last);
+  fft(s2, s2 + size);
+
+  auto s1_it = s1;
+  auto s2_it = s2;
+  auto out_it = out;
+  for (; s1_it != s1_last; ++s1_it, ++s2_it, ++out_it) {
+    *out_it = *s1_it * *s2_it;
+  }
+
+  inverse_fft(out, out_it);
+}
+
+int main() {
+  auto signal1 = std::array<c64, 64>();
+  std::fill(begin(signal1) + 16, begin(signal1) + 48, 1);
+
+  auto signal2 = signal1;
+
+  auto out1 = std::array<c64, 128>();
+  conv(begin(signal1), end(signal1), begin(signal2), end(signal2), begin(out1));
+
+  auto signal3 = std::array<c64, 128>();
+  std::copy(begin(signal1), end(signal1), begin(signal3));
+  auto signal4 = signal3;
+
+  auto out2 = std::array<c64, 128>();
+  conv_fft(begin(signal3), end(signal3), begin(signal4), begin(out2));
+
+  std::cout << std::right << std::setw(16) << "i" << std::setw(16)
+            << "subtracted" << '\n';
+
+  for (size_t i = 0; i < signal1.size(); ++i) {
+    std::cout << std::setw(16) << i << std::setw(16)
+              << (std::abs(out1[i]) - std::abs(out2[i])) << '\n';
+  }
+}

chapters/principles_of_code/res/clone.png renamed to chapters/introduction/res/clone.png

@@ -0,0 +1,68 @@
+#include "fft.h"
+
+#include <stdio.h>
+
+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) {
+                sum += signal1[j] * signal2[i-j];
+            }
+        }
+        out[i] = sum;
+        sum = 0;
+    }
+}
+
+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];
+    }
+
+    ifft(out, n);
+}
+
+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) {
+            signal1[i] = 1.0;
+            signal2[i] = 1.0;
+            signal3[i] = 1.0;
+            signal4[i] = 1.0;
+            out1[i] = 0.0;
+            out2[i] = 0.0;
+        } else if (i >= 64) {
+            signal3[i] = 0.0;
+            signal4[i] = 0.0;
+            out1[i] = 0.0;
+            out2[i] = 0.0;
+        } else {
+            signal1[i] = 0.0;
+            signal2[i] = 0.0;
+            signal3[i] = 0.0;
+            signal4[i] = 0.0;
+            out1[i] = 0.0;
+            out2[i] = 0.0;
+        }
+    }
+
+    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]));
+    }
+
+    return 0;
+}

chapters/principles_of_code/res/fork.png renamed to chapters/introduction/res/fork.png

@@ -0,0 +1,41 @@
+#ifndef FFT_H
+#define FFT_H
+
+#include <complex.h>
+#include <math.h>
+
+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];
+        }
+
+        fft(X, N / 2);
+        fft(X + N / 2, N / 2);
+
+        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) {
+        x[i] = conj(x[i]);
+    }
+
+    fft(x, n);
+
+    for (size_t i = 0; i < n; ++i) {
+        x[i] = conj(x[i]) / n;
+    }
+}
+
+#endif //FFT_H

chapters/principles_of_code/version_control.md renamed to chapters/introduction/version_control.md

@@ -0,0 +1,5 @@
+import Data.List (tails)
+
+convolution :: (Num a) => [a] -> [a] -> [a]
+convolution x = map (sum . zipWith (*) (reverse x)) . spread
+  where spread = init . tails . (replicate (length x - 1) 0 ++)

chapters/principles_of_code/choosing_a_language/choosing_a_language.md renamed to chapters/languages/choosing_a_language.md

@@ -0,0 +1,22 @@
+function conv(signal1::Vector{Complex}, signal2::Vector{Complex})
+    n = length(signal1) + length(signal2)
+    out = Vector{Complex}(n)
+    sum = 0
+
+    for i = 0:n
+        for j = 0:i
+            if(j < length(signal1))
+                sum += signal1[j] * signal2[i-j]
+            end
+        end
+        out[i] = sum
+        sum = 0
+    end
+
+    return out
+end
+
+function conv_fft(signal1::Vector{Complex}, signal2::Vector{Complex})
+    return ifft(fft(signal1).*fft(signal2))
+end
+