Merge pull request #75 from nickntg/master

Proposed fixes for catalan numbers

Author: aalhour

Algorithms/Numeric/BinomialCoefficients.cs

@@ -1,30 +1,33 @@
-using System;
+using System.Collections.Generic;
+using System.Numerics;
 
 namespace Algorithms.Numeric
 {
     public static class BinomialCoefficients
     {
+        private static readonly Dictionary<uint, BigInteger> Cache = new Dictionary<uint, BigInteger>();
+
         /// <summary>
         /// Calculate binomial coefficients, C(n, k).
         /// </summary>
-        public static ulong Calculate(uint n, uint k)
+        /// <param name="n"></param>
+        /// <returns></returns>
+        public static BigInteger Calculate(uint n)
         {
-            ulong result = 1;
-
-            // Since C(n, k) = C(n, n-k)
-            if (k > n - k)
-                k = n - k;
+            return Factorial(2 * n) / (Factorial(n) * Factorial(n + 1));
+        }
 
-            // Calculate value of [n*(n-1)*---*(n-k+1)] / [k*(k-1)*---*1]
-            for (int i = 0; i < k; ++i)
+        private static BigInteger Factorial(uint n)
+        {
+            if (n <= 1)
+                return 1;
+            if (Cache.ContainsKey(n))
             {
-                result *= Convert.ToUInt64(n - i);
-                result /= Convert.ToUInt64(i + 1);
+                return Cache[n];
             }
-
-            return result;
+            var value = n * Factorial(n - 1);
+            Cache[n] = value;
+            return value;
         }
-
     }
-
-}
+}

Algorithms/Numeric/CatalanNumbers.cs

@@ -4,9 +4,9 @@
  * Wikipedia: https://en.wikipedia.org/wiki/Catalan_number
  */
 
-using System;
 using System.Diagnostics;
 using System.Collections.Generic;
+using System.Numerics;
 
 namespace Algorithms.Numeric
 {
@@ -16,26 +16,28 @@ public static class CatalanNumbers
         /// Internal cache.
         /// By default contains the first two catalan numbers for the ranks: 0, and 1.
         /// </summary>
-        private static Dictionary<uint, ulong> _catalanNumbers = new Dictionary<uint, ulong>() { { 0, 1 }, { 1, 1 } };
+        private static readonly Dictionary<uint, BigInteger> CachedCatalanNumbers = new Dictionary<uint, BigInteger> { { 0, 1 }, { 1, 1 } };
 
         /// <summary>
-        /// Helper function.
+        /// Helper method.
         /// </summary>
-        private static ulong _recursiveHelper(uint rank)
+        /// <param name="rank"></param>
+        /// <returns></returns>
+        private static BigInteger _recursiveHelper(uint rank)
         {
-            if (_catalanNumbers.ContainsKey(rank))
-                return _catalanNumbers[rank];
+            if (CachedCatalanNumbers.ContainsKey(rank))
+                return CachedCatalanNumbers[rank];
 
-            ulong number = 0;
-            uint lastRank = rank - 1;
+            BigInteger number = 0;
+            var lastRank = rank - 1;
 
             for (uint i = 0; i <= lastRank; ++i)
             {
-                ulong firstPart = _recursiveHelper(i);
-                ulong secondPart = _recursiveHelper(lastRank - i);
+                var firstPart = _recursiveHelper(i);
+                var secondPart = _recursiveHelper(lastRank - i);
 
-                if (!_catalanNumbers.ContainsKey(i)) _catalanNumbers.Add(i, firstPart);
-                if (!_catalanNumbers.ContainsKey(lastRank - i)) _catalanNumbers.Add(lastRank - i, secondPart);
+                if (!CachedCatalanNumbers.ContainsKey(i)) CachedCatalanNumbers.Add(i, firstPart);
+                if (!CachedCatalanNumbers.ContainsKey(lastRank - i)) CachedCatalanNumbers.Add(lastRank - i, secondPart);
 
                 number = number + (firstPart * secondPart);
             }
@@ -44,44 +46,46 @@ private static ulong _recursiveHelper(uint rank)
         }
 
         /// <summary>
-        /// Public API
+        /// Public API.
         /// </summary>
-        public static ulong GetNumber(uint rank)
+        /// <param name="rank"></param>
+        /// <returns></returns>
+        public static BigInteger GetNumber(uint rank)
         {
             // Assert the cache is not empty.
-            Debug.Assert(_catalanNumbers.Count >= 2);
+            Debug.Assert(CachedCatalanNumbers.Count >= 2);
 
             return _recursiveHelper(rank);
         }
 
         /// <summary>
         /// Calculate the number using the Binomial Coefficients algorithm
         /// </summary>
-        public static ulong GetNumberByBinomialCoefficients(uint rank)
+        /// <param name="rank"></param>
+        /// <returns></returns>
+        public static BigInteger GetNumberByBinomialCoefficients(uint rank)
         {
-            // Calculate value of 2nCn
-            var catalanNumber = BinomialCoefficients.Calculate(2 * rank, rank);
-
-            // return 2nCn/(n+1)
-            return Convert.ToUInt64(catalanNumber / (rank + 1));
+            // Calculate by binomial coefficient.
+            return BinomialCoefficients.Calculate(rank);
         }
 
         /// <summary>
-        /// Return the list of catalan numbers between two ranks, inclusive.
+        /// Return the list of catalan numbers between two ranks, inclusive
         /// </summary>
-        public static List<ulong> GetRange(uint fromRank, uint toRank)
+        /// <param name="fromRank"></param>
+        /// <param name="toRank"></param>
+        /// <returns></returns>
+        public static List<BigInteger> GetRange(uint fromRank, uint toRank)
         {
-            List<ulong> numbers = new List<ulong>();
+            var numbers = new List<BigInteger>();
 
             if (fromRank > toRank)
                 return null;
 
-            for (uint i = fromRank; i <= toRank; ++i)
+            for (var i = fromRank; i <= toRank; ++i)
                 numbers.Add(GetNumber(i));
 
             return numbers;
         }
-
     }
-
-}
+}

UnitTest/AlgorithmsTests/CatalanNumbersTest.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Numerics;
 using Algorithms.Numeric;
 using Xunit;
 
@@ -7,10 +8,10 @@ namespace UnitTest.AlgorithmsTests
     public class CatalanNumbersTest
     {
         [Fact]
-        public static void DoTest()
+        public void DoTest()
         {
             var list = CatalanNumbers.GetRange(0, 100);
-            var list2 = new List<ulong>();
+            var list2 = new List<BigInteger>();
 
             // TRY CALCULATING FROM Bin.Coeff.
             for (uint i = 0; i < list.Count; ++i)
@@ -21,5 +22,48 @@ public static void DoTest()
                 Assert.True(list[(int)i] == list2[(int)i], "Wrong calculation.");
             }
         }
+
+        // Values retrieved from https://oeis.org/A000108/list.
+        [Theory]
+        [InlineData(0, "1")]
+        [InlineData(1, "1")]
+        [InlineData(2, "2")]
+        [InlineData(3, "5")]
+        [InlineData(4, "14")]
+        [InlineData(5, "42")]
+        [InlineData(6, "132")]
+        [InlineData(7, "429")]
+        [InlineData(8, "1430")]
+        [InlineData(9, "4862")]
+        [InlineData(10, "16796")]
+        [InlineData(11, "58786")]
+        [InlineData(12, "208012")]
+        [InlineData(13, "742900")]
+        [InlineData(14, "2674440")]
+        [InlineData(15, "9694845")]
+        [InlineData(16, "35357670")]
+        [InlineData(17, "129644790")]
+        [InlineData(18, "477638700")]
+        [InlineData(19, "1767263190")]
+        [InlineData(20, "6564120420")]
+        [InlineData(21, "24466267020")]
+        [InlineData(22, "91482563640")]
+        [InlineData(23, "343059613650")]
+        [InlineData(24, "1289904147324")]
+        [InlineData(25, "4861946401452")]
+        [InlineData(26, "18367353072152")]
+        [InlineData(27, "69533550916004")]
+        [InlineData(28, "263747951750360")]
+        [InlineData(29, "1002242216651368")]
+        [InlineData(30, "3814986502092304")]
+        public void ManuallyVerifyCatalanNumber(uint rank, string value)
+        {
+            // This conversion seems to be necessary because as of this
+            // writing xunit doesn't behave well with BigInteger inline
+            // data values.
+            var bigint = BigInteger.Parse(value);
+
+            Assert.True(CatalanNumbers.GetNumber(rank) == bigint);
+        }
     }
 }