Switch factorial calculation to big integer (TheAlgorithms#393)

Author: craftycoder07

Algorithms.Tests/Numeric/FactorialTests.cs

@@ -1,41 +1,39 @@
 using System;
+using System.Numerics;
 using Algorithms.Numeric;
 using NUnit.Framework;
 
 namespace Algorithms.Tests.Numeric
 {
     public static class FactorialTests
     {
-        [Test]
-        [TestCase(5, 120)]
-        [TestCase(1, 1)]
-        [TestCase(0, 1)]
-        [TestCase(4, 24)]
-        [TestCase(18, 6402373705728000)]
-        [TestCase(10, 3628800)]
-        public static void GetsFactorial(int input, long expected)
+        [TestCase(0, "1")]
+        [TestCase(1, "1")]
+        [TestCase(4, "24")]
+        [TestCase(10, "3628800")]
+        [TestCase(18, "6402373705728000")]
+        public static void GetsFactorial(int input, string expected)
         {
             // Arrange
+            BigInteger expectedBigInt = BigInteger.Parse(expected);
 
             // Act
             var result = Factorial.Calculate(input);
 
             // Assert
-            Assert.AreEqual(expected, result);
+            Assert.AreEqual(expectedBigInt, result);
         }
 
-        [Test]
-        public static void GetsFactorialExceptionForNonPositiveNumbers(
-            [Random(-1000, -1, 10, Distinct = true)]
-            int input)
+        [TestCase(-5)]
+        [TestCase(-10)]
+        public static void GetsFactorialExceptionForNegativeNumbers(int num)
         {
             // Arrange
 
             // Act
-            void Act() => Factorial.Calculate(input);
+            void Act() => Factorial.Calculate(num);
 
             // Assert
-
             _ = Assert.Throws<ArgumentException>(Act);
         }
     }

Algorithms.Tests/Strings/PermutationTests.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 using Algorithms.Numeric;
 using Algorithms.Strings;
-using FluentAssertions;
 using NUnit.Framework;
 
 namespace Algorithms.Tests.Strings
@@ -48,7 +48,7 @@ public void Test_GetEveryUniquePermutation(string word)
             {
                 return current / Factorial.Calculate(keyValuePair.Value);
             });
-            Assert.AreEqual(expectedNumberOfAnagrams, permutations.Count);
+            Assert.AreEqual(expectedNumberOfAnagrams, new BigInteger(permutations.Count));
             // End 1.
 
             // Start 2

Algorithms/Numeric/Factorial.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Numerics;
 
 namespace Algorithms.Numeric
 {
@@ -9,18 +10,30 @@ namespace Algorithms.Numeric
     public static class Factorial
     {
         /// <summary>
-        ///     Calculates factorial of a number.
+        ///     Calculates factorial of a integer number.
         /// </summary>
-        /// <param name="num">Input number.</param>
-        /// <returns>Factorial of input number.</returns>
-        public static long Calculate(int num)
+        /// <param name="inputNum">Integer Input number.</param>
+        /// <returns>Factorial of integer input number.</returns>
+        public static BigInteger Calculate(int inputNum)
         {
-            if (num < 0)
+            // Convert integer input to BigInteger
+            BigInteger num = new BigInteger(inputNum);
+
+            // Don't calculate factorial if input is a negative number.
+            if (BigInteger.Compare(num, BigInteger.Zero) < 0)
             {
                 throw new ArgumentException("Only for num >= 0");
             }
 
-            return num == 0 ? 1 : num * Calculate(num - 1);
+            // Factorial of numbers greater than 0.
+            BigInteger result = BigInteger.One;
+
+            for (BigInteger i = BigInteger.One; BigInteger.Compare(i, num) <= 0; i = BigInteger.Add(i, BigInteger.One))
+            {
+                result = BigInteger.Multiply(result, i);
+            }
+
+            return result;
         }
     }
 }

Algorithms/Numeric/Series/Maclaurin.cs

@@ -117,7 +117,7 @@ private static double ErrorTermWrapper(double x, double error, Func<double, int,
         /// <param name="x">Given point.</param>
         /// <param name="i">Term index from 0 to n.</param>
         /// <returns>Single term value.</returns>
-        private static double ExpTerm(double x, int i) => Math.Pow(x, i) / Factorial.Calculate(i);
+        private static double ExpTerm(double x, int i) => Math.Pow(x, i) / (long)Factorial.Calculate(i);
 
         /// <summary>
         ///     Single term for sin(x) function approximation: (-1)^i * x^(2*i + 1) / (2*i + 1)!.
@@ -126,7 +126,7 @@ private static double ErrorTermWrapper(double x, double error, Func<double, int,
         /// <param name="i">Term index from 0 to n.</param>
         /// <returns>Single term value.</returns>
         private static double SinTerm(double x, int i) =>
-            Math.Pow(-1, i) / Factorial.Calculate(2 * i + 1) * Math.Pow(x, 2 * i + 1);
+            Math.Pow(-1, i) / ((long)Factorial.Calculate(2 * i + 1)) * Math.Pow(x, 2 * i + 1);
 
         /// <summary>
         ///     Single term for cos(x) function approximation: (-1)^i * x^(2*i) / (2*i)!.
@@ -135,6 +135,6 @@ private static double SinTerm(double x, int i) =>
         /// <param name="i">Term index from 0 to n.</param>
         /// <returns>Single term value.</returns>
         private static double CosTerm(double x, int i) =>
-            Math.Pow(-1, i) / Factorial.Calculate(2 * i) * Math.Pow(x, 2 * i);
+            Math.Pow(-1, i) / ((long)Factorial.Calculate(2 * i)) * Math.Pow(x, 2 * i);
     }
 }