MA.Limits.LimitsDomain.PowerFunction.ToTaylorExpansion C# (CSharp) Method

        public IEnumerable<Summand> ToTaylorExpansion(int n)
        {
            var gcd = MathHelper.GreatestCommonDivisor(PowerNumerator, PowerDenominator);
            var powerNumerator = PowerNumerator /= gcd;
            var powerDenominator = PowerDenominator /= gcd;

            if (powerDenominator == 1)
            {
                return DomainHelper.RaiseLineToPowerWithBinomialExpansion(Aparam, Bparam, powerNumerator);
            }

            if (MathHelper.IsZero(Bparam))
            {
                var aPowered = MathHelper.Power(Aparam, powerNumerator, powerDenominator);

                if (double.IsNaN(aPowered))
                {
                    throw new LimitDoesNotExistException();
                }

                return new List<Summand>
                {
                    new Summand
                    {
                        Coefficient = aPowered,
                        PolynomialDegree = powerNumerator,
                        PolynomialDegreeDenominator = powerDenominator
                    }
                };
            }

            var bPowered = MathHelper.Power(Bparam, powerNumerator, powerDenominator);

            if (double.IsNaN(bPowered))
            {
                throw new LimitDoesNotExistException();
            }

            return Enumerable.Range(0, n + 1)
                              .Select(i =>
                                  //DomainHelper.RaiseLineToPowerWithBinomialExpansion(Aparam, Bparam - 1, i).Select(s => new Summand
                                  //{
                                  //    PolynomialDegree = s.PolynomialDegree,
                                  //    //Coefficient = s.Coefficient * Enumerable.Range(0, i).Select(x => (double)x).Aggregate(1.0, (product, next) => product * (Power - next)) / MathHelper.Factorial(i)
                                  //    Coefficient = s.Coefficient * Product(i) / MathHelper.Factorial(i)
                                  //}))
                                  new Summand
                                  {
                                    PolynomialDegree = i,
                                    Coefficient = bPowered * Product(i, powerNumerator / (double)powerDenominator) * MathHelper.FastPow(Aparam / Bparam, i) / MathHelper.Factorial(i)
                                  })
                              .Concat(new[] { new Summand { LittleODegree = n, Coefficient = 1.0 } });
        }

        public void ToTaylorExpansion_2()
        {
            var power = new PowerFunction { Aparam = 2, Bparam = 3, PowerNumerator = 1, PowerDenominator = 2 };
            var expansion = power.ToTaylorExpansion(2).ToList();

            expansion.Should().HaveCount(4);

            expansion.Select(s => s.PolynomialDegree).Should().ContainInOrder(0, 1, 2, 0);
            expansion.Select(s => s.LittleODegree).Should().ContainInOrder(0, 0, 0, 2);
            expansion.Select(s => s.Coefficient).Should().ContainInOrder(Math.Pow(3, 0.5), Math.Pow(3, 0.5) * 1.0 / 3.0, Math.Pow(3, 0.5) * -1.0 / 18.0, 1.0);
        }