Merge branch 'master' into master

Author: Mukundan314

CONTRIBUTORS.md

@@ -9,4 +9,5 @@ Maxime Dherbécourt
 Jess 3Jane
 Pen Pal
 Mukundan
-Chinmaya Mahesh
+Chinmaya Mahesh
+Unlambder

book.json

@@ -36,12 +36,8 @@
 					"name": "C"
 				},
 				{
-					"lang": "py2",
-					"name": "Python 2"
-				},
-				{
-					"lang": "py3",
-					"name": "Python 3"
+					"lang": "py",
+					"name": "Python"
 				},
 				{
 					"lang": "js",
@@ -86,6 +82,14 @@
 				{
 					"lang": "go",
 					"name": "Go"
+				},
+				{
+					"lang": "racket",
+					"name": "Racket"
+				}
+				{
+					"lang": "m",
+					"name": "Matlab"
 				}
 
 			],

chapters/FFT/code/python2/fft.py renamed to chapters/FFT/code/python/fft.py

@@ -77,7 +77,7 @@ For some reason, though, putting code to this transformation really helped me fi
 [import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="hs" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
-{% sample lang="py2" %}
+{% sample lang="py" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="scratch" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
@@ -122,8 +122,8 @@ In the end, the code looks like:
 [import:27-57, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
 [import:6-19, lang:"haskell"](code/hs/fft.hs)
-{% sample lang="py2" %}
-[import:5-16, lang:"python"](code/python2/fft.py)
+{% sample lang="py" %}
+[import:5-16, lang:"python"](code/python/fft.py)
 {% sample lang="scratch" %}
 [import:14-31, lang:"julia"](code/julia/fft.jl)
 {% endmethod %}
@@ -230,9 +230,9 @@ Note: I implemented this in Julia because the code seems more straightforward in
 {% sample lang="hs" %}
 ### Haskell
 [import, lang:"haskell"](code/hs/fft.hs)
-{% sample lang="py2" %}
+{% sample lang="py" %}
 ### Python
-[import, lang:"python"](code/python2/fft.py)
+[import, lang:"python"](code/python/fft.py)
 {% sample lang="scratch" %}
 ### Scratch
 Some rather impressive scratch code was submitted by Jie and can be found here: https://scratch.mit.edu/projects/37759604/#editor

chapters/FFT/cooley_tukey.md

@@ -24,6 +24,8 @@ def euclid_sub(a, b):
 
     return a
 
-print euclid_mod(64 * 67, 64 * 81)
-print euclid_sub(128 * 12, 128 * 77)
+def main():
+    print(euclid_mod(64 * 67, 64 * 81))
+    print(euclid_sub(128 * 12, 128 * 77))
 
+main()

chapters/euclidean_algorithm/code/python2/euclidean_example.py renamed to chapters/euclidean_algorithm/code/python/euclidean_example.py

@@ -15,8 +15,8 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 [import:20-33, lang="c_cpp"](code/c++/euclidean.cpp)
 {% sample lang="js" %}
 [import:15-29, lang="javascript"](code/javascript/euclidean_example.js)
-{% sample lang="py2" %}
-[import:14-25, lang="python"](code/python2/euclidean_example.py)
+{% sample lang="py" %}
+[import:14-25, lang="python"](code/python/euclidean_example.py)
 {% sample lang="haskell" %}
 [import:3-11, lang="haskell"](code/haskell/euclidean_example.hs)
 {% sample lang="rs" %}
@@ -48,8 +48,8 @@ Modern implementations, though, often use the modulus operator (%) like so
 [import:7-17, lang="c_cpp"](code/c++/euclidean.cpp)
 {% sample lang="js" %}
 [import:1-13, lang="javascript"](code/javascript/euclidean_example.js)
-{% sample lang="py2" %}
-[import:1-12, lang="python"](code/python2/euclidean_example.py)
+{% sample lang="py" %}
+[import:1-12, lang="python"](code/python/euclidean_example.py)
 {% sample lang="haskell" %}
 [import:13-24, lang="haskell"](code/haskell/euclidean_example.hs)
 {% sample lang="rs" %}
@@ -91,9 +91,9 @@ Program.cs
 {% sample lang="js" %}
 ### JavaScript
 [import, lang="javascript"](code/javascript/euclidean_example.js)
-{% sample lang="py2" %}
+{% sample lang="py" %}
 ### Python
-[import, lang="python"](code/python2/euclidean_example.py)
+[import, lang="python"](code/python/euclidean_example.py)
 {% sample lang="haskell" %}
 ### Haskell
 [import, lang="haskell"](code/haskell/euclidean_example.hs)

chapters/euclidean_algorithm/euclidean.md

@@ -0,0 +1,37 @@
+// Submitted by Chinmaya Mahesh (chin123)
+
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"time"
+)
+
+func inCircle(x, y float64) bool {
+	return x*x+y*y < 1.0 // the radius of an unit circle is 1.0
+}
+
+func monteCarlo(samples int) {
+	count := 0
+	s := rand.NewSource(time.Now().UnixNano())
+	r := rand.New(s)
+
+	for i := 0; i < samples; i++ {
+		x, y := r.Float64(), r.Float64()
+
+		if inCircle(x, y) {
+			count += 1
+		}
+	}
+	
+	estimate := 4.0 * float64(count) / float64(samples)
+
+	fmt.Println("The estimate of pi is", estimate)
+	fmt.Printf("Which has an error of %f%%\n", 100*math.Abs(math.Pi-estimate)/math.Pi)
+}
+
+func main() {
+	monteCarlo(10000000)
+}

chapters/monte_carlo/code/go/monteCarlo.go

@@ -47,6 +47,8 @@ each point is tested to see whether it's in the circle or not:
 [import:7-9, lang:"rust"](code/rust/monte_carlo.rs)
 {% sample lang="d" %}
 [import:2-5, lang:"d"](code/rust/monte_carlo.d)
+{% sample lang="go" %}
+[import:12-14, lang:"go"](code/go/monteCarlo.go)
 {% endmethod %}
 
 If it's in the circle, we increase an internal count by one, and in the end,
@@ -93,6 +95,9 @@ Feel free to submit your version via pull request, and thanks for reading!
 ### D
 {%sample lang="d" %}
 [import, lang:"d"](code/d/monte_carlo.d)
+### Go
+{%sample lang="go" %}
+[import, lang:"go"](code/go/monteCarlo.go)
 {% endmethod %}
 
 

chapters/monte_carlo/monte_carlo.md

@@ -52,17 +52,17 @@ def main():
     sim = Verlet(Ball(pos = 5.0, acc = -10))
     sim.run()
 
-    print "Verlet:", sim.time
+    print("Verlet:", sim.time)
 
     sim = Stormer_Verlet(Ball(pos = 5.0, acc = -10))
     sim.run()
 
-    print "Stormer Verlet:", sim.time
+    print("Stormer Verlet:", sim.time)
 
     sim = Velocity_Verlet(Ball(pos = 5.0, acc = -10))
     sim.run()
 
-    print "Velocity Verlet:", sim.time
+    print("Velocity Verlet:", sim.time)
 
 
 if __name__ == "__main__":

chapters/physics_solvers/verlet/code/python2/verlet.py renamed to chapters/physics_solvers/verlet/code/python/verlet.py

@@ -38,8 +38,8 @@ Here is what it looks like in code:
 [import:3-16, lang:"c_cpp"](code/c/verlet.c)
 {% sample lang="java" %}
 [import:2-18, lang:"java"](code/java/verlet.java)
-{% sample lang="py2" %}
-[import:28-33, lang:"python"](code/python2/verlet.py)
+{% sample lang="py" %}
+[import:28-33, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
 Unfortunately, this has not yet been implemented in haskell, so here's Julia code:
 [import:1-13, lang:"julia"](code/julia/verlet.jl)
@@ -84,8 +84,8 @@ Here's what it looks like in code:
 [import:18-33, lang:"c_cpp"](code/c/verlet.c)
 {% sample lang="java" %}
 [import:21-40, lang:"java"](code/java/verlet.java)
-{% sample lang="py2" %}
-[import:35-42, lang:"python"](code/python2/verlet.py)
+{% sample lang="py" %}
+[import:35-42, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
 Unfortunately, this has not yet been implemented in scratch, so here's Julia code:
 [import:15-31, lang:"julia"](code/julia/verlet.jl)
@@ -141,8 +141,8 @@ Here is the velocity Verlet method in code:
 [import:35-46, lang:"c_cpp"](code/c/verlet.c)
 {% sample lang="java" %}
 [import:43-57, lang:"java"](code/java/verlet.java)
-{% sample lang="py2" %}
-[import:44-48, lang:"python"](code/python2/verlet.py)
+{% sample lang="py" %}
+[import:44-48, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
 Unfortunately, this has not yet been implemented in haskell, so here's Julia code:
 [import:33-45, lang:"julia"](code/julia/verlet.jl)
@@ -181,9 +181,9 @@ Both of these methods work simply by iterating timestep-by-timestep and can be w
 {% sample lang="java" %}
 ### Java
 [import, lang:"java"](code/java/verlet.java)
-{% sample lang="py2" %}
+{% sample lang="py" %}
 ### Python
-[import, lang:"python"](code/python2/verlet.py)
+[import, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
 ### Haskell
 [import, lang:"haskell"](code/haskell/verlet.hs)

chapters/physics_solvers/verlet/verlet.md

@@ -27,6 +27,8 @@ In code, it looks something like this:
 [import:1-16, lang:"javascript"](code/js/bogo.js)
 {% sample lang="hs" %}
 [import, lang:"haskell"](code/haskell/bogoSort.hs)
+{% sample lang="m" %}
+[import, lang:"matlab"](code/matlab/bogosort.m)
 {% sample lang="cpp" %}
 [import, lang:"c_cpp"](code/c++/bogosort.cpp)
 {% sample lang="rs" %}

chapters/sorting_searching/bogo/bogo_sort.md

@@ -0,0 +1,30 @@
+function main()
+    array = floor( rand(1,7)*100 );
+    disp('Before Sorting:')
+    disp(array)
+
+    array = bogo_sort(array);
+    disp('After Sorting')
+    disp(array)
+end
+
+function retval = is_sorted(array)
+    for i=1:length(array)-1
+        if array(i) > array(i+1)
+            retval = false;
+            return
+        end
+    end
+    retval = true;
+end
+
+function sorted_array = bogo_sort(array)
+    while ~is_sorted(array)
+        % create a list of random permutation indices
+        i = randperm(length(array));
+        array = array(i);
+    end
+    sorted_array = array;
+end
+
+

chapters/sorting_searching/bogo/code/matlab/bogosort.m

@@ -18,6 +18,10 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 [import:2-12, lang:"java"](code/java/bubble.java)
 {% sample lang="js" %}
 [import:1-11, lang:"javascript"](code/js/bubble.js)
+{% sample lang="py" %}
+[import:4-9, lang:"python"](code/python/bubblesort.py)
+{% sample lang="m" %}
+[import:11-23, lang:"matlab"](code/matlab/bubblesort.m)
 {% sample lang="hs" %}
 [import, lang:"haskell"](code/haskell/bubbleSort.hs)
 {% sample lang="cpp" %}
@@ -28,6 +32,8 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 [import:3-18, lang:"d"](code/d/bubble_sort.d)
 {% sample lang="go" %}
 [import:7-21, lang:"go"](code/go/bubbleSort.go)
+{% sample lang="racket" %}
+[import:5-19, lang:"racket"](code/racket/bubbleSort.rkt)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.

chapters/sorting_searching/bubble/bubble_sort.md

@@ -0,0 +1,25 @@
+function main()
+    array = floor( rand(1,7)*100 );
+    disp('Before Sorting:')
+    disp(array)
+
+    array = bubble_sort(array);
+    disp('After Sorting')
+    disp(array)
+end
+
+function sorted_array = bubble_sort(array)
+    for i=1:length(array)
+        for j=1:length(array)-i
+            if array(j) > array(j+1)
+                % swap elements in the list
+                temp       = array(j);
+                array(j)   = array(j+1);
+                array(j+1) = temp;
+            end
+        end
+    end
+    sorted_array = array
+end
+
+

chapters/sorting_searching/bubble/code/matlab/bubblesort.m

@@ -1,23 +1,17 @@
-#!usr/bin/python3
-
-#import section
 import random
 
 
 def bubble_sort(array):
-  len_array = len(array)
-  for i in range(len_array):
-    for j in range(len_array - i - 1):
-      if(array[j] > array[j+1]):
-        array[j], array[j+1] = array[j+1], array[j] #swap elements in the list
-
+    len_array = len(array)
+    for i in range(len_array):
+        for j in range(len_array - i - 1):
+            if(array[j] > array[j+1]):
+                array[j], array[j+1] = array[j+1], array[j] #swap elements in the list
 
 def main():
-  number = [random.randint(0, 10000) for _ in range(10)]
-  print("Before Sorting  {}".format(number))
-  bubble_sort(number)
-  print("After Sorting  {}".format(number))
-
+    number = [random.randint(0, 1000) for _ in range(10)]
+    print("Before Sorting  {}".format(number))
+    bubble_sort(number)
+    print("After Sorting  {}".format(number))
 
-if __name__ == "__main__":
-  main()
+main()

chapters/sorting_searching/bubble/code/python/bubblesort.py

@@ -0,0 +1,21 @@
+#lang racket
+
+(provide bubbleSort)
+
+
+(define bubbleSort
+  (case-lambda [(l) (bubbleSort l (length l))]
+               [(l n) (if (= n 1)
+                          l
+                          (bubbleSort (pass l 0 n) (- n 1)))]))
+
+; a single pass, if this is the nth pass, then we know that the (n - 1) last elements are already sorted
+(define (pass l counter n)
+  (let ([x (first l)]
+        [y (second l)]
+        [r (drop l 2)])
+    (cond [(= (- n counter) 2) (cons (min x y) (cons (max x y) r))]
+          [(cons (min x y) (pass  (cons (max x y) r) (+ counter 1) n))])))
+          
+
+((lambda (x) (display (bubbleSort x))) (read))