public void TestFibonacciBigIntegerEqualsFibonacciInt()
        {
            for (int n = 0; n < 10; n++)
            {
                // arrange
                int        fibonacci0 = BigIntegerMathLib.Fibonacci0(n);
                BigInteger fibonacci1 = BigIntegerMathLib.Fibonacci1(n);

                // assert
                Assert.AreEqual((BigInteger)fibonacci0, fibonacci1);
            }
        }
        public void DebugFibonacci()
        {
            for (int n = 0; n < 10; n++)
            {
                BigInteger result0 = BigIntegerMathLib.Fibonacci0(n);
                BigInteger result1 = BigIntegerMathLib.Fibonacci1(n);
                BigInteger result2 = BigIntegerMathLib.Fibonacci2(n);

                string message = string.Format("{0},  {1},  {2},  {3}", n, result0, result1, result2);
                Debug.WriteLine(message);
            }
        }
        public void TestFactorialOfOneIsOne()
        {
            // act
            BigInteger result1 = BigIntegerMathLib.Factorial1(1);
            BigInteger result2 = BigIntegerMathLib.Factorial2(1);

            // assert
            BigInteger one = 1;

            Assert.AreEqual(one, result1);
            Assert.AreEqual(one, result2);
        }
        public void TestBothVersionsOfFactorialAreEqual()
        {
            for (BigInteger n = 0; n < 100; n++)
            {
                // act
                BigInteger factorial1 = BigIntegerMathLib.Factorial1(n);
                BigInteger factorial2 = BigIntegerMathLib.Factorial2(n);

                // assert
                Assert.AreEqual(factorial1, factorial2);
            }
        }
        public void TestFibonacciOfOneIsOne()
        {
            // act
            BigInteger result1 = BigIntegerMathLib.Fibonacci1(1);
            BigInteger result2 = BigIntegerMathLib.Fibonacci2(1);

            // assert
            BigInteger one = 1;

            Assert.AreEqual(one, result1);
            Assert.AreEqual(one, result2);
        }
        public void TestFibonacciOfZeroIsZero()
        {
            // act
            BigInteger result1 = BigIntegerMathLib.Fibonacci1(0);
            BigInteger result2 = BigIntegerMathLib.Fibonacci2(0);

            // assert
            BigInteger zero = 0;

            Assert.AreEqual(zero, result1);
            Assert.AreEqual(zero, result2);
        }
        public void TestBothVersionsOfFibonacciAreEqual()
        {
            for (BigInteger n = 0; n < 10; n++)
            {
                // arrange
                BigInteger fibonacci1 = BigIntegerMathLib.Fibonacci1(n);
                BigInteger fibonacci2 = BigIntegerMathLib.Fibonacci2(n);

                // assert
                Assert.AreEqual(fibonacci1, fibonacci2);
            }
        }
        public void TestFactorialBigIntegerEqualsFactorialInt()
        {
            for (int n = 0; n < 10; n++)
            {
                // act
                int        factorial0 = BigIntegerMathLib.Factorial0(n);
                BigInteger factorial1 = BigIntegerMathLib.Factorial1(n);

                // assert
                Assert.AreEqual((BigInteger)factorial0, factorial1);
                Assert.AreEqual(factorial0, (int)factorial1);
            }
        }
예제 #9
0
        static void Main()
        {
            BigInteger factorial1000 = BigIntegerMathLib.Factorial2(1000);
            BigInteger fibonacci1000 = BigIntegerMathLib.Fibonacci2(1000);

            string message1 = string.Format("\nFactorial(1000) = \n{0}", factorial1000);

            Console.WriteLine(message1);

            string message2 = string.Format("\nFibonacci(1000) = \n{0}", fibonacci1000);

            Console.WriteLine(message2);

            const string file     = "FactorialAndFibonacci.txt";
            string       contents = string.Format("{0}{1}", message1, message2);

            File.WriteAllText(file, contents);

            Console.ReadKey();
        }
 public void TestFactorial2OfNegativeNumberThrowsArgumentException()
 {
     // assert
     Assert.That(() => BigIntegerMathLib.Factorial2(-1), Throws.TypeOf <ArgumentException>());
 }
 public void TestFibonacci11OfNegativeNumberThrowsArgumentException()
 {
     // assert
     Assert.That(() => BigIntegerMathLib.Fibonacci1(-1), Throws.TypeOf <ArgumentException>());
 }