A BigNumber Class Done in C#

BigNumber

#region Trig Functions

       public BigNumber Acos(int places)
       {
           BigNumber val = ArcCosUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Round(val, res, places);
           return res;
       }

       public BigNumber Asin(int places)
       {
           BigNumber val = ArcSinUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Round(val, res, places);
           return res;
       }

       public BigNumber Atan()
       {
           BigNumber val = ArcTanUsingTaylorSeries(this, numDefaultPlaces);
           BigNumber res = 0;
           Round(val, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Atan(int places)
       {
           BigNumber val = ArcTanUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Round(val, res, places);
           return res;
       }

       public BigNumber Cos()
       {
           BigNumber val = CosUsingTaylorSeries(this, numDefaultPlaces);
           BigNumber res = 0;
           Round(val, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Cos(int places)
       {
           BigNumber val = CosUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Round(val, res, places);
           return res;
       }

       public BigNumber Cot()
       {
           BigNumber val = TanUsingTaylorSeries(this, numDefaultPlaces);
           BigNumber res = 0;
           Round(val, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Cot(int places)
       {
           BigNumber val = CotUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Round(val, res, places);
           return res;
       }

       public BigNumber Csc()
       {
           BigNumber sin = SinUsingTaylorSeries(this, numDefaultPlaces);
           BigNumber res = 0;
           Div(One, sin, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Csc(int places)
       {
           BigNumber sin = SinUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Div(One, sin, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Sec()
       {
           BigNumber cos = CosUsingTaylorSeries(this, numDefaultPlaces);
           BigNumber res = 0;
           Div(One, cos, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Sec(int places)
       {
           BigNumber cos = CosUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Div(One, cos, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Sin()
       {
           BigNumber val = SinUsingTaylorSeries(this, numDefaultPlaces);
           BigNumber res = 0;
           Round(val, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Sin(int places)
       {
           BigNumber val = SinUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Round(val, res, places);
           return res;
       }

       public BigNumber Tan()
       {
           BigNumber val = TanUsingTaylorSeries(this, numDefaultPlaces);
           BigNumber res = 0;
           Round(val, res, numDefaultPlaces);
           return res;
       }

       public BigNumber Tan(int places)
       {
           BigNumber val = TanUsingTaylorSeries(this, places);
           BigNumber res = 0;
           Round(val, res, places);
           return res;
       }

       #endregion Trig Functions

namespace BigNumbers
{
    /// <summary>
    /// This class adds trig functions for the Big Number
    /// Sin
    /// Cos
    /// 
    /// </summary>
    public partial class BigNumber
    {
        // ReSharper disable once StaticFieldInitializersReferesToFieldBelow
        private static readonly BigNumber c2Pi = BN_PI * 2.0;
        private static readonly BigNumber cPiOver2 = BN_PI / 2.0;

        /// <summary>
        /// Solves the sine trigonometric function that is equal to the ratio of the side opposite a given angle 
        /// (in a right triangle) to the hypotenuse using the Taylor series.
        /// </summary>
        /// <param name="radian">The radian.</param>
        /// <param name="places">The number of decimal places.</param>
        /// <remarks> 
        ///                   x^3      x^5      x^7      x^9     x^11     x^13 
        /// sin(x) = (x)  -  ----  +  ----  -  ----  +  ----  -  ----  +  ----  ..... 
        ///                   3!       5!       7!       9!       11!      13!
        /// Where x is in radians. 
        /// </remarks>
        public static BigNumber SinUsingTaylorSeries(BigNumber radian, int places)
        {
            radian = CorrectRadian(radian, places);
            BigNumber result = radian;
            BigNumber factorialResult = 3.0 * 2.0;
            int factorial = 4;
            BigNumber doubleRadian = radian * radian;
            BigNumber multiple = radian * doubleRadian;
            BigNumber prevResult = 0;
            var divResult = new BigNumber();
            multiple = multiple.Neg();
            int counter = (int)(places * 5);
            for (int i = 0; i < counter; i++)
            {
                //result += multiple / factorialResult;
                Div(multiple, factorialResult, divResult, places);
                result += divResult;

                multiple *= doubleRadian.Neg();

                int tmp = (factorial + 1) * factorial;
                factorialResult *= tmp;
                factorial += 2;

                BigNumber tmpResult = result.Round(places);
                if (prevResult == tmpResult)
                    break;
                prevResult = tmpResult;
            }

            return result;
        }

        /// <summary>
        /// The cosine trigonometric function that is equal to the ratio of the side adjacent to an acute angle (in a right-angled triangle) to the hypotenuse.
        /// </summary>
        /// <param name="radian">The radian.</param>
        /// <param name="places">The number of decimal places.</param>
        /// <remarks> 
        ///                 x^2      x^4      x^6      x^8     x^10     x^12 
        /// cos(x) = 1  -  ----  +  ----  -  ----  +  ----  -  ----  +  ----  ..... 
        ///                 2!       4!       6!       8!       10!      12!
        /// Where x is in radians. 
        /// </remarks>
        public static BigNumber CosUsingTaylorSeries(BigNumber radian, int places)
        {
            radian = CorrectRadian(radian, places);
            BigNumber result = 1;
            BigNumber factorialResult = 2.0;
            int factorial = 3;
            BigNumber doubleRadian = radian * radian;
            BigNumber multiple = doubleRadian;
            multiple = multiple.Neg();
            var divResult = new BigNumber();
            BigNumber prevResult = 0;
            int counter = (int)(places * 5);
            for (int i = 0; i < counter; i++)
            {
                //result += multiple / factorialResult;

                Div(multiple, factorialResult, divResult, places);
                result += divResult;

                multiple *= doubleRadian.Neg();

                int tmp = (factorial + 1) * factorial;
                factorialResult *= tmp;
                factorial += 2;

                BigNumber tmpResult = result.Round(places);
                if (prevResult == tmpResult)
                    break;
                prevResult = tmpResult;
            }

            return result;
        }

        /// <summary>
        /// In a right triangle, the tangent of an angle is the length of the opposite side divided by the length of the adjacent side.
        /// </summary>
        /// <param name="radian">The radian.</param>
        /// <param name="places">The number of decimal places.</param>
        /// <remarks> 
        ///          sin(x)
        /// tan(x) = ------ 
        ///          cos(x) 
        /// Where x is in radians. 
        /// </remarks>
        public static BigNumber TanUsingTaylorSeries(BigNumber radian, int places)
        {
            radian = CorrectRadian(radian, places);

            BigNumber result = 0;
            BigNumber doubleRadian = radian * radian;
            BigNumber prevCosResult = 0;
            BigNumber prevSinResult = 0;

            BigNumber cosResult = 1;
            BigNumber cosFactorialResult = 2.0;
            int factorial = 3;
            BigNumber cosMultiple = doubleRadian;
            cosMultiple = cosMultiple.Neg();

            BigNumber sinResult = radian;
            BigNumber sinFactorialResult = 3.0 * 2.0;
            BigNumber sinMultiple = radian * doubleRadian;

            var divResult = new BigNumber();

            sinMultiple = sinMultiple.Neg();
            int counter = (int)(places * 5);
            for (int i = 0; i < counter; i++)
            {
                //sinResult += sinMultiple / sinFactorialResult;
                //cosResult += cosMultiple / cosFactorialResult;

                Div(sinMultiple, sinFactorialResult, divResult, places);
                sinResult += divResult;

                Div(cosMultiple, cosFactorialResult, divResult, places);
                cosResult += divResult;

                BigNumber negDoubleRadian = doubleRadian.Neg();
                sinMultiple *= negDoubleRadian;
                cosMultiple *= negDoubleRadian;

                int factPlusOne = factorial + 1;
                int factPlusTwo = factPlusOne + 1;
                int cosTmp = factPlusOne * factorial;
                cosFactorialResult *= cosTmp;

                int sinTmp = factPlusTwo * factPlusOne;
                sinFactorialResult *= sinTmp;

                factorial += 2;

                BigNumber tmpCosResult = cosResult.Round(100);
                BigNumber tmpSinResult = sinResult.Round(100);

                if (tmpCosResult == 0)
                    break;

                if ((prevSinResult == tmpSinResult) && (prevCosResult == tmpCosResult))
                    break;

                prevCosResult = tmpCosResult;
                prevSinResult = tmpSinResult;
            }


            Div(sinResult, cosResult, result, places);

            return result;
        }

        /// <summary>
        /// The cotangent trigonometric function ... solved using Taylor series.
        /// </summary>
        /// <param name="radian">The radian.</param>
        /// <param name="places">The number of decimal places.</param>
        /// <remarks>
        ///              1       cos(x)
        /// cot(x) =  ------  =  ------
        ///           tan(x)     sin(x)
        /// Where x is in radians. 
        /// </remarks>
        public static BigNumber CotUsingTaylorSeries(BigNumber radian, int places)
        {
            radian = CorrectRadian(radian, places);

            BigNumber result = 0;
            BigNumber doubleRadian = radian * radian;
            BigNumber prevCosResult = 0;
            BigNumber prevSinResult = 0;

            BigNumber cosResult = 1;
            BigNumber cosFactorialResult = 2.0;
            int factorial = 3;
            BigNumber cosMultiple = doubleRadian;
            cosMultiple = cosMultiple.Neg();

            BigNumber sinResult = radian;
            BigNumber sinFactorialResult = 3.0 * 2.0;
            BigNumber sinMultiple = radian * doubleRadian;

            var divResult = new BigNumber();

            int counter = (int)(places * 5);
            sinMultiple = sinMultiple.Neg();
            for (int i = 0; i < counter; i++)
            {
                //sinResult += sinMultiple / sinFactorialResult;
                //cosResult += cosMultiple / cosFactorialResult;

                Div(sinMultiple, sinFactorialResult, divResult, places);
                sinResult += divResult;

                Div(cosMultiple, cosFactorialResult, divResult, places);
                cosResult += divResult;

                BigNumber negDoubleRadian = doubleRadian.Neg();
                sinMultiple *= negDoubleRadian;
                cosMultiple *= negDoubleRadian;

                int factPlusOne = factorial + 1;
                int factPlusTwo = factPlusOne + 1;
                int cosTmp = factPlusOne * factorial;
                cosFactorialResult *= cosTmp;

                int sinTmp = factPlusTwo * factPlusOne;
                sinFactorialResult *= sinTmp;

                factorial += 2;

                BigNumber tmpCosResult = cosResult.Round(100);
                BigNumber tmpSinResult = sinResult.Round(100);

                if (tmpCosResult == 0)
                    break;

                if ((prevSinResult == tmpSinResult) && (prevCosResult == tmpCosResult))
                    break;

                prevCosResult = tmpCosResult;
                prevSinResult = tmpSinResult;
            }


            Div(cosResult, sinResult, result, places);

            return result;
        }

        /// <summary>
        /// Solves the arcsine function which is the inverse of the tangent function by using the Taylor series.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <param name="places">The number of decimal places.</param>
        /// <remarks>
        ///                   1 * x^3     1*3 * x^5       1*3*5 * x^7     1*3*5*7 * x^9     
        /// sin^-1(x) = x  +  -------  +  -----------  +  -----------  +  -------------    ..... 
        ///                   2 *  3      2*4 *  5        2*4*6    7      2*4*6*8 *  9      
        /// Where x >= -1 and x <= 1 
        ///  </remarks>
        public static BigNumber ArcSinUsingTaylorSeries(BigNumber value, int places)
        {

            bool isNegative = value < 0;
            if (isNegative)
                value = value.Neg();

            bool useInverseValue = value > 1;
            if (useInverseValue)
            {
                BigNumber tmp = 0;
                Div(One, value, tmp, SignificantDigits(value));
                value = tmp;
            }

            BigNumber prevResult = 0;
            int c = 1;
            BigNumber abRatio = (BigNumber)0.5m;
            int n = 3;
            BigNumber doubleValue = value * value;
            BigNumber multiple = value * doubleValue;

            var tmpA = new BigNumber();
            var tmpB = new BigNumber();
            Mul(abRatio, multiple, tmpA);
            Div(tmpA, n, tmpB, places);
            BigNumber result = value + tmpB;

            int counter = (int)(places * 10);
            //BigNumber result = value + abRatio * (multiple / n);

            for (int i = 0; i < counter; i++)
            {
                c += 2;
                n += 2;
                var tmp1 = new BigNumber();
                var tmp2 = new BigNumber();
                Div(c, (1 + c), tmp1, places);
                Mul(abRatio, tmp1, tmp2);
                abRatio = tmp2;
                var tmp3 = new BigNumber();
                Mul(multiple, doubleValue, tmp3);
                multiple = tmp3;
                var tmp4 = new BigNumber();
                var tmp5 = new BigNumber();
                Mul(abRatio, multiple, tmp4);
                Div(tmp4, n, tmp5, places);
                result += tmp5;

                result = result.Round(places);

                if (result == prevResult)
                    break;

                prevResult = result;
            }

            if (isNegative)
                result = result.Neg();

            return result;
        }

        /// <remarks>
        ///             pi           1 * x^3     1*3 * x^5       1*3*5 * x^7     1*3*5*7 * x^9     
        /// cos^-1(x) = --  - (x  +  -------  +  -----------  +  -----------  +  -------------    ..... )
        ///              2           2 *  3      2*4 *  5        2*4*6    7      2*4*6*8 *  9      
        /// Where x >= -1 and x <= 1 
        ///  </remarks>
        public static BigNumber ArcCosUsingTaylorSeries(BigNumber value, int places)
        {
            return cPiOver2 - ArcSinUsingTaylorSeries(value, places);
        }

        /// <summary>
        /// Solves the arctangent function which is the inverse of the tangent function by using the Taylor series.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <param name="places">The number of decimal places.</param>
        /// <remarks>
        ///                   x^3     x^5     x^7     x^9     x^11     x^13  
        /// tan^-1(x) = x  -  ---  +  ---  -  ---  +  ---  -  ----  +  ----  ..... 
        ///                    3       5       7       9       11       13
        /// Where x >= -1 and x <= 1 
        ///  </remarks>
        public static BigNumber ArcTanUsingTaylorSeries(BigNumber value, int places)
        {

            bool isNegative = value < 0;
            if (isNegative)
                value = value.Neg();

            bool useInverseValue = value > 1;
            if (useInverseValue)
            {
                BigNumber tmp = 0;
                Div(One, value, tmp, SignificantDigits(value));
                value = tmp;
            }

            BigNumber prevResult = 0;
            BigNumber result = value;
            int factorial = 3;
            BigNumber doubleValue = value * value;
            BigNumber multiple = value.Neg() * doubleValue;

            int counter = (int)(places * 5);
            var divResult = new BigNumber();
            for (int i = 0; i < counter; i++)
            {
                BigNumber factorialResult = factorial;

                Div(multiple, factorialResult, divResult, places);
                result += divResult;

                multiple *= doubleValue.Neg();
                factorial += 2;

                BigNumber tmpResult = result.Round(places);
                if (tmpResult == prevResult)
                    break;
                prevResult = tmpResult;
            }

            if (useInverseValue)
            {
                Div(BN_PI, Two, divResult, places);
                result = divResult - result;
            }

            if (isNegative)
                result = result.Neg();

            return result;
        }

        #region Private Methods

        public static BigNumber CorrectRadian(BigNumber radian, int places)
        {

            if ((radian < 0) || (radian > c2Pi))
            {
                var tmp = radian / c2Pi;
                var wholePart = tmp.Floor();
                var fracPart = tmp - wholePart;
                radian = fracPart * c2Pi;
                radian = radian.Round(places);
            }

            return radian;
        }

        #endregion Private Methods
    }
}