Euclid algorithm in bash

book.json

@@ -163,6 +163,10 @@
  {
  "lang": "lolcode",
  "name": "LOLCODE"
+ },
+ {
+ "lang": "bash",
+ "name": "Bash"
  }
  ]
  }

contents/euclidean_algorithm/code/bash/euclid.sh

@@ -0,0 +1,37 @@
+abs() {
+local ret=$1
+if [ $ret -lt 0 ]; then
+let "ret = $ret * -1"
+fi
+echo $ret
+} 
+
+euclid_mod() {
+local a=$(abs $1)
+local b=$(abs $2)
+while [ $b -ne 0 ]; do
+let "tmp = $b"
+let "b = $a % $b"
+let "a = tmp"
+done
+echo $a
+}
+
+euclid_sub() {
+local a=$(abs $1)
+local b=$(abs $2)
+
+while [ $a -ne $b ]; do
+if [ $a -gt $b ]; then
+let "a = $a - $b"
+else
+let "b = $b - $a"
+fi
+done
+echo $a
+}
+
+result=$(euclid_mod 143 693)
+echo $result
+result=$(euclid_sub 150 400)
+echo $result

contents/euclidean_algorithm/euclidean_algorithm.md

@@ -59,6 +59,8 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 [import:2-17, lang:"emojicode"](code/emojicode/euclidean_algorithm.emojic)
 {% sample lang="lolcode" %}
 [import:25-40, lang="LOLCODE"](code/lolcode/euclid.lol)
+{% sample lang="bash" %}
+[import:9-18, lang="bash"](code/bash/euclid.sh)
 {% endmethod %}
 
 Here, we simply line the two numbers up every step and subtract the lower value from the higher one every timestep. Once the two values are equal, we call that value the greatest common divisor. A graph of `a` and `b` as they change every step would look something like this:
@@ -124,6 +126,8 @@ Modern implementations, though, often use the modulus operator (%) like so
 [import:19-31, lang:"emojicode"](code/emojicode/euclidean_algorithm.emojic)
 {% sample lang="lolcode" %}
 [import:9-23, lang="LOLCODE"](code/lolcode/euclid.lol)
+{% sample lang="bash" %}
+[import:20-32, lang="bash"](code/bash/euclid.sh)
 {% endmethod %}
 
 Here, we set `b` to be the remainder of `a%b` and `a` to be whatever `b` was last timestep. Because of how the modulus operator works, this will provide the same information as the subtraction-based implementation, but when we show `a` and `b` as they change with time, we can see that it might take many fewer steps:
@@ -197,6 +201,8 @@ and modulo method:
 [import, lang:"emojicode"](code/emojicode/euclidean_algorithm.emojic)
 {% sample lang="lolcode" %}
 [import, lang="LOLCODE"](code/lolcode/euclid.lol)
+{% sample lang="bash" %}
+[import, lang="bash"](code/bash/euclid.sh)
 {% endmethod %}
 
 <script>

contents/thomas_algorithm/thomas_algorithm.md

@@ -1,4 +1,4 @@
-# Thomas Algorithm
+s# Thomas Algorithm
 
 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 $$ O(n^3)$$ to $$O(n)$$ in certain cases!
 This is done by exploiting a particular case of Gaussian Elimination where the matrix looks like this:
@@ -111,8 +111,6 @@ You will find this algorithm implemented [in this project](https://scratch.mit.e
 [import, lang:"java"](code/java/thomas.java)
 {% sample lang="hs" %}
 [import, lang:"haskell"](code/haskell/thomas.hs)
-{% sample lang="go" %}
-[import, lang:"go"](code/golang/thomas.go)
 {% sample lang="swift" %}
 [import, lang:"swift"](code/swift/thomas.swift)
 {% sample lang="php" %}