Пример #1
0
        public void LogIntegrateTest()
        {
            (MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Log, 1, 2);

            MultiPrecision <Pow2.N4> expected = 2 * MultiPrecision <Pow2.N4> .Log(2) - 1;

            Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
        }
        public void LogDiffTest()
        {
            (MultiPrecision <Pow2.N4> actual, MultiPrecision <Pow2.N4> error) = MultiPrecisionUtil.FiniteDifference <Pow2.N4>(MultiPrecision <Pow2.N4> .Log, 1);

            MultiPrecision <Pow2.N4> expected = 1;

            Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 16));
        }
Пример #3
0
        public void ZeroIntegrateTest()
        {
            (MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Cube, -1, 1);

            MultiPrecision <Pow2.N4> expected = 0;

            Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
        }
Пример #4
0
        public void PolyIntegrateTest()
        {
            (MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Square, 0, 1);

            MultiPrecision <Pow2.N4> expected = MultiPrecision <Pow2.N4> .One / 3;

            Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
        }
Пример #5
0
        public void SinIntegrateTest()
        {
            (MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .SinPI, 0, 1);

            MultiPrecision <Pow2.N4> expected = 2 / MultiPrecision <Pow2.N4> .PI;

            Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
        }
Пример #6
0
        public void ExpIntegrateTest()
        {
            (MultiPrecision <Pow2.N4> actual, _) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Exp, 1, 2);

            MultiPrecision <Pow2.N4> expected = MultiPrecision <Pow2.N4> .E * (MultiPrecision <Pow2.N4> .E - 1);

            Assert.IsTrue(MultiPrecision <Pow2.N4> .NearlyEqualBits(expected, actual, 1));
        }
Пример #7
0
        static void Main(string[] args)
        {
            //MultiPrecisionUtil.RichardsonExtrapolation<Pow2.N4>.R(5);

            //MultiPrecisionUtil.RichardsonExtrapolation<Pow2.N4> extrapolation = new();
            //
            //extrapolation.Append(1 / 2m);
            //extrapolation.Append(17 / 64m);
            //extrapolation.Append(197 / 1024m);

            (var value, var error) = MultiPrecisionUtil.RombergIntegrate <Pow2.N4>(MultiPrecision <Pow2.N4> .Log, 1, 2);

            Console.WriteLine("END");
            Console.Read();
        }
Пример #8
0
        public void NewtonRaphsonRootFindingTest()
        {
            MultiPrecision <Pow2.N8> f(MultiPrecision <Pow2.N8> x)
            {
                return(x * x * x - 2);
            }

            MultiPrecision <Pow2.N8> df(MultiPrecision <Pow2.N8> x)
            {
                return(3 * x * x);
            }

            MultiPrecision <Pow2.N8> y = MultiPrecisionUtil.NewtonRaphsonRootFinding <Pow2.N8>(2, f, df);

            Assert.IsTrue(MultiPrecision <Pow2.N8> .NearlyEqualBits(y, MultiPrecision <Pow2.N8> .Cbrt(2), 1));
        }
Пример #9
0
        public void HalleyRootFindingTest()
        {
            MultiPrecision <Pow2.N8> f(MultiPrecision <Pow2.N8> x)
            {
                return(x * x * x - 2);
            }

            (MultiPrecision <Pow2.N8> d1, MultiPrecision <Pow2.N8> d2) df(MultiPrecision <Pow2.N8> x)
            {
                return(3 * x * x, 6 * x);
            }

            MultiPrecision <Pow2.N8> y = MultiPrecisionUtil.HalleyRootFinding <Pow2.N8>(2, f, df);

            Assert.IsTrue(MultiPrecision <Pow2.N8> .NearlyEqualBits(y, MultiPrecision <Pow2.N8> .Cbrt(2), 1));
        }
Пример #10
0
        private static MultiPrecision <N> InverseErfcRootFinding(MultiPrecision <N> x)
        {
            MultiPrecision <N> s = 2 / Sqrt(PI);

            MultiPrecision <N> z0;

            if (Length <= 4)
            {
                const double a = 0.147;

                MultiPrecision <Pow2.N4> xl4 = x.Convert <Pow2.N4>();
                MultiPrecision <Pow2.N4> lg  = MultiPrecision <Pow2.N4> .Log((2 - xl4) *xl4);

                MultiPrecision <Pow2.N4> lga = 2 / (MultiPrecision <Pow2.N4> .PI * a) + lg / 2;

                z0 = MultiPrecision <Pow2.N4> .Sqrt(MultiPrecision <Pow2.N4> .Sqrt(lga *lga - lg / a) - lga).Convert <N>();
            }
            else
            {
                z0 = MultiPrecision <Pow2.N4> .InverseErfcRootFinding(x.Convert <Pow2.N4>()).Convert <N>();
            }

            MultiPrecision <N> erfc(MultiPrecision <N> z)
            {
                return(Erfc(z) - x);
            };
            (MultiPrecision <N>, MultiPrecision <N>) derfc(MultiPrecision <N> z)
            {
                MultiPrecision <N> d1 = -Exp(-z * z) * s;
                MultiPrecision <N> d2 = -2 * z * d1;

                return(d1, d2);
            };

            MultiPrecision <N> y = MultiPrecisionUtil.HalleyRootFinding(z0, erfc, derfc, break_overshoot: true);

            return(y);
        }