Merge master

Author: stormofice

.devcontainer/Dockerfile

@@ -6,7 +6,7 @@ FROM mcr.microsoft.com/vscode/devcontainers/base:0-${VARIANT}
 
 # [Optional] Uncomment this section to install additional OS packages.
 RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-    && apt-get -y install --no-install-recommends build-essential software-properties-common xz-utils g++ sbcl julia python3 python3-pip python3-dev ghc openjdk-11-jdk rustc libssl-dev gfortran libxml2-dev libyaml-dev libgmp-dev libz-dev libncurses5 gnuplot nodejs npm lua5.3 ocaml php ruby-full gnu-smalltalk scratch
+    && apt-get -y install --no-install-recommends build-essential software-properties-common xz-utils g++ sbcl julia python3 python3-pip python3-dev ghc openjdk-11-jdk rustc libssl-dev gfortran libxml2-dev libyaml-dev libgmp-dev libz-dev libncurses5 gnuplot nodejs npm lua5.3 ocaml php ruby-full gnu-smalltalk scratch libfftw3-dev
 
 # Setup Crystal
 RUN echo 'deb http://download.opensuse.org/repositories/devel:/languages:/crystal/xUbuntu_20.04/ /' | sudo tee /etc/apt/sources.list.d/devel:languages:crystal.list
@@ -31,11 +31,10 @@ RUN sudo sh -c 'sudo dpkg -i packages-microsoft-prod.deb'
 RUN sudo sh -c 'rm packages-microsoft-prod.deb'
 
 # Setup D Lang
-RUN sudo sh -c 'mkdir -p ~/dlang && wget https://dlang.org/install.sh -O ~/dlang/install.sh'
-RUN sudo sh -c 'bash ~/dlang/install.sh'
-## From Docs not needed though
-# RUN sudo sh -c 'source ~/dlang/dmd-2.097.2/activate'
-ENV PATH=$PATH:/root/dlang/dmd-2.097.2/linux/bin64
+ENV DLANG_VERSION=2.097.2
+RUN mkdir -p ~/dlang && wget https://dlang.org/install.sh -O ~/dlang/install.sh
+RUN bash ~/dlang/install.sh dmd-$DLANG_VERSION
+ENV PATH=$PATH:~/dlang/dmd-$DLANG_VERSION/linux/bin64/
 
 # Setup Go
 RUN sudo sh -c 'wget -c https://dl.google.com/go/go1.14.2.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local'
@@ -56,36 +55,35 @@ ENV PATH=$PATH:/usr/local/kotlinc/bin
 # Setup Matlab
 # ?????? This is a licensed language???
 
-# Setup Emojicode (in progress)
-RUN sudo sh -c 'wget -c https://github.com/emojicode/emojicode/releases/download/v1.0-beta.2/Emojicode-1.0-beta.2-Linux-x86_64.tar.gz -O /usr/local/Emojicode-1.0-beta.2-Linux-x86_64.tar.gz'
-RUN sudo tar -xvzf /usr/local/Emojicode-1.0-beta.2-Linux-x86_64.tar.gz
-# && cd ~/emojicode/ && echo && ./install.sh'
-ENV PATH=$PATH:/usr/local/Emojicode-1.0-beta.2-Linux-x86_64
+# Setup Emojicode
+RUN mkdir -p ~/emojicode && wget -c https://github.com/emojicode/emojicode/releases/download/v1.0-beta.2/Emojicode-1.0-beta.2-Linux-x86_64.tar.gz -O ~/emojicode/emojicode.tar.gz && \
+    tar -xzf ~/emojicode/emojicode.tar.gz -C ~/emojicode --strip-components=1
+ENV PATH=$PATH:~/emojicode
 
-# Setup Factor (in progress)
-RUN mkdir -p ~/factor && wget https://downloads.factorcode.org/releases/0.98/factor-linux-x86-64-0.98.tar.gz -O ~/factor/factor.tar.gz
-RUN tar -xzf /root/factor/factor.tar.gz
-# && rm ~/factor/factor.tar.gz
-ENV PATH=$PATH:/root/factor/factor
+# Setup Factor
+RUN mkdir -p ~/factor && wget https://downloads.factorcode.org/releases/0.98/factor-linux-x86-64-0.98.tar.gz -O ~/factor/factor.tar.gz && tar -xzf ~/factor/factor.tar.gz -C ~/factor --strip-components=1
+ENV PATH=$PATH:~/factor/factor
 
 # Setup R
 RUN sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9
 RUN sudo add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu focal-cran40/'
 
-# Setup Racket
-## Use: https://ubunlog.com/en/racket-install-ubuntu-programming-language
-
-# Setup Scheme
-## Use: https://github.com/ashinn/chibi-scheme
+# Setup Racket and Scheme
+# To run scheme files, use `racket -f <file.ss>`
+RUN sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys D9D33FCD84D82C17288BA03B3C9A6980F827E01E
+RUN sudo add-apt-repository 'deb http://ppa.launchpad.net/plt/racket/ubuntu focal main'
 
 # Setup Scratch
 ## using 1.x right now.... in future checkout snap or adobe air?
 
 # Setup Swift
-## ?
+RUN mkdir -p ~/swift && wget https://swift.org/builds/swift-5.5-release/ubuntu2004/swift-5.5-RELEASE/swift-5.5-RELEASE-ubuntu20.04.tar.gz -O ~/swift/swift.tar.gz && \
+    tar -xzf ~/swift/swift.tar.gz -C ~/swift --strip-components=1
+ENV PATH=$PATH:~/swift/usr/bin
 
 # Setup viml
-## ?
+# To run vim script commands use `/usr/bin/vim -c ":source %" <path_to_file>`
+RUN export DEBIAN_FRONTEND=noninteractive && apt-get -y install --no-install-recommends vim
 
 # Setup whitespace
 ## ?
@@ -94,13 +92,15 @@ RUN sudo add-apt-repository 'deb https://cloud.r-project.org/bin/linux/ubuntu fo
 ## https://github.com/elm/compiler/blob/master/installers/linux/README.md
 
 # Setup V
-## https://github.com/vlang/v/blob/master/doc/docs.md
-
+RUN mkdir -p ~/vlang && wget https://github.com/vlang/v/releases/download/weekly.2021.44/v_linux.zip -O ~/vlang/vlang.zip && \
+    unzip ~/vlang/vlang.zip -d ~/vlang 
+ENV PATH=$PATH:~/vlang/v
 
 # Install the packages that needed extra help
 RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-    && apt-get -y install --no-install-recommends crystal dart nim powershell scala dotnet-sdk-5.0 r-base
+    && apt-get -y install --no-install-recommends crystal dart nim powershell scala dotnet-sdk-5.0 r-base racket
 
-RUN pip install wheel matplotlib numpy coconut
+RUN pip install wheel matplotlib numpy coconut scons
 
 RUN sudo sh -c 'npm install -g typescript'
+

.gitignore

@@ -517,3 +517,10 @@ vscode/
 
 # aspell
 *.bak
+
+# SCons intermidiate files
+.sconsign.dblite
+*.o
+
+# SCons build directory
+build/

CONTRIBUTORS.md

@@ -51,11 +51,13 @@ This file lists everyone, who contributed to this repo and wanted to show up her
 - Vincent Zalzal
 - Jonathan D B Van Schenck
 - James Goytia
-- Amaras
+- Sammy Plat 
 - Jonathan Dönszelmann
 - Ishaan Verma
 - Delphi1024
 - ntindle
 - Mahdi Sarikhani
 - Ridham177
 - Hugo Salou
+- Dimitri Belopopsky
++ Henrik Abel Christensen

SConscript

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+Import('*')
+
+for p in Path('contents').iterdir():
+    if (q := (p / 'code')).exists():
+        for path in q.iterdir():
+            if path.stem in languages:
+                env.SConscript(path / 'SConscript', exports='env',
+                               must_exist=0)

SConstruct

@@ -0,0 +1,20 @@
+"""
+SCons top-level build description (SConstruct) for the Arcane Algorithm Achive
+
+This provides Builder objects for each of the language implementations in the AAA; however, this work cannot be considered exhaustive until every language has been covered.
+
+Currently, the aim is to provide a way to compile or copy the implementation files to the build directory, as well as to provide ways to run them and capture their output.
+
+To run the compilation for all implmeentations in one language, e.g. Rust, run the command `scons build/c`, and the resulting executables will be available in the `cuild/c` directory, each in their respective algorithm directory, containing the executable."""
+
+from pathlib import Path
+
+env = Environment()
+
+# Add other languages here when you want to add language targets
+languages = ['c']
+
+env.C = env.Program
+
+SConscript('SConscript', exports='env languages')
+

contents/IFS/code/c/SConscript

@@ -0,0 +1,6 @@
+Import('*')
+from pathlib import Path
+
+dirname = Path.cwd().parents[1].stem
+
+env.C(f'#/build/c/{dirname}', Glob('*.c'))

contents/approximate_counting/approximate_counting.md

@@ -360,6 +360,8 @@ As we do not have any objects to count, we will instead simulate the counting wi
 {% method %}
 {% sample lang="jl" %}
 [import, lang:"julia"](code/julia/approximate_counting.jl)
+{% sample lang="c" %}
+[import, lang:"c"](code/c/approximate_counting.c)
 {% sample lang="cpp" %}
 [import, lang:"cpp"](code/c++/approximate_counting.cpp)
 {% sample lang="python" %}

contents/approximate_counting/code/c++/approximate_counting.cpp

@@ -61,11 +61,11 @@ auto test_approximate_count(
 int main() {
   std::cout << "Counting Tests, 100 trials\n";
 
-  std::cout << "testing 1,000, a = 30, 1% error "
+  std::cout << "testing 1,000, a = 30, 10% error "
             << test_approximate_count(100, 1000, 30, 0.1) << "\n";
-  std::cout << "testing 12,345, a = 10, 1% error "
+  std::cout << "testing 12,345, a = 10, 10% error "
             << test_approximate_count(100, 12345, 10, 0.1) << "\n";
   // Note : with a lower a, we need more trials, so a higher % error here.
-  std::cout << "testing 222,222, a = 0.5, 10% error "
+  std::cout << "testing 222,222, a = 0.5, 20% error "
             << test_approximate_count(100, 222222, 0.5, 0.2) << "\n";
 }

contents/approximate_counting/code/c/SConscript

@@ -0,0 +1,6 @@
+Import('*')
+from pathlib import Path
+
+dirname = Path.cwd().parents[1].stem
+
+env.C(f'#/build/c/{dirname}', Glob('*.c'), LIBS='m')

contents/approximate_counting/code/c/approximate_counting.c

@@ -0,0 +1,82 @@
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+// This function returns a pseudo-random number between 0 and 1
+double drand()
+{
+    return (double)rand() / RAND_MAX;
+}
+
+// This function takes
+//  - v: value in register
+//  - a: a scaling value for the logarithm based on Morris's paper
+// It returns the approximate count
+double n(double v, double a)
+{
+    return a * (pow(1 + 1 / a, v) - 1);
+}
+
+// This function takes
+//  - v: value in register
+//  - a: a scaling value for the logarithm based on Morris's paper
+// It returns a new value for v
+double increment(double v, double a)
+{
+    // delta is the probability of incrementing our counter
+    double delta = 1 / (n(v + 1, a) - n(v, a));
+
+    if (drand() <= delta) {
+        return v + 1;
+    }
+    return v;
+}
+
+// This function simulates counting and takes
+//  - n_items: number of items to count and loop over
+//  - a: a scaling value for the logarithm based on Morris's paper
+// It returns n(v, a), the approximate count
+double approximate_count(size_t n_items, double a)
+{
+    int v = 0;
+    for (size_t i = 0; i < n_items; ++i) {
+        v = increment(v, a);
+    }
+
+    return n(v, a);
+}
+
+// This function takes
+//  - n_trials: the number of counting trials
+//  - n_items: the number off items to count
+//  - a: a scaling value for the logarithm based on Morris's paper
+//  - threshold: the maximum percent error allowed
+// It terminates the program on failure
+void test_approximation_count(size_t n_trials, size_t n_items, double a,
+                              double threshold)
+{
+    double sum = 0.0;
+    for (size_t i = 0; i < n_trials; ++i) {
+        sum += approximate_count(n_items, a);
+    }
+    double avg = sum / n_trials;
+
+    assert(fabs((avg - n_items) / n_items) < threshold);
+}
+
+int main()
+{
+    srand(time(NULL));
+
+    printf("Counting Tests, 100 trials\n");
+    printf("testing 1000, a = 30, 10%% error\n");
+    test_approximation_count(100, 1000, 30, 0.1);
+    printf("testing 12345, a = 10, 10%% error\n");
+    test_approximation_count(100, 12345, 10, 0.1);
+    printf("testing 222222, a = 0.5, 20%% error\n");
+    test_approximation_count(100, 222222, 0.5, 0.2);
+
+    return 0;
+}

contents/approximate_counting/code/julia/approximate_counting.jl

@@ -51,11 +51,11 @@ function test_approximate_count(n_trials, n_items, a, threshold)
 end
 
 @testset "Counting Tests, 100 trials" begin
-    println("testing 1,000, a = 30, 1% error")
+    println("testing 1,000, a = 30, 10% error")
         test_approximate_count(100, 1000, 30, 0.1)
-    println("testing 12,345, a = 10, 1% error")
+    println("testing 12,345, a = 10, 10% error")
         test_approximate_count(100, 12345, 10, 0.1)
     # Note: with a lower a, we need more trials, so a higher % error here.
-    println("testing 222,222, a = 0.5, 10% error")
+    println("testing 222,222, a = 0.5, 20% error")
         test_approximate_count(100, 222222, 0.5, 0.2)
 end

contents/approximate_counting/code/python/approximate_counting.py

@@ -41,9 +41,9 @@ def test_approximate_count(n_trials, n_items, a, threshold):
     if abs((avg - n_items)/n_items) < threshold:
         print("passed")
 
-print("testing 1,000, a = 30, 1% error")
+print("testing 1,000, a = 30, 10% error")
 test_approximate_count(100, 1000, 30, 0.1)
-print("testing 12,345, a = 10, 1% error")
+print("testing 12,345, a = 10, 10% error")
 test_approximate_count(100, 12345, 10, 0.1)
-print("testing 222,222, a = 0.5, 10% error")
+print("testing 222,222, a = 0.5, 20% error")
 test_approximate_count(100, 222222, 0.5, 0.2)

contents/barnsley/code/c/SConscript

@@ -0,0 +1,6 @@
+Import('*')
+from pathlib import Path
+
+dirname = Path.cwd().parents[1].stem
+
+env.C(f'#/build/c/{dirname}', Glob('*.c'))

contents/computus/code/c/SConscript

@@ -0,0 +1,6 @@
+Import('*')
+from pathlib import Path
+
+dirname = Path.cwd().parents[1].stem
+
+env.C(f'#/build/c/{dirname}', Glob('*.c'))

contents/convolutions/1d/1d.md

@@ -56,6 +56,8 @@ With this in mind, we can almost directly transcribe the discrete equation into
 [import:27-46, lang:"julia"](code/julia/1d_convolution.jl)
 {% sample lang="cs" %}
 [import:63-84, lang:"csharp"](code/csharp/1DConvolution.cs)
+{% sample lang="py" %}
+[import:20-31, lang:"python"](code/python/1d_convolution.py)
 {% endmethod %}
 
 The easiest way to reason about this code is to read it as you might read a textbook.
@@ -189,6 +191,8 @@ Here it is again for clarity:
 [import:27-46, lang:"julia"](code/julia/1d_convolution.jl)
 {% sample lang="cs" %}
 [import:63-84, lang:"csharp"](code/csharp/1DConvolution.cs)
+{% sample lang="py" %}
+[import:20-31, lang:"python"](code/python/1d_convolution.py)
 {% endmethod %}
 
 Here, the main difference between the bounded and unbounded versions is that the output array size is smaller in the bounded case.
@@ -199,6 +203,8 @@ For an unbounded convolution, the function would be called with a the output arr
 [import:58-59, lang:"julia"](code/julia/1d_convolution.jl)
 {% sample lang="cs" %}
 [import:96-97, lang:"csharp"](code/csharp/1DConvolution.cs)
+{% sample lang="py" %}
+[import:41-42, lang:"python"](code/python/1d_convolution.py)
 {% endmethod %}
 
 On the other hand, the bounded call would set the output array size to simply be the length of the signal
@@ -208,6 +214,8 @@ On the other hand, the bounded call would set the output array size to simply be
 [import:61-62, lang:"julia"](code/julia/1d_convolution.jl)
 {% sample lang="cs" %}
 [import:98-99, lang:"csharp"](code/csharp/1DConvolution.cs)
+{% sample lang="py" %}
+[import:44-45, lang:"python"](code/python/1d_convolution.py)
 {% endmethod %}
 
 Finally, as we mentioned before, it is possible to center bounded convolutions by changing the location where we calculate the each point along the filter.
@@ -218,6 +226,8 @@ This can be done by modifying the following line:
 [import:35-35, lang:"julia"](code/julia/1d_convolution.jl)
 {% sample lang="cs" %}
 [import:71-71, lang:"csharp"](code/csharp/1DConvolution.cs)
+{% sample lang="py" %}
+[import:25-25, lang:"python"](code/python/1d_convolution.py)
 {% endmethod %}
 
 Here, `j` counts from `i-length(filter)` to `i`.
@@ -252,6 +262,8 @@ In code, this typically amounts to using some form of modulus operation, as show
 [import:4-25, lang:"julia"](code/julia/1d_convolution.jl)
 {% sample lang="cs" %}
 [import:38-61, lang:"csharp"](code/csharp/1DConvolution.cs)
+{% sample lang="py" %}
+[import:5-17, lang:"python"](code/python/1d_convolution.py)
 {% endmethod %}
 
 This is essentially the same as before, except for the modulus operations, which allow us to work on a periodic domain.
@@ -269,6 +281,8 @@ For the code associated with this chapter, we have used the convolution to gener
 [import, lang:"julia"](code/julia/1d_convolution.jl)
 {% sample lang="cs" %}
 [import, lang:"csharp"](code/csharp/1DConvolution.cs)
+{% sample lang="py" %}
+[import, lang:"python"](code/python/1d_convolution.py)
 {% endmethod %}
 
 At a test case, we have chosen to use two sawtooth functions, which should produce the following images: