From ca4a1f7cdc7b2aaaff0ffa22148d3e3013ef3830 Mon Sep 17 00:00:00 2001 From: Ken Power Date: Wed, 3 Oct 2018 09:27:32 +0200 Subject: [PATCH 1/6] add Scala example for Euclidean --- .../code/scala/euclidean.scala | 20 +++++++++++++++++++ .../euclidean_algorithm.md | 6 ++++++ 2 files changed, 26 insertions(+) create mode 100644 contents/euclidean_algorithm/code/scala/euclidean.scala diff --git a/contents/euclidean_algorithm/code/scala/euclidean.scala b/contents/euclidean_algorithm/code/scala/euclidean.scala new file mode 100644 index 000000000..c0f999bc9 --- /dev/null +++ b/contents/euclidean_algorithm/code/scala/euclidean.scala @@ -0,0 +1,20 @@ +object Euclid { + + def euclid(a: Int, b: Int):Int = + (a,b) match{ + case (x, y) if x < y => euclid(x, y-x) + case (x, y) if x > y => euclid(x-y, y) + case _ => a + } + + def euclid_mod(a: Int, b: Int):Int = + b match{ + case 0 => a + case _ => euclid_mod(b, a % b) + } + + def main(args: Array[String]): Unit = + println(euclid(135749,27482)) + println(euclid_mod(135749,27482)) + +} \ No newline at end of file diff --git a/contents/euclidean_algorithm/euclidean_algorithm.md b/contents/euclidean_algorithm/euclidean_algorithm.md index 81860ae5f..243797522 100644 --- a/contents/euclidean_algorithm/euclidean_algorithm.md +++ b/contents/euclidean_algorithm/euclidean_algorithm.md @@ -41,6 +41,8 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two [import:13-24, lang="nim"](code/nim/euclid_algorithm.nim) {% sample lang="f90" %} [import:1-19, lang="Fortran"](code/fortran/euclidean.f90) +{% sample lang="scala" %} +[import:3-8, lang="Scala"](code/scala/euclidean.scala) {% 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: @@ -88,6 +90,8 @@ Modern implementations, though, often use the modulus operator (%) like so [import:1-11, lang="nim"](code/nim/euclid_algorithm.nim) {% sample lang="f90" %} [import:21-34, lang="Fortran"](code/fortran/euclidean.f90) +{% sample lang="scala" %} +[import:10-14, lang="Scala"](code/scala/euclidean.scala) {% 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: @@ -140,6 +144,8 @@ The Euclidean Algorithm is truly fundamental to many other algorithms throughout [import, lang="nim" %](code/nim/euclid_algorithm.nim) {% sample lang="f90" %} [import, lang="Fortran"](code/fortran/euclidean.f90) +{% sample lang="scala" %} +[import, lang="Scala"](code/scala/euclidean.scala) {% endmethod %} From 281537cada1c877dcced3b1eea556c02a4ffd610 Mon Sep 17 00:00:00 2001 From: Ken Power Date: Wed, 3 Oct 2018 23:11:47 +0200 Subject: [PATCH 2/6] deal with negative args and zero --- .../code/scala/euclidean.scala | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/contents/euclidean_algorithm/code/scala/euclidean.scala b/contents/euclidean_algorithm/code/scala/euclidean.scala index c0f999bc9..9fcef4099 100644 --- a/contents/euclidean_algorithm/code/scala/euclidean.scala +++ b/contents/euclidean_algorithm/code/scala/euclidean.scala @@ -1,20 +1,22 @@ object Euclid { - def euclid(a: Int, b: Int):Int = - (a,b) match{ - case (x, y) if x < y => euclid(x, y-x) - case (x, y) if x > y => euclid(x-y, y) + def euclid(a: Int, b: Int): Int = + (Math.abs(a), Math.abs(b)) match { + case (0, _) | (_, 0) => 0 + case (x, y) if x < y => euclid(x, y - x) + case (x, y) if x > y => euclid(x - y, y) case _ => a } - def euclid_mod(a: Int, b: Int):Int = - b match{ + def euclid_mod(a: Int, b: Int): Int = + b match { case 0 => a case _ => euclid_mod(b, a % b) } - def main(args: Array[String]): Unit = - println(euclid(135749,27482)) - println(euclid_mod(135749,27482)) + def main(args: Array[String]): Unit = { + println(euclid(151 * 899, 151 * 182)) + println(euclid_mod(151 * 899, 151 * 182)) + } -} \ No newline at end of file +} From 53763f11f043197afa8bc4fadd2249b0a6054155 Mon Sep 17 00:00:00 2001 From: Ken Power Date: Wed, 3 Oct 2018 23:11:47 +0200 Subject: [PATCH 3/6] deal with negative args and zero --- .../code/scala/euclidean.scala | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/contents/euclidean_algorithm/code/scala/euclidean.scala b/contents/euclidean_algorithm/code/scala/euclidean.scala index c0f999bc9..9fcef4099 100644 --- a/contents/euclidean_algorithm/code/scala/euclidean.scala +++ b/contents/euclidean_algorithm/code/scala/euclidean.scala @@ -1,20 +1,22 @@ object Euclid { - def euclid(a: Int, b: Int):Int = - (a,b) match{ - case (x, y) if x < y => euclid(x, y-x) - case (x, y) if x > y => euclid(x-y, y) + def euclid(a: Int, b: Int): Int = + (Math.abs(a), Math.abs(b)) match { + case (0, _) | (_, 0) => 0 + case (x, y) if x < y => euclid(x, y - x) + case (x, y) if x > y => euclid(x - y, y) case _ => a } - def euclid_mod(a: Int, b: Int):Int = - b match{ + def euclid_mod(a: Int, b: Int): Int = + b match { case 0 => a case _ => euclid_mod(b, a % b) } - def main(args: Array[String]): Unit = - println(euclid(135749,27482)) - println(euclid_mod(135749,27482)) + def main(args: Array[String]): Unit = { + println(euclid(151 * 899, 151 * 182)) + println(euclid_mod(151 * 899, 151 * 182)) + } -} \ No newline at end of file +} From 5f761e5332b6664eaa671bdc90e8eb75d29510fd Mon Sep 17 00:00:00 2001 From: Ken Power Date: Thu, 4 Oct 2018 09:09:26 +0200 Subject: [PATCH 4/6] rename function --- contents/euclidean_algorithm/code/scala/euclidean.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/contents/euclidean_algorithm/code/scala/euclidean.scala b/contents/euclidean_algorithm/code/scala/euclidean.scala index 9fcef4099..290681e79 100644 --- a/contents/euclidean_algorithm/code/scala/euclidean.scala +++ b/contents/euclidean_algorithm/code/scala/euclidean.scala @@ -9,9 +9,9 @@ object Euclid { } def euclid_mod(a: Int, b: Int): Int = - b match { - case 0 => a - case _ => euclid_mod(b, a % b) + (Math.abs(a), Math.abs(b)) match { + case (_, 0) => a + case (a, b) => euclid_mod(b, a % b) } def main(args: Array[String]): Unit = { From c6ffce1a1ffff223678f906bf3a91c5284bcfc50 Mon Sep 17 00:00:00 2001 From: Ken Power Date: Thu, 4 Oct 2018 16:07:04 +0200 Subject: [PATCH 5/6] change method name --- contents/euclidean_algorithm/code/scala/euclidean.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/contents/euclidean_algorithm/code/scala/euclidean.scala b/contents/euclidean_algorithm/code/scala/euclidean.scala index 290681e79..bc3fe103a 100644 --- a/contents/euclidean_algorithm/code/scala/euclidean.scala +++ b/contents/euclidean_algorithm/code/scala/euclidean.scala @@ -1,6 +1,6 @@ object Euclid { - def euclid(a: Int, b: Int): Int = + def euclid_sub(a: Int, b: Int): Int = (Math.abs(a), Math.abs(b)) match { case (0, _) | (_, 0) => 0 case (x, y) if x < y => euclid(x, y - x) @@ -15,7 +15,7 @@ object Euclid { } def main(args: Array[String]): Unit = { - println(euclid(151 * 899, 151 * 182)) + println(euclid_sub(151 * 899, 151 * 182)) println(euclid_mod(151 * 899, 151 * 182)) } From d39bfb2f152d8fb9d0f7d937dbbac26f478d19b7 Mon Sep 17 00:00:00 2001 From: Ken Power Date: Fri, 5 Oct 2018 09:36:27 +0200 Subject: [PATCH 6/6] fix typo --- contents/euclidean_algorithm/euclidean_algorithm.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/contents/euclidean_algorithm/euclidean_algorithm.md b/contents/euclidean_algorithm/euclidean_algorithm.md index 6099fc278..ad3d88183 100644 --- a/contents/euclidean_algorithm/euclidean_algorithm.md +++ b/contents/euclidean_algorithm/euclidean_algorithm.md @@ -40,9 +40,9 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two {% sample lang="nim" %} [import:13-24, lang="nim"](code/nim/euclid_algorithm.nim) {% sample lang="f90" %} -[import:1-19, lang="Fortran"](code/fortran/euclidean.f90) +[import:1-19, lang="fortran"](code/fortran/euclidean.f90) {% sample lang="scala" %} -[import:3-8, lang="Scala"](code/scala/euclidean.scala) +[import:3-8, lang="scala"](code/scala/euclidean.scala) {% sample lang="racket" %} [import:3-14, lang="lisp"](code/racket/euclidean_algorithm.rkt) {% endmethod %} @@ -91,9 +91,9 @@ Modern implementations, though, often use the modulus operator (%) like so {% sample lang="nim" %} [import:1-11, lang="nim"](code/nim/euclid_algorithm.nim) {% sample lang="f90" %} -[import:21-34, lang="Fortran"](code/fortran/euclidean.f90) +[import:21-34, lang="fortran"](code/fortran/euclidean.f90) {% sample lang="scala" %} -[import:10-14, lang="Scala"](code/scala/euclidean.scala) +[import:10-14, lang="scala"](code/scala/euclidean.scala) {% sample lang="racket" %} [import:16-24, lang="lisp"](code/racket/euclidean_algorithm.rkt) {% endmethod %} @@ -147,9 +147,9 @@ The Euclidean Algorithm is truly fundamental to many other algorithms throughout {% sample lang="nim" %} [import, lang="nim" %](code/nim/euclid_algorithm.nim) {% sample lang="f90" %} -[import, lang="Fortran"](code/fortran/euclidean.f90) +[import, lang="fortran"](code/fortran/euclidean.f90) {% sample lang="scala" %} -[import, lang="Scala"](code/scala/euclidean.scala) +[import, lang="scala"](code/scala/euclidean.scala) {% sample lang="racket" %} [import, lang="lisp"](code/racket/euclidean_algorithm.rkt) {% endmethod %}