Merge pull request #104 from PatrykOlejniczak/fix-greatest-common-divisor

Fix unit test, separate version GCD algorithm to stein and euclidean.

Author: aalhour

Algorithms/Numeric/GreatestCommonDivisor.cs

@@ -1,46 +1,73 @@
-/***
- * Euclidean Algorithm to find the greatest common divisor of two numbers.
- * 
- */
-
+using System;
 
 namespace Algorithms.Numeric
 {
     public static class GreatestCommonDivisor
     {
         /// <summary>
-        /// Finds and returns the greatest common divisor of two numbers
+        ///     Returns the greatest common divisor of two numbers using Euclidean Algorithm.
         /// </summary>
-        public static uint FindGCD(uint a, uint b)
+        public static int FindGCDEuclidean(int a, int b)
         {
+            a = Math.Abs(a);
+            b = Math.Abs(b);
+
             if (a == 0)
                 return b;
             if (b == 0)
                 return a;
+            if (a == b)
+                return a;
 
-            uint _a = a, _b = b;
-            
-            //Bitwise operator '&' works on individual bits of each value
-            //result is 0 or 1
-            //it works like a modulus operator '%' but is more efficient
-            uint r = _a & _b;
+            return Euclidean(a, b);
+        }
 
-            while(r != 0)
-            {
-                _a = _b;
-                _b = r;
-                r = _a & _b;
-            }
+        private static int Euclidean(int a, int b)
+        {
+            if (b == 0)
+                return a;
 
-            return _b;
+            return Euclidean(b, a % b);
         }
 
         /// <summary>
-        /// Determines given two numbers are relatively prime
+        ///     Returns the greatest common divisor of two numbers using Stein Algorithm.
         /// </summary>
-        public static bool IsRelativelyPrime(uint a, uint b)
+        public static int FindGCDStein(int a, int b)
+        {
+            a = Math.Abs(a);
+            b = Math.Abs(b);
+
+            return Stein(a, b);
+        }
+
+        private static int Stein(int a, int b)
         {
-            return FindGCD(a, b) == 1;
+            if (a == 0)
+                return b;
+            if (b == 0)
+                return a;
+            if (a == b)
+                return a;
+
+            if ((~a & 1) == 1)
+            {
+                if ((b & 1) == 1)
+                {
+                    return Stein(a >> 1, b);
+                }
+                else
+                {
+                    return Stein(a >> 1, b >> 1) << 1;
+                }
+            }
+
+            if ((~b & 1) == 1)
+            {
+                return Stein(a, b >> 1);
+            }
+
+            return a > b ? Stein((a - b) >> 1, b) : Stein(a, (b - a) >> 1);
         }
     }
 }

UnitTest/AlgorithmsTests/GreatestCommonDivisorTest.cs

@@ -0,0 +1,88 @@
+using Algorithms.Numeric;
+using Xunit;
+
+namespace UnitTest.AlgorithmsTests
+{
+    public class GreatestCommonDivisorTests
+    {
+        [Fact]
+        public void FindGCD_BothAreZero()
+        {
+            var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(0, 0);
+            Assert.Equal(0, gcdEuclidean);
+
+            var gcdStein = GreatestCommonDivisor.FindGCDStein(0, 0);
+            Assert.Equal(0, gcdStein);
+        }
+
+        [Theory]
+        [InlineData(0, 4, 4)]
+        [InlineData(0, 9, 9)]
+        [InlineData(0, -14, 14)]
+        [InlineData(0, -99, 99)]
+        public void FindGCD_FirstIsZero(int a, int b, int expected)
+        {
+            var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(a, b);
+            Assert.Equal(expected, gcdEuclidean);
+
+            var gcdStein = GreatestCommonDivisor.FindGCDStein(a, b);
+            Assert.Equal(expected, gcdStein);
+        }
+
+        [Theory]
+        [InlineData(4, 0, 4)]
+        [InlineData(9, 0, 9)]
+        [InlineData(-14, 0, 14)]
+        [InlineData(-99, 0, 99)]
+        public void FindGCD_SecondIsZero(int a, int b, int expected)
+        {
+            var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(a, b);
+            Assert.Equal(expected, gcdEuclidean);
+
+            var gcdStein = GreatestCommonDivisor.FindGCDStein(a, b);
+            Assert.Equal(expected, gcdStein);
+        }
+
+        [Theory]
+        [InlineData(2, 4, 2)]
+        [InlineData(27, 9, 9)]
+        [InlineData(27, 14, 1)]
+        [InlineData(9, 6, 3)]
+        public void FindGCD_BothNumberArePositive(int a, int b, int expected)
+        {
+            var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(a, b);
+            Assert.Equal(expected, gcdEuclidean);
+
+            var gcdStein = GreatestCommonDivisor.FindGCDStein(a, b);
+            Assert.Equal(expected, gcdStein);
+        }
+
+        [Theory]
+        [InlineData(-2, -4, 2)]
+        [InlineData(-27, -9, 9)]
+        [InlineData(-27, -14, 1)]
+        [InlineData(-9, -6, 3)]
+        public void FindGCD_BothNumberAreNegative(int a, int b, int expected)
+        {
+            var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(a, b);
+            Assert.Equal(expected, gcdEuclidean);
+
+            var gcdStein = GreatestCommonDivisor.FindGCDStein(a, b);
+            Assert.Equal(expected, gcdStein);
+        }
+
+        [Theory]
+        [InlineData(2, -4, 2)]
+        [InlineData(-27, 9, 9)]
+        [InlineData(27, -14, 1)]
+        [InlineData(-9, 6, 3)]
+        public void FindGCD_CombinationPositiveAndNegative(int a, int b, int expected)
+        {
+            var gcdEuclidean = GreatestCommonDivisor.FindGCDEuclidean(a, b);
+            Assert.Equal(expected, gcdEuclidean);
+
+            var gcdStein = GreatestCommonDivisor.FindGCDStein(a, b);
+            Assert.Equal(expected, gcdStein);
+        }
+    }
+}