Faster(?) factorial calculations I saw this question, but was unable to answer because of my inexistant knowledge of Rust, so I decided to try and write an algorithm on my own and put it for review.

There is the casual way to compute factorials:

\$n! = \prod\limits_{k=1}^n k\$

public static BigInteger fact(BigInteger n)  =&gt; n == 0 ? 1 : n*fact(n - 1);


The problem with this one is that with big factorials, it get's slow (or, in this case, throw a StackOverflowException.

Now, reading this "paper", I figured I'd try to implement a faster algorithm to compute factorials.

From what I understood, the equation would look something like this :

\$\prod\limits_{i=1}^{\frac{n}{2}}( \sum\limits_{z=0}^i (n - z\times2))((\lceil{\frac{n}{2}\rceil})\$  (if n is odd)\$)\$

The idea is to reduce the number of multiplications by half.

public static BigInteger Factorial(int n)
{
    BigInteger sum = n;
    BigInteger result = n;
    for (int i = n - 2; i &gt; 1; i -= 2)
    {
        sum = (sum + i);
        result *= sum;
    }

    if (n % 2 != 0)
        result *= (BigInteger)Math.Round((double)n / 2, MidpointRounding.AwayFromZero);

    return result;
}


I decided to keep a sum variable so I don't need to redo the sum computing at each multiplication's iteration.

I'd like to see if I missed something or if this can be optimized. (I'm doing this as a mathematical exercise, so there's no need for performance, I'm looking at ways to make it more performant just because I want to understant the maths behind it).
\$0! = 1\$, which is a case not handled by the code.

The method should throw an ArgumentOutOfRangeException if n is negative.

You could also replace this


if (n % 2 != 0)
    result *= (BigInteger)Math.Round((double)n / 2, MidpointRounding.AwayFromZero);



with this

if (n % 2 != 0)
    result *= n / 2 + 1;


if you find it clearer.