Merge branch 'algorithm-archivists:master' into computus_in_javascript_typescript

Author: hugo-s29

CONTRIBUTORS.md

@@ -56,3 +56,5 @@ This file lists everyone, who contributed to this repo and wanted to show up her
 - Ishaan Verma
 - Delphi1024
 - ntindle
+- Mahdi Sarikhani
+- Ridham177

book.json

@@ -206,6 +206,10 @@
           "lang": "kotlin",
           "name": "Kotlin"
         },
+        {
+          "lang": "ts",
+          "name": "TypeScript"
+        },
         {
           "lang": "vim",
           "name": "VimL"

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="cpp" %}
+[import, lang:"cpp"](code/c++/approximate_counting.cpp)
 {% endmethod %}
 
 ### Bibliography

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

@@ -0,0 +1,71 @@
+#include <cmath>
+#include <iostream>
+#include <numeric>
+#include <random>
+
+// Returns a pseudo-random number generator
+std::default_random_engine& rng() {
+  // Initialize static pseudo-random engine with non-deterministic random seed
+  static std::default_random_engine randEngine(std::random_device{}());
+  return randEngine;
+}
+
+// Returns a random double in [0, 1)
+double drand() {
+  return std::uniform_real_distribution<double>(0.0, 1.0)(rng());
+}
+
+// This function takes
+//     - v: value in register
+//     - a: a  scaling value for the logarithm based on Morris's paper
+// It returns n(v,a), the approximate count
+auto 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
+auto increment(int v, double a) {
+  // delta is the probability of incrementing our counter
+  const auto delta = 1 / (n(v + 1, a) - n(v, a));
+  return (drand() <= delta) ? v + 1 : v;
+}
+
+// This 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
+auto approximate_count(int n_items, double a) {
+  auto v = 0;
+  for (auto 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 of items to count to
+//     - a: a scaling value for the logarithm based on Morris's paper
+//     - threshold: the maximum percent error allowed
+// It returns a "pass" / "fail" test value
+auto test_approximate_count(
+    int n_trials, int n_items, double a, double threshold) {
+  auto sum = 0.0;
+  for (auto i = 0; i < n_trials; ++i)
+    sum += approximate_count(n_items, a);
+  const auto avg = sum / n_trials;
+  return std::abs((avg - n_items) / n_items) < threshold ? "pass" : "fail";
+}
+
+int main() {
+  std::cout << "Counting Tests, 100 trials\n";
+
+  std::cout << "testing 1,000, a = 30, 1% error "
+            << test_approximate_count(100, 1000, 30, 0.1) << "\n";
+  std::cout << "testing 12,345, a = 10, 1% 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 "
+            << test_approximate_count(100, 222222, 0.5, 0.2) << "\n";
+}

contents/approximate_counting/code/julia/approximate_counting.jl

@@ -17,7 +17,7 @@ function increment(v, a)
     delta = 1/(n(v+1, a)-n(v, a))
 
     if rand() <= delta
-        return v += 1
+        return v + 1
     else
         return v
     end
@@ -47,7 +47,7 @@ function test_approximate_count(n_trials, n_items, a, threshold)
 
     avg = sum(samples)/n_trials
 
-    @test ((avg - n_items) / n_items < threshold)
+    @test (abs((avg - n_items) / n_items) < threshold)
 end
 
 @testset "Counting Tests, 100 trials" begin

contents/barnsley/barnsley.md

@@ -125,6 +125,12 @@ The biggest differences between the two code implementations is that the Barnsle
 {% method %}
 {% sample lang="jl" %}
 [import, lang:"julia"](code/julia/barnsley.jl)
+{% sample lang="cpp" %}
+[import, lang:"cpp"](code/c++/barnsley.cpp)
+{% sample lang="c" %}
+[import, lang:"c"](code/c/barnsley.c)
+{% sample lang="java" %}
+[import, lang:"java"](code/java/Barnsley.java)
 {% endmethod %}
 
 ### Bibliography

contents/barnsley/code/c++/barnsley.cpp

@@ -0,0 +1,121 @@
+// The code bellow uses C++-17 features, compile it with C++-17 flags, e.g.:
+// clang++ -Wall -Wextra -Wshadow -Wnon-virtual-dtor -Wold-style-cast -Wcast-align -Wunused -Woverloaded-virtual -Wpedantic -Wconversion -Wsign-conversion -Wnull-dereference -Wdouble-promotion -Wformat=2 -gdwarf-3 -D_GLIBCXX_DEBUG -std=c++17 -O3 -c ./barnsley.cpp barnsley
+
+#include <array>
+#include <cassert>
+#include <fstream>
+#include <random>
+
+using Vec2 = std::array<double, 2>;
+using Vec3 = std::array<double, 3>;
+using Row = std::array<double, 3>;
+using Op = std::array<Row, 3>;
+
+constexpr auto OpN = 4U;
+
+template <size_t N>
+auto operator+(std::array<double, N> x, std::array<double, N> y) {
+  for (auto i = 0U; i < N; ++i)
+    x[i] += y[i];
+  return x;
+}
+
+template <size_t N>
+auto operator*(double k, std::array<double, N> v) {
+  for (auto i = 0U; i < N; ++i)
+    v[i] *= k;
+  return v;
+}
+
+template <size_t N>
+auto operator*(std::array<double, N> v, double k) {
+  return k * v;
+}
+
+auto operator*(const Op& x, const Vec3& y) {
+  auto ret = Vec3{};
+  for (auto i = 0U; i < 3U; ++i) {
+    ret[i] = 0;
+    for (auto j = 0U; j < 3U; ++j)
+      ret[i] += y[j] * x[i][j];
+  }
+  return ret;
+}
+
+// Returns a pseudo-random number generator
+std::default_random_engine& rng() {
+  // Initialize static pseudo-random engine with non-deterministic random seed
+  static std::default_random_engine randEngine(std::random_device{}());
+  return randEngine;
+}
+
+// Returns a random double in [0, 1)
+double drand() {
+  return std::uniform_real_distribution<double>(0.0, 1.0)(rng());
+}
+
+// This is a function that reads in the Hutchinson operator and
+// corresponding
+//     probabilities and outputs a randomly selected transform
+// This works by choosing a random number and then iterating through all
+//     probabilities until it finds an appropriate bin
+auto select_array(
+    const std::array<Op, OpN>& hutchinson_op,
+    const std::array<double, OpN>& probabilities) {
+
+  // random number to be binned
+  auto rnd = drand();
+
+  // This checks to see if a random number is in a bin, if not, that
+  //     probability is subtracted from the random number and we check the
+  //     next bin in the list
+  for (auto i = 0U; i < probabilities.size(); ++i) {
+    if (rnd < probabilities[i])
+      return hutchinson_op[i];
+    rnd -= probabilities[i];
+  }
+  assert(!static_cast<bool>("check if probabilities adding up to 1"));
+}
+
+// This is a general function to simulate a chaos game
+// n is the number of iterations
+// initial_location is the the starting point of the chaos game
+// hutchinson_op is the set of functions to iterate through
+// probabilities is the set of probabilities corresponding to the likelihood
+//     of choosing their corresponding function in hutchinson_op
+auto chaos_game(
+    size_t n,
+    Vec2 initial_location,
+    const std::array<Op, OpN>& hutchinson_op,
+    const std::array<double, OpN>& probabilities) {
+
+  // Initializing the output array and the initial point
+  auto output_points = std::vector<Vec2>{};
+
+  // extending point to 3D for affine transform
+  auto point = Vec3{initial_location[0], initial_location[1], 1};
+
+  for (auto i = 0U; i < n; ++i) {
+    output_points.push_back(Vec2{point[0], point[1]});
+    point = select_array(hutchinson_op, probabilities) * point;
+  }
+
+  return output_points;
+}
+
+int main() {
+
+  const std::array barnsley_hutchinson = {
+      Op{Row{0.0, 0.0, 0.0}, Row{0.0, 0.16, 0.0}, Row{0.0, 0.0, 1.0}},
+      Op{Row{0.85, 0.04, 0.0}, Row{-0.04, 0.85, 1.60}, Row{0.0, 0.0, 1.0}},
+      Op{Row{0.20, -0.26, 0.0}, Row{0.23, 0.22, 1.60}, Row{0.0, 0.0, 1.0}},
+      Op{Row{-0.15, 0.28, 0.0}, Row{0.26, 0.24, 0.44}, Row{0.0, 0.0, 1.0}}};
+
+  const std::array barnsley_probabilities = {0.01, 0.85, 0.07, 0.07};
+  auto output_points = chaos_game(
+      10'000, Vec2{0, 0}, barnsley_hutchinson, barnsley_probabilities);
+
+  std::ofstream ofs("out.dat");
+  for (auto pt : output_points)
+    ofs << pt[0] << '\t' << pt[1] << '\n';
+}

contents/barnsley/code/c/barnsley.c

@@ -0,0 +1,108 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct matrix {
+    double xx, xy, xz,
+           yx, yy, yz,
+           zx, zy, zz;
+};
+
+struct point2d {
+    double x, y;
+};
+
+struct point3d {
+    double x, y, z;
+};
+
+struct point3d matmul(struct matrix mat, struct point3d point)
+{
+    struct point3d out = {
+        mat.xx * point.x + mat.xy * point.y + mat.xz * point.z,
+        mat.yx * point.x + mat.yy * point.y + mat.yz * point.z,
+        mat.zx * point.x + mat.zy * point.y + mat.zz * point.z
+    };
+    return out;
+}
+
+// This function reads in the Hutchinson operator and corresponding
+// probabilities and returns a randomly selected transform
+// This works by choosing a random number and then iterating through all
+// probabilities until it finds an appropriate bin
+struct matrix select_array(struct matrix *hutchinson_op, double *probabilities,
+                           size_t num_op)
+{
+    // random number to be binned
+    double rnd = (double)rand() / RAND_MAX;
+
+    // This checks to see if a random number is in a bin, if not, that
+    // probability is subtracted from the random number and we check the next
+    // bin in the list
+    for (size_t i = 0; i < num_op; ++i) {
+        if (rnd < probabilities[i]) {
+            return hutchinson_op[i];
+        }
+        rnd -= probabilities[i];
+    }
+}
+
+// This is a general function to simulate a chaos game
+//  - output_points: pointer to an initialized output array
+//  - num: the number of iterations
+//  - initial_point: the starting point of the chaos game
+//  - hutchinson_op: the set of functions to iterate through
+//  - probabilities: the set of probabilities corresponding to the likelihood
+//      of choosing their corresponding function in hutchingson_op
+//  - nop: the number of functions in hutchinson_op
+void chaos_game(struct point2d *output_points, size_t num,
+                struct point2d initial_point, struct matrix *hutchinson_op,
+                double *probabilities, size_t nop)
+{
+    // extending point to 3D for affine transform
+    struct point3d point = {initial_point.x, initial_point.y, 1.0};
+
+    for (size_t i = 0; i < num; ++i) {
+        point = matmul(select_array(hutchinson_op, probabilities, nop), point);
+        output_points[i].x = point.x;
+        output_points[i].y = point.y;
+    }
+}
+
+int main()
+{
+    struct matrix barnsley_hutchinson[4] = {
+        {
+            0.0, 0.0, 0.0,
+            0.0, 0.16, 0.0,
+            0.0, 0.0, 1.0
+        },
+        {
+            0.85, 0.04, 0.0,
+            -0.04, 0.85, 1.60,
+            0.0, 0.0, 1.0
+        },
+        {
+            0.2, -0.26, 0.0,
+            0.23, 0.22, 1.60,
+            0.0, 0.0, 1.0
+        },
+        {
+            -0.15, 0.28, 0.0,
+            0.26, 0.24, 0.44,
+            0.0, 0.0, 1.0
+        }
+    };
+
+    double barnsley_probabilities[4] = {0.01, 0.85, 0.07, 0.07};
+    struct point2d output_points[10000];
+    struct point2d initial_point = {0.0, 0.0};
+    chaos_game(output_points, 10000, initial_point, barnsley_hutchinson,
+               barnsley_probabilities, 4);
+    FILE *f = fopen("barnsley.dat", "w");
+    for (size_t i = 0; i < 10000; ++i) {
+        fprintf(f, "%f\t%f\n", output_points[i].x, output_points[i].y);
+    }
+    fclose(f);
+
+    return 0;
+}