示例#1
0
        public void EvalTestOneArray()
        {
            double[]   b0Values = { 0.0, 1.0 };
            double[][] bValues  =
            {
                new double[] {     },
                new double[] { 2.0 },
                new double[] {2.0, 2.0 },
                new double[] {2.0, 2.0, 2.0 },
                new double[] {2.0, 2.0, 2.0, 2.0 }
            };

            foreach (double b0 in b0Values)
            {
                for (int i = 0; i < b0Values.Length; i++)
                {
                    double[]      b        = bValues[i];
                    TestFraction1 f        = _Fractions1[i];
                    double        result   = ContinuedFraction.Eval(b0, 1.0, b);
                    double        expected = f.EquivalentFunction(b0, b);

                    Assert2.AreNear(expected, result, 2);
                }
            }
        }
示例#2
0
        public void EvalTestInfinite()
        {
            double expected, actual;

            expected = 1.0 / (Math.Sqrt(Math.E) - 1.0);
            // actual = ContinuedFraction.Eval(1.0, Series1(),tolerance,100);
            actual = ContinuedFraction.Eval(1.0, Series1());
            Assert2.AreNear(expected, actual, 10);

            expected = 1.0 / (Math.E - 1.0);
            // actual = ContinuedFraction.Eval(0.0, Series2(),tolerance,100);
            actual = ContinuedFraction.Eval(0.0, Series2());
            Assert2.AreNear(expected, actual, 10);
        }
示例#3
0
        public void EvalTestInfiniteF()
        {
            double expected, actual;

            Series1Function f1 = new Series1Function();

            expected = 1.0 / (Math.Sqrt(Math.E) - 1.0);
            // actual = ContinuedFraction.Eval(1.0, Series1(),tolerance,100);
            actual = ContinuedFraction.Eval(1.0, f1.Next);
            Assert2.AreNear(expected, actual, 10);

            Series2Function f2 = new Series2Function();

            expected = 1.0 / (Math.E - 1.0);
            // actual = ContinuedFraction.Eval(0.0, Series2(),tolerance,100);
            actual = ContinuedFraction.Eval(0.0, f2.Next);
            Assert2.AreNear(expected, actual, 10);
        }
示例#4
0
        public void EvalTestTwoArray()
        {
            double[] b0Values = { 0.0, 1.0 };

            Tuple <double[], double[]>[] abValues =
            {
                new Tuple <double[],                                                 double[]>(new double[] {     },
                                                                                               new double[] { }),
                new Tuple <double[],                                                 double[]>(new double[] { 1.0 },
                                                                                               new double[] { 2.0 }),
                new Tuple <double[],                                                 double[]>(new double[] {1.0, 1.0 },
                                                                                               new double[] { 2.0,                                                 2.0 }),
                new Tuple <double[],                                                 double[]>(new double[] {1.0, 1.0, 1.0 },
                                                                                               new double[] { 2.0,                                                 2.0, 2.0 }),
                new Tuple <double[],                                                 double[]>(new double[] {1.0, 1.0, 1.0 },
                                                                                               new double[] { 2.0,                                                 2.0, 2.0 }),

                // infinite series would =1/(Sqrt(e)-1)
                // Source:http://mathworld.wolfram.com/ContinuedFraction.html
                new Tuple <double[],                                                 double[]>(new double[] {2.0, 4.0, 6.0, 8.0 },
                                                                                               new double[] { 3.0,                                                 5.0, 7.0, 9.0 }),

                // infinite series would =1/(e-1)
                // Source: http://mathworld.wolfram.com/ContinuedFraction.html
                new Tuple <double[],                                                 double[]>(new double[] {1.0, 2.0, 3.0, 4.0 },
                                                                                               new double[] { 1.0, 2.0, 3.0, 4.0 })
            };


            foreach (double b0 in b0Values)
            {
                foreach (var abValue in abValues)
                {
                    double[] a = abValue.Item1;
                    double[] b = abValue.Item2;
                    Debug.Assert(a.Length == b.Length);
                    TestFraction2 f        = _Fractions2[a.Length];
                    double        result   = ContinuedFraction.Eval(b0, a, b);
                    double        expected = f.EquivalentFunction(b0, a, b);

                    Assert2.AreNear(expected, result, 2);
                }
            }
        }