Merge branch 'master' into missingexamples

Author: Gathros

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/computational_geometry/gift_wrapping/graham_scan/code/c/graham.c

@@ -0,0 +1,114 @@
+#include <math.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct point {
+    double x, y;
+};
+
+int cmp_points(const void *a, const void *b) {
+    struct point* pa = (struct point*) a;
+    struct point* pb = (struct point*) b;
+
+    if (pa->y > pb->y) {
+        return 1;
+    } else if (pa->y < pb->y) {
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+double ccw(struct point a, struct point b, struct point c) {
+    return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}
+
+double polar_angle(struct point origin, struct point p) {
+    return atan2(p.y - origin.y, p.x - origin.x);
+}
+
+void polar_angles_sort(struct point *points, struct point origin, size_t size) {
+    if (size < 2) {
+        return;
+    }
+
+    double pivot_angle = polar_angle(origin, points[size / 2]);
+
+    int i = 0;
+    int j = size - 1;
+    while (1) {
+        while (polar_angle(origin, points[i]) < pivot_angle) {
+            i++;
+        }
+        while (polar_angle(origin, points[j]) > pivot_angle) {
+            j--;
+        }
+
+        if (i >= j) {
+            break;
+        }
+
+        struct point tmp = points[i];
+        points[i] = points[j];
+        points[j] = tmp;
+
+        i++;
+        j--;
+    }
+
+    polar_angles_sort(points, origin, i);
+    polar_angles_sort(points + i, origin, size - i);
+}
+
+size_t graham_scan(struct point *points, size_t size) {
+    qsort(points, size, sizeof(struct point), cmp_points);
+    polar_angles_sort(points, points[0], size);
+
+    struct point tmp_points[size + 1];
+    memcpy(tmp_points + 1, points, size * sizeof(struct point));
+    tmp_points[0] = tmp_points[size];
+
+    size_t m = 1;
+    for (size_t i = 2; i <= size; ++i) {
+        while (ccw(tmp_points[m - 1], tmp_points[m], tmp_points[i]) <= 0) {
+            if (m > 1) {
+                m--;
+                continue;
+            } else if (i == size) {
+                break;
+            } else {
+                i++;
+            }
+        }
+
+        m++;
+        struct point tmp = tmp_points[i];
+        tmp_points[i] = tmp_points[m];
+        tmp_points[m] = tmp;
+    }
+
+    memcpy(points, tmp_points + 1, size * sizeof(struct point));
+
+    return m;
+}
+
+int main() {
+    struct point points[] = {{2.0, 1.9}, {1.0, 1.0}, {2.0, 4.0}, {3.0, 1.0},
+                                {2.0, 0.0}};
+
+    printf("Points:\n");
+    for (size_t i = 0; i < 5; ++i) {
+        printf("(%f,%f)\n", points[i].x, points[i].y);
+    }
+
+    size_t hull_size = graham_scan(points, 5);
+
+    printf("\nHull:\n");
+    for (size_t i = 0; i < hull_size; ++i) {
+        printf("(%f,%f)\n", points[i].x, points[i].y);
+    }
+
+    return 0;
+}

chapters/computational_geometry/gift_wrapping/graham_scan/code/julia/graham.jl

@@ -7,26 +7,6 @@ function dist(point1::Point, point2::Point)
     return sqrt((point1.x - point2.x)^2 + (point1.y - point2.y)^2)
 end
 
-function graham_angle(point1::Point, point2::Point, point3::Point)
-    # Find distances between all points
-    a = dist(point3, point2)
-    b = dist(point3, point1)
-    c = dist(point1, point2)
-
-    ret_angle = acos((b*b - a*a - c*c)/(2*a*c))
-
-    if(sign(point1.x - point2.x) != sign(point1.x - point3.x))
-        ret_angle += 0.5*pi
-    end
-
-    if (isnan(ret_angle))
-        exit(1)
-    end
-
-    return ret_angle
-
-end
-
 function ccw(a::Point, b::Point, c::Point)
     return ((b.x - a.x)*(c.y - a.y) - (b.y - a.y)*(c.x - a.x))
 end
@@ -38,7 +18,8 @@ function graham_scan(points::Vector{Point})
     sort!(points, by = item -> item.y)
 
     # Sort all other points according to angle with that point
-    other_points = sort(points[2:end], by = item -> graham_angle(Point(points[1].x - 1,points[1].y), points[1], item))
+    other_points = sort(points[2:end], by = item -> atan2(item.y - points[1].y,
+                                                          item.x - points[1].x))
 
     # Place points sorted by angle back into points vector
     for i in 1:length(other_points)
@@ -69,6 +50,7 @@ function graham_scan(points::Vector{Point})
 end
 
 function main()
+    # This hull is just a simple test so we know what the output should be
     points = [Point(2,1.9), Point(1, 1), Point(2, 4), Point(3, 1), Point(2, 0)]
     hull = graham_scan(points)
     println(hull)

chapters/computational_geometry/gift_wrapping/graham_scan/graham_scan.md

@@ -14,6 +14,8 @@ We can find whether a rotation is counter-clockwise with trigonometric functions
 {% method %}
 {% sample lang="jl" %}
 [import:30-32, lang:"julia"](code/julia/graham.jl)
+{% sample lang="c" %}
+[import:24-26, lang:"c_cpp"](code/c/graham.c)
 {% endmethod %}
 
 If the output of this function is 0, the points are collinear.
@@ -30,6 +32,8 @@ In the end, the code should look something like this:
 {% method %}
 {% sample lang="jl" %}
 [import:34-69, lang:"julia"](code/julia/graham.jl)
+{% sample lang="c" %}
+[import:65-95, lang:"c_cpp"](code/c/graham.c)
 {% endmethod %}
 
 ### Bibliography
@@ -41,6 +45,8 @@ In the end, the code should look something like this:
 {% method %}
 {% sample lang="jl" %}
 [import, lang:"julia"](code/julia/graham.jl)
+{% sample lang="c" %}
+[import, lang:"c_cpp"](code/c/graham.c)
 {% endmethod %}
 
 <script>

chapters/matrix_methods/thomas/thomas.md

@@ -1,9 +1,6 @@
-##### Dependencies
-* [Gaussian Elimination](gaussian_elimination.md)
-
 # Thomas Algorithm
 
-As alluded to in the Gaussian Elimination Chapter, the Thomas Algorithm (or TDMA -- Tri-Diagonal Matrix Algorithm) allows for programmers to **massively** cut the computational cost of their code from $$\sim O(n^3) \rightarrow \sim O(n)$$! This is done by exploiting a particular case of Gaussian Elimination, particularly the case where our matrix looks like:
+As alluded to in the [Gaussian Elimination chapter](../gaussian_elimination/gaussian_elimination.md), the Thomas Algorithm (or TDMA -- Tri-Diagonal Matrix Algorithm) allows for programmers to **massively** cut the computational cost of their code from $$\sim O(n^3) \rightarrow \sim O(n)$$! This is done by exploiting a particular case of Gaussian Elimination, particularly the case where our matrix looks like:
 
 $$
 \left[
@@ -19,7 +16,8 @@ $$
 
 By this, I mean that our matrix is *Tri-Diagonal* (excluding the right-hand side of our system of equations, of course!). Now, at first, it might not be obvious how this helps; however, we may divide this array into separate vectors corresponding to $$a$$, $$b$$, $$c$$, and $$d$$ and then solve for $$x$$ with back-substitution, like before. 
 
-In particular, we need to find an optimal scale factor for each row and use that. What is the scale factor? Well, it is the diagonal $$-$$ the multiplicative sum of the off-diagonal elements. In the end, we will update $$c$$ and $$d$$ to be$$c'$$ and $$d'$$ like so:
+In particular, we need to find an optimal scale factor for each row and use that. What is the scale factor? Well, it is the diagonal $$-$$ the multiplicative sum of the off-diagonal elements.
+In the end, we will update $$c$$ and $$d$$ to be $$c'$$ and $$d'$$ like so:
 
 $$
 \begin{align}