From d9f74581e69262e43f859cc04df8b9df261bd2cd Mon Sep 17 00:00:00 2001
From: c252 <c252@gmail.com>
Date: Sat, 26 Jan 2019 16:26:51 -0500
Subject: [PATCH 01/11] euclid alg in scheme

---
 book.json                                     |  4 +++
 .../code/scheme/euclidalg.ss                  | 25 +++++++++++++++++++
 .../euclidean_algorithm.md                    |  6 +++++
 3 files changed, 35 insertions(+)
 create mode 100644 contents/euclidean_algorithm/code/scheme/euclidalg.ss

diff --git a/book.json b/book.json
index f15df90ae..839600e50 100644
--- a/book.json
+++ b/book.json
@@ -188,6 +188,10 @@
         {
           "lang": "piet",
           "name": "Piet"
+        },
+        {
+          "lang": "ss",
+          "name": "Scheme"
         }
       ]
     }
diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
new file mode 100644
index 000000000..7e0da36d4
--- /dev/null
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -0,0 +1,25 @@
+(define euclid-sub
+    (lambda (a b)
+        (cond 
+            ((or (negative? a) (negative? b))
+            (euclid-sub (abs a) (abs b)))
+            (else (cond
+                ((eq? a b) a)
+                (else (cond
+                    ((> a b)
+                    (euclid-sub (- a b) b))
+                    (else
+                        (euclid-sub a (- b a))))))))))
+                  
+(define euclid-mod
+    (lambda (a b)
+        (cond
+            ((or (negative? a) (negative? b))
+            (euclid-mod (abs a) (abs b)))
+        (else (cond
+            ((zero? b) a)
+            (else
+                (euclid-mod b (modulo a b))))))))
+
+(display (euclid-mod (* 64 67) (* 64 81))) (newline)
+(display (euclid-sub (* 64 12) (* 64 27))) (newline)
\ No newline at end of file
diff --git a/contents/euclidean_algorithm/euclidean_algorithm.md b/contents/euclidean_algorithm/euclidean_algorithm.md
index 84aa60f3f..adee422cb 100644
--- a/contents/euclidean_algorithm/euclidean_algorithm.md
+++ b/contents/euclidean_algorithm/euclidean_algorithm.md
@@ -65,6 +65,8 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 [import:24-38, lang="bash"](code/bash/euclid.bash)
 {% sample lang="piet" %}
 > ![](code/piet/subtract/euclidian_algorithm_subtract_large.png) ![](code/piet/subtract/euclidian_algorithm_subtract.png)
+{% sample lang="ss" %}
+[import:1-12, lang="scheme"](code/scheme/euclidalg.ss)
 {% 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:
@@ -136,6 +138,8 @@ Modern implementations, though, often use the modulus operator (%) like so
 [import:10-22, lang="bash"](code/bash/euclid.bash)
 {% sample lang="piet" %}
 > ![](code/piet/mod/euclidian_algorithm_mod_large.png) ![](code/piet/mod/euclidian_algorithm_mod.png)
+{% sample lang="ss" %}
+[import:14-22, lang="scheme"](code/scheme/euclidalg.ss)
 {% 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:
@@ -232,6 +236,8 @@ A text version of the program is provided for both versions.
 > ![](code/piet/mod/euclidian_algorithm_mod_large.png) ![](code/piet/mod/euclidian_algorithm_mod.png)
 
 [import:126-146](code/piet/euclidian_algorithm.piet)
+{% sample lang="ss" %}
+[import:, lang="scheme"](code/scheme/euclidalg.ss)
 {% endmethod %}
 
 <script>

From e94b787fcef63e3e3a0f5621db50945794ac33b1 Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 07:23:07 -0500
Subject: [PATCH 02/11] Update euclidalg.ss

---
 contents/euclidean_algorithm/code/scheme/euclidalg.ss | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
index 7e0da36d4..0b72388de 100644
--- a/contents/euclidean_algorithm/code/scheme/euclidalg.ss
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -14,12 +14,9 @@
 (define euclid-mod
     (lambda (a b)
         (cond
-            ((or (negative? a) (negative? b))
-            (euclid-mod (abs a) (abs b)))
-        (else (cond
             ((zero? b) a)
             (else
-                (euclid-mod b (modulo a b))))))))
+                (euclid-mod b (modulo a b))))))
 
 (display (euclid-mod (* 64 67) (* 64 81))) (newline)
-(display (euclid-sub (* 64 12) (* 64 27))) (newline)
\ No newline at end of file
+(display (euclid-sub (* 64 12) (* 64 27))) (newline)

From 2e3c2dff1b44c0c6e8ad89801505acfe90bec702 Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 07:33:26 -0500
Subject: [PATCH 03/11] Update euclidalg.ss

---
 contents/euclidean_algorithm/code/scheme/euclidalg.ss | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
index 0b72388de..d57fb410c 100644
--- a/contents/euclidean_algorithm/code/scheme/euclidalg.ss
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -1,5 +1,4 @@
-(define euclid-sub
-    (lambda (a b)
+(define (euclid-sub a b)
         (cond 
             ((or (negative? a) (negative? b))
             (euclid-sub (abs a) (abs b)))
@@ -9,14 +8,13 @@
                     ((> a b)
                     (euclid-sub (- a b) b))
                     (else
-                        (euclid-sub a (- b a))))))))))
+                        (euclid-sub a (- b a)))))))))
                   
-(define euclid-mod
-    (lambda (a b)
+(define (euclid-mod a b)
         (cond
             ((zero? b) a)
             (else
-                (euclid-mod b (modulo a b))))))
+                (euclid-mod b (modulo a b)))))
 
 (display (euclid-mod (* 64 67) (* 64 81))) (newline)
 (display (euclid-sub (* 64 12) (* 64 27))) (newline)

From 49178feb8fd88eeb2ef1c92dbeb824077aa66b7c Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 08:32:13 -0500
Subject: [PATCH 04/11] Update euclidalg.ss

---
 contents/euclidean_algorithm/code/scheme/euclidalg.ss | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
index d57fb410c..6a8ee6ac4 100644
--- a/contents/euclidean_algorithm/code/scheme/euclidalg.ss
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -11,10 +11,9 @@
                         (euclid-sub a (- b a)))))))))
                   
 (define (euclid-mod a b)
-        (cond
-            ((zero? b) a)
-            (else
-                (euclid-mod b (modulo a b)))))
+        (if (zero? b)
+            a
+            (euclid-mod b (modulo a b))))
 
 (display (euclid-mod (* 64 67) (* 64 81))) (newline)
 (display (euclid-sub (* 64 12) (* 64 27))) (newline)

From 240ca6667e402fbc99579eec2a9c094df806cb2d Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 10:20:01 -0500
Subject: [PATCH 05/11] Update euclidalg.ss

---
 .../code/scheme/euclidalg.ss                  | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
index 6a8ee6ac4..492822a82 100644
--- a/contents/euclidean_algorithm/code/scheme/euclidalg.ss
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -1,15 +1,12 @@
 (define (euclid-sub a b)
-        (cond 
-            ((or (negative? a) (negative? b))
-            (euclid-sub (abs a) (abs b)))
-            (else (cond
-                ((eq? a b) a)
-                (else (cond
-                    ((> a b)
-                    (euclid-sub (- a b) b))
-                    (else
-                        (euclid-sub a (- b a)))))))))
-                  
+        (if (or (negative? a) (negative? b))
+            (euclid-sub (abs a) (abs b))
+            (if (eq? a b) 
+                a
+                (if (> a b)
+                    (euclid-sub (- a b) b)
+                    (euclid-sub a (- b a))))))
+
 (define (euclid-mod a b)
         (if (zero? b)
             a

From 1060e40af1cb77982851b766ccb7d5f3fc7d9380 Mon Sep 17 00:00:00 2001
From: c252 <c252@gmail.com>
Date: Sat, 2 Feb 2019 10:33:49 -0500
Subject: [PATCH 06/11] fixed import lines

---
 contents/euclidean_algorithm/euclidean_algorithm.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/contents/euclidean_algorithm/euclidean_algorithm.md b/contents/euclidean_algorithm/euclidean_algorithm.md
index adee422cb..42dc8049e 100644
--- a/contents/euclidean_algorithm/euclidean_algorithm.md
+++ b/contents/euclidean_algorithm/euclidean_algorithm.md
@@ -66,7 +66,7 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 {% sample lang="piet" %}
 > ![](code/piet/subtract/euclidian_algorithm_subtract_large.png) ![](code/piet/subtract/euclidian_algorithm_subtract.png)
 {% sample lang="ss" %}
-[import:1-12, lang="scheme"](code/scheme/euclidalg.ss)
+[import:1-8, lang="scheme"](code/scheme/euclidalg.ss)
 {% 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:
@@ -139,7 +139,7 @@ Modern implementations, though, often use the modulus operator (%) like so
 {% sample lang="piet" %}
 > ![](code/piet/mod/euclidian_algorithm_mod_large.png) ![](code/piet/mod/euclidian_algorithm_mod.png)
 {% sample lang="ss" %}
-[import:14-22, lang="scheme"](code/scheme/euclidalg.ss)
+[import:10-13, lang="scheme"](code/scheme/euclidalg.ss)
 {% 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:

From d18a8b93dd470fb15868b9ca58c1aaf1bf91717a Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 13:25:57 -0500
Subject: [PATCH 07/11] Update euclidalg.ss

---
 .../code/scheme/euclidalg.ss                  | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
index 492822a82..86c520237 100644
--- a/contents/euclidean_algorithm/code/scheme/euclidalg.ss
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -1,16 +1,15 @@
 (define (euclid-sub a b)
-        (if (or (negative? a) (negative? b))
-            (euclid-sub (abs a) (abs b))
-            (if (eq? a b) 
-                a
-                (if (> a b)
-                    (euclid-sub (- a b) b)
-                    (euclid-sub a (- b a))))))
+    (cond                                                                                                                                                                                                                                                                         
+        [(or (negative? a) (negative? b)) (euclid-sub (abs a) (abs b))]                                                                                                                                                                                                              
+        [(eq? a b) a]
+            (if (> a b)
+                (euclid-sub (- a b) b)
+                (euclid-sub a (- b a))))))
 
 (define (euclid-mod a b)
-        (if (zero? b)
-            a
-            (euclid-mod b (modulo a b))))
+    (if (zero? b)
+        a
+        (euclid-mod b (modulo a b))))
 
 (display (euclid-mod (* 64 67) (* 64 81))) (newline)
 (display (euclid-sub (* 64 12) (* 64 27))) (newline)

From 7297c09300bc9c094d2d84621b2cb1acca62d6a7 Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 13:26:28 -0500
Subject: [PATCH 08/11] Update euclidalg.ss

---
 contents/euclidean_algorithm/code/scheme/euclidalg.ss | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
index 86c520237..e0226958c 100644
--- a/contents/euclidean_algorithm/code/scheme/euclidalg.ss
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -4,7 +4,7 @@
         [(eq? a b) a]
             (if (> a b)
                 (euclid-sub (- a b) b)
-                (euclid-sub a (- b a))))))
+                (euclid-sub a (- b a)))))
 
 (define (euclid-mod a b)
     (if (zero? b)

From 0114f450009a6d9a5345e798772cd8700fc54745 Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 14:03:43 -0500
Subject: [PATCH 09/11] Update euclidalg.ss

---
 contents/euclidean_algorithm/code/scheme/euclidalg.ss | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
index e0226958c..2075c3e57 100644
--- a/contents/euclidean_algorithm/code/scheme/euclidalg.ss
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -2,9 +2,9 @@
     (cond                                                                                                                                                                                                                                                                         
         [(or (negative? a) (negative? b)) (euclid-sub (abs a) (abs b))]                                                                                                                                                                                                              
         [(eq? a b) a]
-            (if (> a b)
-                (euclid-sub (- a b) b)
-                (euclid-sub a (- b a)))))
+        [(> a b) (euclid-sub (- a b) b)]
+        (else
+            (euclid-sub a (- b a)))))
 
 (define (euclid-mod a b)
     (if (zero? b)

From 5f9ff0199953da4659c17bb5639e3b6b8808f5ca Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 14:05:45 -0500
Subject: [PATCH 10/11] Update euclidean_algorithm.md

---
 contents/euclidean_algorithm/euclidean_algorithm.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/contents/euclidean_algorithm/euclidean_algorithm.md b/contents/euclidean_algorithm/euclidean_algorithm.md
index 42dc8049e..20c934293 100644
--- a/contents/euclidean_algorithm/euclidean_algorithm.md
+++ b/contents/euclidean_algorithm/euclidean_algorithm.md
@@ -66,7 +66,7 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 {% sample lang="piet" %}
 > ![](code/piet/subtract/euclidian_algorithm_subtract_large.png) ![](code/piet/subtract/euclidian_algorithm_subtract.png)
 {% sample lang="ss" %}
-[import:1-8, lang="scheme"](code/scheme/euclidalg.ss)
+[import:1-7, lang="scheme"](code/scheme/euclidalg.ss)
 {% 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:
@@ -139,7 +139,7 @@ Modern implementations, though, often use the modulus operator (%) like so
 {% sample lang="piet" %}
 > ![](code/piet/mod/euclidian_algorithm_mod_large.png) ![](code/piet/mod/euclidian_algorithm_mod.png)
 {% sample lang="ss" %}
-[import:10-13, lang="scheme"](code/scheme/euclidalg.ss)
+[import:9-12, lang="scheme"](code/scheme/euclidalg.ss)
 {% 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:

From 15e26c5054626b05b01b926acf18a649979c8ef7 Mon Sep 17 00:00:00 2001
From: Cyrus B <cyrusb252@gmail.com>
Date: Sat, 2 Feb 2019 14:16:21 -0500
Subject: [PATCH 11/11] Update euclidalg.ss

---
 contents/euclidean_algorithm/code/scheme/euclidalg.ss | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/contents/euclidean_algorithm/code/scheme/euclidalg.ss b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
index 2075c3e57..3d891ba73 100644
--- a/contents/euclidean_algorithm/code/scheme/euclidalg.ss
+++ b/contents/euclidean_algorithm/code/scheme/euclidalg.ss
@@ -1,10 +1,10 @@
 (define (euclid-sub a b)
     (cond                                                                                                                                                                                                                                                                         
-        [(or (negative? a) (negative? b)) (euclid-sub (abs a) (abs b))]                                                                                                                                                                                                              
+        [(or (negative? a)(negative? b))(euclid-sub (abs a)(abs b))]                                                                                                                                                                                                              
         [(eq? a b) a]
-        [(> a b) (euclid-sub (- a b) b)]
-        (else
-            (euclid-sub a (- b a)))))
+        [(> a b)(euclid-sub(- a b) b)]
+        [else
+            (euclid-sub a (- b a))]))
 
 (define (euclid-mod a b)
     (if (zero? b)