Changed implementation to use BigInteger in order to have accuracy when using large inputs.

Author: n.bitounis

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,23 +16,23 @@ 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> _catalanNumbers = new Dictionary<uint, BigInteger> { { 0, 1 }, { 1, 1 } };
 
         /// <summary>
         /// Helper function.
         /// </summary>
-        private static ulong _recursiveHelper(uint rank)
+        private static BigInteger _recursiveHelper(uint rank)
         {
             if (_catalanNumbers.ContainsKey(rank))
                 return _catalanNumbers[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);
@@ -46,7 +46,7 @@ private static ulong _recursiveHelper(uint rank)
         /// <summary>
         /// Public API
         /// </summary>
-        public static ulong GetNumber(uint rank)
+        public static BigInteger GetNumber(uint rank)
         {
             // Assert the cache is not empty.
             Debug.Assert(_catalanNumbers.Count >= 2);
@@ -57,31 +57,26 @@ public static ulong GetNumber(uint rank)
         /// <summary>
         /// Calculate the number using the Binomial Coefficients algorithm
         /// </summary>
-        public static ulong GetNumberByBinomialCoefficients(uint rank)
+        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.
         /// </summary>
-        public static List<ulong> GetRange(uint fromRank, uint toRank)
+        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;
 
@@ -10,7 +11,7 @@ public class CatalanNumbersTest
         public static 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)