Click here to Skip to main content
15,896,359 members
Search within:


Articles / Programming Languages / C#
 

Rational Numbers - .NET 4.0 Version (Rational Computing 1)

Rate me:
Please Sign up or sign in to vote.
4.97/5 (54 votes)
22 Jul 2010CPOL21 min read 127.8K   1.2K   72  
A Rational number type providing virtually unlimited precision for .NET and Silverlight.
 
using Mathematics.RationalNumbers;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using Q = Mathematics.RationalNumbers.Rational;
using Math = Mathematics.RationalNumbers.Rational;
using System.Numerics;
using System.Diagnostics;
using System.Collections.Generic;

namespace RationalNumbers_Tests
{
    
    
    /// <summary>
    ///This is a test class for RationalTest and is intended
    ///to contain all RationalTest Unit Tests
    ///</summary>
    [TestClass()]
    public class RationalTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Gets or sets the test context which provides
        ///information about and functionality for the current test run.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for ToString
        ///</summary>
        [TestMethod()]
        public void ToStringTest()
        {
            
            
            Assert.AreEqual("0", new Rational().ToString() );
            Assert.AreEqual("33", new Rational(33).ToString());
            Assert.AreEqual("1/2", new Rational(1,2).ToString());
            Assert.AreEqual("1/2", new Rational(2, 4).ToString());
        }


        [TestMethod()]
        public void ToStringTest_Extended()
        {

            Assert.AreEqual("100", new Rational(123.4).ToString(EApproxmationType.SignificantFigures, 1, true));
            Assert.AreEqual("123.0", new Rational(123).ToString(EApproxmationType.SignificantFigures, 4, true));
            Assert.AreEqual("123", new Rational(123).ToString(EApproxmationType.SignificantFigures, 3, true));
            Assert.AreEqual("120", new Rational(123).ToString(EApproxmationType.SignificantFigures, 2, true));
            Assert.AreEqual("100", new Rational(123).ToString(EApproxmationType.SignificantFigures, 1, true));
            Assert.AreEqual("-1.33333", new Rational(-4, 3).ToString(EApproxmationType.DecimalPlaces, 5, false));
            Assert.AreEqual("1.33333", new Rational(4, 3).ToString(EApproxmationType.DecimalPlaces, 5, false));
            Assert.AreEqual("1.3333", new Rational(4, 3).ToString(EApproxmationType.SignificantFigures, 5, false));
            Assert.AreEqual("1.00", new Rational(1).ToString(EApproxmationType.DecimalPlaces, 2, true));
            Assert.AreEqual("1", new Rational(1).ToString(EApproxmationType.DecimalPlaces, 5, false));

            Assert.AreEqual("-0.2", new Rational(-1, 4).ToString( EApproxmationType.DecimalPlaces, 1, true));
          
            Assert.AreEqual("0.33333", new Rational(1, 3).ToString(EApproxmationType.DecimalPlaces, 5,false ));
            Assert.AreEqual("0.3333333333333333333333333", new Rational(1, 3).ToString( EApproxmationType.DecimalPlaces, 25, false));
            Assert.AreEqual("0.5", new Rational(1, 2).ToString( EApproxmationType.DecimalPlaces, 5, false));
            Assert.AreEqual("0.50000", new Rational(1, 2).ToString( EApproxmationType.DecimalPlaces, 5, true));
            Assert.AreEqual("0.5000", new Rational(1, 2).ToString( EApproxmationType.DecimalPlaces, 4, true));
            Assert.AreEqual("0.500", new Rational(1, 2).ToString( EApproxmationType.DecimalPlaces, 3, true));
            Assert.AreEqual("0.50", new Rational(1, 2).ToString( EApproxmationType.DecimalPlaces,2, true));
            Assert.AreEqual("0.5", new Rational(1, 2).ToString( EApproxmationType.DecimalPlaces, 1, true));

            Assert.AreEqual("0.2", new Rational(1, 4).ToString( EApproxmationType.DecimalPlaces, 1, true));
            Assert.AreEqual("0.05", new Rational(1, 20).ToString(EApproxmationType.DecimalPlaces, 1, true));
          





        }


        /// <summary>
        ///A test for op_Addition
        ///</summary>
        [TestMethod()]
        public void op_AdditionTest()
        {
            Assert.AreEqual((Q)1 / 2, (Q)1/2 + (Q)0);
            Assert.AreEqual((Q)1/2, (Q)0 + (Q)1 / 2);
            Assert.AreEqual((Q)1, (Q)1/2 + (Q)1/2);
        }

        /// <summary>
        ///A test for op_Division
        ///</summary>
        [TestMethod()]
        public void op_DivisionTest()
        {
      
            Assert.AreEqual((Q)15/8, (Q)3/4 /((Q)2/5));
            Assert.AreEqual((Q)5 , 2  / ((Q)2 / 5));
            Assert.AreEqual((Q)0 , 0 / ((Q)2 / 5));
            try
            {
                Rational r = new Rational(4) / (Q)0;
                Assert.Fail();
            }
            catch { }



            try
            {
                Rational r = new Rational(4) /  0;
                Assert.Fail();
            }
            catch { }
        

          try
            {
                Rational r =  7 / (Q) 0;
                Assert.Fail();
            }
            catch { }
        }
     

        /// <summary>
        ///A test for op_Multiply
        ///</summary>
        [TestMethod()]
        public void op_MultiplyTest()
        {
            Rational r1 = new Rational(2,5);  
            Rational r2 = new Rational(5,7);  
            Rational expected = new Rational(2,7);  
            Rational actual;
            actual = (r1 * r2);
            Assert.AreEqual(expected, actual);

            Assert.AreEqual(r1 * 2, new Rational(4, 5));
            Assert.AreEqual(2 * r1 , new Rational(4, 5));

            Assert.AreEqual(r1 * (long)2, new Rational(4, 5));
            Assert.AreEqual((long)2*r1, new Rational(4, 5));

            Assert.AreEqual((Q)0, new Rational(4, 5)*(long)0);
            Assert.AreEqual((Q)0, (long)0 * (Q) 5/6);

            Assert.AreEqual((Q)0, new Rational () * (long)23);
            Assert.AreEqual((Q)0, (long)55 * (Q)0);

            Assert.AreEqual((Q)0, new Rational(4, 5) *  0);
            Assert.AreEqual((Q)0,  0 * (Q)5 / 6);

            Assert.AreEqual((Q)0, new Rational() * (int)23);
            Assert.AreEqual((Q)0, (int)55 * (Q)0);
        }

        /// <summary>
        ///A test for op_Subtraction
        ///</summary>
        [TestMethod()]
        public void op_SubtractionTest()
        {
            Rational r1 = new Rational(3,4);  
            Rational r2 = new Rational(1,6); 
            Rational expected = new Rational(7,12);  
            Rational actual;
            actual = (r1 - r2);
            Assert.AreEqual(expected, actual);
            Assert.AreEqual((Q)1/4,  (Q)3/4-(Q)1/2)  ;
           
        }

        /// <summary>
        ///A test for op_UnaryNegation
        ///</summary>
        [TestMethod()]
        public void op_UnaryNegationTest()
        {
            Rational r = new Rational(1,2);  
            Rational expected = new Rational(-1,2);  
            Rational actual;
            actual = -(r);
            Assert.AreEqual(expected, actual);

            Rational test = -(Rational)1 / 3;
            Assert.AreEqual(test , new Rational(-1, 3));
        }

      

        /// <summary>
        ///A test for op_Explicit
        ///</summary>
        [TestMethod()]
        public void op_ExplicitTest()
        {
            int value = 2; // TODO: Initialize to an appropriate value
            Rational expected = new Rational(2); // TODO: Initialize to an appropriate value
            Rational actual;
            actual = ((Q)(value));
            Assert.AreEqual(expected, actual);


            Assert.AreEqual(new Rational(1, 2), (Rational) 1 / 2);
        }





        /// <summary>
        ///A test for IntegerPart
        ///</summary>
        [TestMethod()]
        public void IntegerPartTest()
        {
            Assert.AreEqual(0, ((Rational)0).IntegerPart);
            Assert.AreEqual(2, ((Rational)7 / 3).IntegerPart );
            Assert.AreEqual(-2, (-(Rational)7 / 3).IntegerPart );
        }

        /// <summary>
        ///A test for FractionalPart
        ///</summary>
        [TestMethod()]
        public void FractionalPartTest()
        {
            
            Assert.AreEqual((Rational)1/3,((Rational)7/3).FractionalPart );
            Assert.AreEqual( -(Rational)1 / 3, (-(Rational)7 / 3).FractionalPart);
        }

        /// <summary>
        ///A test for Abs
        ///</summary>
        [TestMethod()]
        public void AbsTest()
        {
           
            Assert.AreEqual((Q)1/3, Math.Abs((Q)1/3));
            Assert.AreEqual((Q)1 / 3, Math.Abs(-(Q)1 / 3));
           
        }

        /// <summary>
        ///A test for Ceiling
        ///</summary>
        [TestMethod()]
        public void CeilingTest()
        {
            Assert.AreEqual(1, System.Math.Ceiling(.5));
            Assert.AreEqual((Q)1, Math.Ceiling((Q)1 / 2));

            Assert.AreEqual(1, System.Math.Ceiling(1.0));
            Assert.AreEqual((Q)1, Math.Ceiling((Q)1));

            Assert.AreEqual(0, System.Math.Ceiling(-.5));
            Assert.AreEqual( (Q)0, Math.Ceiling(-(Q)1 / 2));


            Assert.AreEqual((Q)2 / 3, Math.Ceiling((Q)1 / 2, 3));
            Assert.AreEqual((Q)2/3, Math.Ceiling((Q)7 / 12, 6));
            Assert.AreEqual((Q)5 / 3, Math.Ceiling((Q)19 / 12, 6));

            Assert.AreEqual((Q)2 / 3, Math.Ceiling((Q)1 / 2, (BigInteger) 3));
            Assert.AreEqual((Q)2 / 3, Math.Ceiling((Q)7 / 12, (BigInteger)6));
            Assert.AreEqual((Q)5 / 3, Math.Ceiling((Q)19 / 12, (BigInteger)6));

            Assert.AreEqual((Q)2 / 3, Math.Ceiling((Q)1 / 2, (Q)1 / 3));
            Assert.AreEqual((Q)2 / 3, Math.Ceiling((Q)7 / 12, (Q)1 / 6));
            Assert.AreEqual((Q)5 / 3, Math.Ceiling((Q)19 / 12, (Q)1 / 6));
             
        }

        /// <summary>
        ///A test for Max
        ///</summary>
        [TestMethod()]
        public void MaxTest()
        {
     
            Assert.AreEqual((Q)3/4,Math.Max((Q)3/4,(Q)1/2));
            Assert.AreEqual((Q)3/4,Math.Max((Q)1/2,(Q)3/4));
            Assert.AreEqual((Q)3 / 4, Math.Max((Q)3 / 4, (Q)3 / 4));
        }

        /// <summary>
        ///A test for Pow
        ///</summary>
        [TestMethod()]
        public void PowTest()
        {
            Assert.AreEqual((Q)1 / 4, Math.Pow((Q)1 / 2,2));
            Assert.AreEqual((Q)4, Math.Pow((Q)1 / 2, -2));
            Assert.AreEqual((Q)1, Math.Pow((Q)1 / 2, 0));
        }

        /// <summary>
        ///A test for Min
        ///</summary>
        [TestMethod()]
        public void MinTest()
        {
           
            Assert.AreEqual((Q)1/2,Math.Min((Q)3/4,(Q)1/2));
            Assert.AreEqual((Q)1/2,Math.Min((Q)1/2,(Q)3/4));
            Assert.AreEqual((Q)3 / 4, Math.Min((Q)3 / 4, (Q)3 / 4));
        }

        /// <summary>
        ///A test for Round
        ///</summary>
        [TestMethod()]
        public void RoundTest()
        {
            Assert.AreEqual(0, System.Math.Round(.5));
            Assert.AreEqual((Q)0, Math.Round((Q)1 / 2));

            Assert.AreEqual(1, System.Math.Round(1.0));
            Assert.AreEqual((Q)1, Math.Round((Q)1));
            Assert.AreEqual((Q)1, Math.Round((Q).9,(BigInteger)1));
            Assert.AreEqual((Q)1, Math.Round((Q).9, (Q)1));

            Assert.AreEqual(0, System.Math.Round(-.5));
            Assert.AreEqual((Q)0, Math.Round(-(Q)1 / 2));

            Assert.AreEqual((Q)1/2, Math.Round((Q)1 / 3,2));
            Assert.AreEqual((Q)1, Math.Round((Q)1,7));
           
        }

        /// <summary>
        ///A test for Sign
        ///</summary>
        [TestMethod()]
        public void SignTest()
        {
            Assert.AreEqual(1, Math.Sign(new Rational(1)));
            Assert.AreEqual(0, Math.Sign(new Rational(0)));
            Assert.AreEqual(-1, Math.Sign(new Rational(-1)));
        }



        /// <summary>
        ///A test for op_GreaterThanOrEqual
        ///</summary>
        [TestMethod()]
        public void op_GreaterThanOrEqualTest()
        {
            Assert.AreEqual(false, (Q)1 / 6 >= (Q)1 / 4);
            Assert.AreEqual(false, (Q)1 / 5 >= (Q)1 / 3);
            Assert.AreEqual(true, (Q)1 / 5 >= (Q)1 / 5);
            Assert.AreEqual(true, (Q)20 >= (Q)0);
            Assert.AreEqual(true, (Q)20 >= (Q)1 / 5);
            Assert.AreEqual(true, (Q)20 >= (Q)2 / 5);
            Assert.AreEqual(true, (Q)20 >= (Q)3 / 5);
            Assert.AreEqual(true, (Q)20 >= (Q)4 / 5);
            Assert.AreEqual(true, (Q)20 >= (Q)1  );

            Assert.AreEqual(false, (Q)0 >= (Q)20);
        }

        /// <summary>
        ///A test for op_GreaterThan
        ///</summary>
        [TestMethod()]
        public void op_GreaterThanTest()
        {
            Assert.AreEqual(true ,(Q)1/2 >(Q)1/4);
            Assert.AreEqual(false, (Q)1 / 5 > (Q)1 / 3);
            Assert.AreEqual(false, (Q)1 / 5 > (Q)1 / 5);
        }

        /// <summary>
        ///A test for op_LessThan
        ///</summary>
        [TestMethod()]
        public void op_LessThanTest()
        {
            Assert.AreEqual(false, (Q)1 / 4 < (Q)1 / 6);
            Assert.AreEqual(true, (Q)1 / 5 < (Q)1 / 3);
            Assert.AreEqual(false, (Q)1 / 5 < (Q)1 / 5);
        }

        /// <summary>
        ///A test for op_LessThanOrEqual
        ///</summary>
        [TestMethod()]
        public void op_LessThanOrEqualTest()
        {
            Assert.AreEqual(false, (Q)1 / 4 <= (Q)1 / 5);
            Assert.AreEqual(true, (Q)1 / 5 <= (Q)1 / 3);
            Assert.AreEqual(true, (Q)1 / 5 <= (Q)1 / 5);
        }

        /// <summary>
        ///A test for Floor
        ///</summary>
        [TestMethod()]
        public void FloorTest()
        {
            Assert.AreEqual( 0, System.Math.Floor(.5));
            Assert.AreEqual((Q)0, Math.Floor((Q) 1/2));

            Assert.AreEqual(1, System.Math.Floor(1.0));
            Assert.AreEqual((Q)1, Math.Floor((Q)1  ));

            Assert.AreEqual(-1, System.Math.Floor(-.5));
            Assert.AreEqual(-(Q)1, Math.Floor(-(Q)1 / 2));



            
            Assert.AreEqual((Q)1/3, Math.Floor((Q)1 / 2,3));
            Assert.AreEqual((Q)1 / 2, Math.Floor((Q)7 / 12, 6));

            Assert.AreEqual((Q)3 / 2, Math.Floor((Q)19 / 12, 6));
            Assert.AreEqual((Q)3 / 2, Math.Floor((Q)19 / 12, (BigInteger)6));

            Assert.AreEqual((Q)1 / 3, Math.Floor((Q)1 / 2,(Q)1/ 3));
            Assert.AreEqual((Q)1 / 2, Math.Floor((Q)7 / 12, (Q)1/6));

            Assert.AreEqual((Q)3 / 2, Math.Floor((Q)19 / 12, (Q)1/6));

             
        }









        /// <summary>
        ///A test for ToDouble
        ///</summary>
        [TestMethod()]
        public void ToDoubleTest()
        {
            Assert.AreEqual(-4.94065645841247E-324, new Rational(-4.94065645841247E-324).ToDouble());
            Assert.AreEqual(.9, new Rational(.9).ToDouble());
            Assert.AreEqual(.11, new Rational(.11).ToDouble());
            Assert.AreEqual(.100001, new Rational(.100001).ToDouble());


            Assert.AreEqual(.1, new Rational(.1).ToDouble());
            Assert.AreEqual(((double)1 / 30).ToString("R"), (new Rational(1, 30).ToDouble()).ToString("R"));
            Assert.AreEqual(((double)1 / 3).ToString("R"), (new Rational(1, 3).ToDouble()).ToString("R"));

            Assert.AreEqual(System.Math.PI.ToString("R"), new Rational(System.Math.PI).ToDouble().ToString("R"));


            Assert.AreEqual(10, new Rational(10).ToDouble());
            Assert.AreEqual(1, new Rational(1).ToDouble());
            Assert.AreEqual((double)500, new Rational(500, 1).ToDouble());

            Assert.AreEqual(new Rational(Double.MaxValue), -new Rational(Double.MinValue));
            Assert.AreEqual(Double.MaxValue, new Rational(Double.MaxValue).ToDouble());
            Assert.AreEqual(Double.MinValue, new Rational(Double.MinValue).ToDouble());
            Assert.AreEqual(Double.Epsilon , new Rational(Double.Epsilon).ToDouble());

            
        }

        /// <summary>
        ///A test for Parse
        ///</summary>
        [TestMethod()]
        public void ParseTest()
        {
             
            Assert.AreEqual((Q)1/3, Q.Parse("1/3"));
            Assert.AreEqual((Q)0, Q.Parse("0"));
            Assert.AreEqual((Q)12, Q.Parse("12"));
            Assert.AreEqual((Q)3/10, Q.Parse(".3"));
        }

        /// <summary>
        ///A test for Digits
        ///</summary>
        [TestMethod()]
        [DeploymentItem("RationalNumbers.dll")]
        public void DigitsTest()
        {
            Assert.AreEqual("1", String.Join("", Q.Digits((Q)1, 1)));
            Assert.AreEqual("1", String.Join("", Q.Digits((Q)1, 2)));
            Assert.AreEqual("3", String.Join("", Q.Digits((Q)1/3, 1)));
            Assert.AreEqual("1", String.Join ("", Q.Digits( (Q)123.456,1)));
            Assert.AreEqual("12", String.Join("", Q.Digits((Q)123.456, 2)));
            Assert.AreEqual("123", String.Join("", Q.Digits((Q)123.456, 3)));
            Assert.AreEqual("1234", String.Join("", Q.Digits((Q)123.456, 4)));
            Assert.AreEqual("12345", String.Join("", Q.Digits((Q)123.456, 5)));
            Assert.AreEqual("123456", String.Join("", Q.Digits((Q)123.456, 6)));
            Assert.AreEqual("123456", String.Join("", Q.Digits((Q)123.456, 7)));
            Assert.AreEqual("1", String.Join("", Q.Digits((Q)100, 1)));
            Assert.AreEqual("10", String.Join("", Q.Digits((Q)100, 2)));
        }

        /// <summary>
        ///A test for ToScientific
        ///</summary>
        [TestMethod()]
        public void ToScientificTest()
        {
            
            Assert.AreEqual("1E+0", new  Rational (1).ToScientific(1,false));
            Assert.AreEqual("1E+0", new Rational(1).ToScientific(2, false));
            Assert.AreEqual("1.0E+0", new Rational(1).ToScientific(2, true));
            Assert.AreEqual("1E-1", new Rational(1,10).ToScientific(2, false));
            Assert.AreEqual("1.2E+2", new Rational(1.2345678E+2).ToScientific(2, false));
            Assert.AreEqual("1.2345678E+2", new Rational(1.2345678E+2).ToScientific(15, false));
             Assert.AreEqual("1.2345678E-2", new Rational(1.2345678E-2).ToScientific(15, false));

         
        }

        /// <summary>
        ///A test for Magnitude
        ///</summary>
        [TestMethod()]
        public void MagnitudeTest()
        {
            Assert.AreEqual(-2, new Rational(1.2345678E-2).Magnitude );
            Assert.AreEqual(0, new Rational(1).Magnitude);
            Assert.AreEqual(1, new Rational(10).Magnitude);
            Assert.AreEqual(-1, new Rational(.1).Magnitude);
        }

        /// <summary>
        ///A test for op_Addition
        ///</summary>
        [TestMethod()]
        public void op_AdditionTest_int()
        {
  
            Assert.AreEqual((Q)3/2, 1 + (Q)1 / 2);
            Assert.AreEqual((Q)3 / 2,  (Q)1 / 2  + 1);
            Assert.AreEqual((Q)1 / 2, 0 + (Q)1 / 2);
            Assert.AreEqual((Q)1 / 2,   (Q)1 / 2 + 0);
            Assert.AreEqual((Q)5, 5 + (Q)0);
        }


        /// <summary>
        ///A test for op_Explicit
        ///</summary>
        [TestMethod()]
        public void op_ExplicitTest_ToBigInteger()
        {
            Assert.AreEqual(2, (BigInteger)(Rational)2);
            Assert.AreEqual(4999, (BigInteger)(Rational)4999);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToULong()
        {
            Assert.AreEqual((ulong)2, (ulong)(Rational)2);
            Assert.AreEqual((ulong)4999, (ulong)(Rational)4999);
        }


        [TestMethod()]
        public void op_ExplicitTest_ToLong()
        {
            Assert.AreEqual(2, (long)(Rational)2);
            Assert.AreEqual(4999, (long)(Rational)4999);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToInt()
        {
            Assert.AreEqual(2, (int)(Rational)2);
            Assert.AreEqual(4999, (int)(Rational)4999);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToUInt()
        {
            Assert.AreEqual((uint)2, (uint)(Rational)2);
            Assert.AreEqual((uint)4999, (uint)(Rational)4999);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToUshort()
        {
            Assert.AreEqual(2, (ushort)(Rational)2);
            Assert.AreEqual(4999, (ushort)(Rational)4999);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToShort()
        {
            Assert.AreEqual(2, (short)(Rational)2);
            Assert.AreEqual(4999, (short)(Rational)4999);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToByte()
        {
            Assert.AreEqual(2, (byte)(Rational)2);
            Assert.AreEqual(255, (byte)(Rational)255);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToSbyte()
        {
            Assert.AreEqual(2, (sbyte)(Rational)2);
            Assert.AreEqual(127, (sbyte)(Rational)127);
            Assert.AreEqual(-128, (sbyte)(Rational)(-128));
        }

        [TestMethod()]
        public void op_ExplicitTest_ToChar()
        {
            Assert.AreEqual(2, (char)(Rational)2);
            Assert.AreEqual(4999, (char)(Rational)4999);
        }


        [TestMethod()]
        public void op_ExplicitTest_ToSingle()
        {
            Assert.AreEqual(2F, (Single)(Rational)2F);
            Assert.AreEqual(4999F, (Single)(Rational)4999F);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToDouble()
        {
            Assert.AreEqual(2d, (Double)(Rational)2d);
            Assert.AreEqual(4999, (Double)(Rational)4999);
        }

        [TestMethod()]
        public void op_ExplicitTest_ToDecimal()
        {
            Decimal d = 123m;
            Debug.WriteLine(d.ToString());

            Assert.AreEqual(123m, (Decimal)(Rational)123m);
            Assert.AreEqual(2.3m, (Decimal)(Rational)2.3m);
            Assert.AreEqual(2m, (Decimal)(Rational)2m);
            Assert.AreEqual(4999m, (Decimal)(Rational)4999m);
        }

        /// <summary>
        ///A test for GetHashCode
        ///</summary>
        [TestMethod()]
        public void GetHashCodeTest()
        {
            
            Assert.AreEqual(399,new Rational(1,2).GetHashCode());
           
        }

        /// <summary>
        ///A test for Inverse
        ///</summary>
        [TestMethod()]
        public void InverseTest()
        {
           
            Assert.AreEqual((Q)3 / 4, new Rational(4, 3).Inverse);
            try
            {
                Assert.AreEqual(new Rational(), new Rational(0, 3).Inverse);
                Assert.Fail();
            }
            catch { }
          
        }

 
 

      

        /// <summary>
        ///A test for Equals
        ///</summary>
        [TestMethod()]
        public void EqualsTest()
        {
            Assert.IsFalse(new Rational().Equals(null));
            Assert.IsFalse(new Rational().Equals("Hello"));
        }



        /// <summary>
        ///A test for CompareTo
        ///</summary>
        [TestMethod()]
        public void CompareToTest()
        {
            Assert.AreEqual(-1, new Rational(-1,5).CompareTo(new Rational(-1,6)));
            Assert.AreEqual( 1, new Rational(-1, 6).CompareTo(new Rational(-1, 5)));

            Assert.AreEqual(1, new Rational(-1).CompareTo(new Rational(-2)));
            Assert.AreEqual(-1, new Rational(-3, 4).CompareTo(-(Q)2 / 3));
            Assert.AreEqual(1, new Rational(3,4).CompareTo((Q)2/3));
            
            Assert.AreEqual(0, new Rational(1.3).CompareTo(1.3));
            Assert.AreEqual(1, new Rational(1.3).CompareTo(1.2));
            Assert.AreEqual(-1, new Rational(1.3).CompareTo(1.4));
            Assert.AreEqual( 1, new Rational(-1.3).CompareTo(-1.4));
            Assert.AreEqual(1, new Rational(-13,10).CompareTo(-(Q)7/5));

            Assert.AreEqual(1, new Rational(3, 4).CompareTo(new Rational(2, 3)));
            Assert.AreEqual(-1, new Rational(-3, 4).CompareTo(new Rational(-2, 3)));
            Assert.AreEqual(1, new Rational(0).CompareTo(new Rational(-2)));
           
        }

        /// <summary>
        ///A test for CompareTo
        ///</summary>
        [TestMethod()]
        public void CompareToTest_Object()
        {
            object o = new Rational(4.6);
            Rational r = new Rational (4.6);
            Assert.AreEqual (0, r.CompareTo(o));
            try
            {
                Assert.AreEqual(0, r.CompareTo("stringval"));
                Assert.Fail();
            }
            catch { }
        }

        [TestMethod()]
        public void ConstructorErrorTest()
        {
            try
            {
                Rational r = new Rational(2, 0);
                Assert.Fail();
            }
            catch { }

        }

        /// <summary>
        ///A test for op_Modulus
        ///</summary>
        [TestMethod()]
        public void op_ModulusTest()
        {
            Assert.AreEqual(1,(Q)3 % (Q)2);
            Assert.AreEqual((Q)1/2, (Q)3/2 % (Q)1);
        }


        /// <summary>
        ///A test for ParseBigInteger
        ///</summary>
        [TestMethod()]
        [DeploymentItem("MathematicsCore.dll")]
        public void ParseBigIntegerTest()
        {


            Assert.AreEqual(10, Q.ParseBigInteger("10"));
            string test = "1234567890";
            Assert.AreEqual(BigInteger.Parse(test), Q.ParseBigInteger(test));
            test = "12345678901234567890";
            Assert.AreEqual(BigInteger.Parse(test), Q.ParseBigInteger(test));

            test = "-12345678901234567890";
            Assert.AreEqual(BigInteger.Parse(test), Q.ParseBigInteger(test));


        }
    }
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
KenJohnson
Software Developer (Senior)
United States United States
Written software for what seems like forever. I'm currenly infatuated with WPF. Hopefully my affections are returned.

Comments and Discussions

Permalink
Advertise
Privacy
Cookies
Terms of Use
Layout: fixed | fluid

Posted 21 Jun 2010

Article Copyright 2010 by KenJohnson
Everything else Copyright © CodeProject, 1999-2024

Web02 2.8:2024-04-02:1