public void TestInterpolationMethod_CubicSpline_BoundarySecondDerivativeFixed() { double[] t = new double[] { -2.0, -1.0, 0.0, 1.0, 2.0 }; double[] x = new double[] { 1.0, 2.0, -1.0, 0.0, 1.0 }; IInterpolationMethod method = Interpolation.CreateCubicSpline(t, x, SplineBoundaryCondition.SecondDerivative, -5.0, SplineBoundaryCondition.SecondDerivative, -1.0); Assert.IsInstanceOfType(typeof(CubicSplineInterpolation), method, "Type"); for (int i = 0; i < t.Length; i++) { // verify the interpolated values exactly at the sample points. Assert.AreEqual(x[i], method.Interpolate(t[i]), "A Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=-2.4},Spline([[-2,1],[-1,2],[0,-1],[1,0],[2,1]], x, degree=3, endpoints=Matrix(2,13,{(1,3)=1,(1,13)=-5,(2,10)=1,(2,13)=-1}))),20);" NumericAssert.AreAlmostEqual(-.8999999999999999993, method.Interpolate(-2.4), 1e-15, "A -2.4"); NumericAssert.AreAlmostEqual(1.7590357142857142857, method.Interpolate(-0.9), 1e-15, "A -0.9"); NumericAssert.AreAlmostEqual(.41517857142857142854, method.Interpolate(-0.5), 1e-15, "A -0.5"); NumericAssert.AreAlmostEqual(-.82010714285714285714, method.Interpolate(-0.1), 1e-15, "A -0.1"); NumericAssert.AreAlmostEqual(-1.1026071428571428572, method.Interpolate(0.1), 1e-15, "A 0.1"); NumericAssert.AreAlmostEqual(-1.0211428571428571429, method.Interpolate(0.4), 1e-15, "A 0.4"); NumericAssert.AreAlmostEqual(.31771428571428571421, method.Interpolate(1.2), 1e-15, "A 1.2"); NumericAssert.AreAlmostEqual(39, method.Interpolate(10.0), 1e-14, "A 10.0"); NumericAssert.AreAlmostEqual(-37, method.Interpolate(-10.0), 1e-14, "A -10.0"); }
public void TestInterpolationMethod_AkimaSpline() { double[] t = new double[] { -2.0, -1.0, 0.0, 1.0, 2.0 }; double[] x = new double[] { 1.0, 2.0, -1.0, 0.0, 1.0 }; IInterpolationMethod method = Interpolation.CreateAkimaCubicSpline(t, x); Assert.IsInstanceOfType(typeof(AkimaSplineInterpolation), method, "Type"); for (int i = 0; i < t.Length; i++) { // verify the interpolated values exactly at the sample points. Assert.AreEqual(x[i], method.Interpolate(t[i]), "A Exact Point " + i.ToString()); } // TODO: Verify the expected values (that they are really the expected ones) NumericAssert.AreAlmostEqual(-0.52, method.Interpolate(-2.4), 1e-15, "A -2.4"); NumericAssert.AreAlmostEqual(1.826, method.Interpolate(-0.9), 1e-15, "A -0.9"); NumericAssert.AreAlmostEqual(0.25, method.Interpolate(-0.5), 1e-15, "A -0.5"); NumericAssert.AreAlmostEqual(-1.006, method.Interpolate(-0.1), 1e-15, "A -0.1"); NumericAssert.AreAlmostEqual(-0.9, method.Interpolate(0.1), 1e-15, "A 0.1"); NumericAssert.AreAlmostEqual(-0.6, method.Interpolate(0.4), 1e-15, "A 0.4"); NumericAssert.AreAlmostEqual(0.2, method.Interpolate(1.2), 1e-15, "A 1.2"); NumericAssert.AreAlmostEqual(9, method.Interpolate(10.0), 1e-14, "A 10.0"); NumericAssert.AreAlmostEqual(-151, method.Interpolate(-10.0), 1e-14, "A -10.0"); }
public void TestInterpolationMethod_CubicSpline_BoundaryFirstDerivativeFixed() { double[] t = new double[] { -2.0, -1.0, 0.0, 1.0, 2.0 }; double[] x = new double[] { 1.0, 2.0, -1.0, 0.0, 1.0 }; IInterpolationMethod method = Interpolation.CreateCubicSpline(t, x, SplineBoundaryCondition.FirstDerivative, 1.0, SplineBoundaryCondition.FirstDerivative, -1.0); Assert.IsInstanceOfType(typeof(CubicSplineInterpolation), method, "Type"); for (int i = 0; i < t.Length; i++) { // verify the interpolated values exactly at the sample points. Assert.AreEqual(x[i], method.Interpolate(t[i]), "A Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=-2.4},Spline([[-2,1],[-1,2],[0,-1],[1,0],[2,1]], x, degree=3, endpoints=[1,-1])),20);" NumericAssert.AreAlmostEqual(1.120000000000000001, method.Interpolate(-2.4), 1e-15, "A -2.4"); NumericAssert.AreAlmostEqual(1.8243928571428571428, method.Interpolate(-0.9), 1e-15, "A -0.9"); NumericAssert.AreAlmostEqual(.54910714285714285715, method.Interpolate(-0.5), 1e-15, "A -0.5"); NumericAssert.AreAlmostEqual(-.78903571428571428572, method.Interpolate(-0.1), 1e-15, "A -0.1"); NumericAssert.AreAlmostEqual(-1.1304642857142857143, method.Interpolate(0.1), 1e-15, "A 0.1"); NumericAssert.AreAlmostEqual(-1.1040000000000000000, method.Interpolate(0.4), 1e-15, "A 0.4"); NumericAssert.AreAlmostEqual(.4148571428571428571, method.Interpolate(1.2), 1e-15, "A 1.2"); NumericAssert.AreAlmostEqual(-608.14285714285714286, method.Interpolate(10.0), 1e-15, "A 10.0"); NumericAssert.AreAlmostEqual(1330.1428571428571429, method.Interpolate(-10.0), 1e-15, "A -10.0"); }
public void TestInterpolationMethod_NevillePolynomial() { double[] t = new double[] { 0.0, 1.0, 3.0, 4.0 }; double[] x = new double[] { 0.0, 3.0, 1.0, 3.0 }; IInterpolationMethod method = Interpolation.CreatePolynomial(t, x); Assert.IsInstanceOfType(typeof(PolynomialInterpolation), method, "Type"); double dx, d2x; for (int i = 0; i < t.Length; i++) { // verify the interpolated values exactly at the sample points. Assert.AreEqual(x[i], method.Interpolate(t[i]), "A Exact Point " + i.ToString()); Assert.AreEqual(x[i], method.Differentiate(t[i], out dx, out d2x), "B Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},PolynomialInterpolation([[0,0],[1,3],[3,1],[4,3]], x)),20);" NumericAssert.AreAlmostEqual(.57225000000000000000, method.Interpolate(0.1), 1e-15, "A 0.1"); NumericAssert.AreAlmostEqual(.57225000000000000000, method.Differentiate(0.1, out dx, out d2x), 1e-15, "B 0.1"); NumericAssert.AreAlmostEqual(1.8840000000000000000, method.Interpolate(0.4), 1e-15, "A 0.4"); NumericAssert.AreAlmostEqual(1.8840000000000000000, method.Differentiate(0.4, out dx, out d2x), 1e-15, "B 0.4"); NumericAssert.AreAlmostEqual(3.0314166666666666667, method.Interpolate(1.1), 1e-15, "A 1.1"); NumericAssert.AreAlmostEqual(3.0314166666666666667, method.Differentiate(1.1, out dx, out d2x), 1e-15, "B 1.1"); NumericAssert.AreAlmostEqual(1.034666666666666667, method.Interpolate(3.2), 1e-15, "A 3.2"); NumericAssert.AreAlmostEqual(1.034666666666666667, method.Differentiate(3.2, out dx, out d2x), 1e-15, "B 3.2"); NumericAssert.AreAlmostEqual(6.281250000000000000, method.Interpolate(4.5), 1e-15, "A 4.5"); NumericAssert.AreAlmostEqual(6.281250000000000000, method.Differentiate(4.5, out dx, out d2x), 1e-15, "B 4.5"); NumericAssert.AreAlmostEqual(277.50000000000000000, method.Interpolate(10.0), 1e-15, "A 10.0"); NumericAssert.AreAlmostEqual(277.50000000000000000, method.Differentiate(10.0, out dx, out d2x), 1e-15, "B 10.0"); NumericAssert.AreAlmostEqual(-1010.8333333333333333, method.Interpolate(-10.0), 1e-15, "A -10.0"); NumericAssert.AreAlmostEqual(-1010.8333333333333333, method.Differentiate(-10.0, out dx, out d2x), 1e-15, "B -10.0"); }
public void TestInterpolationMethod_CubicSpline_BoundaryNatural() { double[] t = new double[] { -2.0, -1.0, 0.0, 1.0, 2.0 }; double[] x = new double[] { 1.0, 2.0, -1.0, 0.0, 1.0 }; IInterpolationMethod method = Interpolation.CreateNaturalCubicSpline(t, x); Assert.IsInstanceOfType(typeof(CubicSplineInterpolation), method, "Type"); for (int i = 0; i < t.Length; i++) { // verify the interpolated values exactly at the sample points. Assert.AreEqual(x[i], method.Interpolate(t[i]), "A Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=-2.4},Spline([[-2,1],[-1,2],[0,-1],[1,0],[2,1]], x, degree=3, endpoints='natural')),20);" NumericAssert.AreAlmostEqual(.144000000000000000, method.Interpolate(-2.4), 1e-15, "A -2.4"); NumericAssert.AreAlmostEqual(1.7906428571428571429, method.Interpolate(-0.9), 1e-15, "A -0.9"); NumericAssert.AreAlmostEqual(.47321428571428571431, method.Interpolate(-0.5), 1e-15, "A -0.5"); NumericAssert.AreAlmostEqual(-.80992857142857142857, method.Interpolate(-0.1), 1e-15, "A -0.1"); NumericAssert.AreAlmostEqual(-1.1089285714285714286, method.Interpolate(0.1), 1e-15, "A 0.1"); NumericAssert.AreAlmostEqual(-1.0285714285714285714, method.Interpolate(0.4), 1e-15, "A 0.4"); NumericAssert.AreAlmostEqual(.30285714285714285716, method.Interpolate(1.2), 1e-15, "A 1.2"); NumericAssert.AreAlmostEqual(189, method.Interpolate(10.0), 1e-15, "A 10.0"); NumericAssert.AreAlmostEqual(677, method.Interpolate(-10.0), 1e-15, "A -10.0"); }
public void TestInterpolationMethod_LinearSpline() { double[] t = new double[] { -2.0, -1.0, 0.0, 1.0, 2.0 }; double[] x = new double[] { 1.0, 2.0, -1.0, 0.0, 1.0 }; IInterpolationMethod method = Interpolation.CreateLinearSpline(t, x); Assert.IsInstanceOfType(typeof(LinearSplineInterpolation), method, "Type"); for (int i = 0; i < t.Length; i++) { // verify the interpolated values exactly at the sample points. Assert.AreEqual(x[i], method.Interpolate(t[i]), "A Exact Point " + i.ToString()); } // Maple: "f := x -> piecewise(x<-1,3+x,x<0,-1-3*x,x<1,-1+x,-1+x);" // Maple: "f(x)" NumericAssert.AreAlmostEqual(.6, method.Interpolate(-2.4), 1e-15, "A -2.4"); NumericAssert.AreAlmostEqual(1.7, method.Interpolate(-0.9), 1e-15, "A -0.9"); NumericAssert.AreAlmostEqual(.5, method.Interpolate(-0.5), 1e-15, "A -0.5"); NumericAssert.AreAlmostEqual(-.7, method.Interpolate(-0.1), 1e-15, "A -0.1"); NumericAssert.AreAlmostEqual(-.9, method.Interpolate(0.1), 1e-15, "A 0.1"); NumericAssert.AreAlmostEqual(-.6, method.Interpolate(0.4), 1e-15, "A 0.4"); NumericAssert.AreAlmostEqual(.2, method.Interpolate(1.2), 1e-15, "A 1.2"); NumericAssert.AreAlmostEqual(9.0, method.Interpolate(10.0), 1e-15, "A 10.0"); NumericAssert.AreAlmostEqual(-7.0, method.Interpolate(-10.0), 1e-15, "A -10.0"); }
public void TestInterpolationMethod_LimitedOrderRationalWithPoles() { double[] t = new double[] { 0, 1, 3, 4, 5 }; double[] x = new double[] { 0, 3, 1000, -1000, 3 }; LimitedOrderRationalInterpolation method = new LimitedOrderRationalInterpolation(); method.Init(t, x); for (int i = 0; i < t.Length; i++) { Assert.AreEqual(x[i], method.Interpolate(t[i]), "Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},RationalInterpolation([[0,0],[1,3],[3,1000],[4,-1000], [5,3]], x)),20);" NumericAssert.AreAlmostEqual(.19389203383553566255, method.Interpolate(0.1), 1e-15, "A 0.1"); NumericAssert.AreAlmostEqual(.88132900698869875369, method.Interpolate(0.4), 1e-14, "A 0.4"); NumericAssert.AreAlmostEqual(3.5057665681580626913, method.Interpolate(1.1), 1e-15, "A 1.1"); NumericAssert.AreAlmostEqual(1548.7666642693586902, method.Interpolate(3.01), 1e-13, "A 3.01"); NumericAssert.AreAlmostEqual(3362.2564334253633516, method.Interpolate(3.02), 1e-13, "A 3.02"); NumericAssert.AreAlmostEqual(-22332.603641443806014, method.Interpolate(3.03), 1e-12, "A 3.03"); NumericAssert.AreAlmostEqual(-440.30323769822443789, method.Interpolate(3.1), 1e-14, "A 3.1"); NumericAssert.AreAlmostEqual(-202.42421196280566349, method.Interpolate(3.2), 1e-14, "A 3.2"); NumericAssert.AreAlmostEqual(21.208249625210155439, method.Interpolate(4.5), 1e-14, "A 4.5"); NumericAssert.AreAlmostEqual(-4.8936986959784751517, method.Interpolate(10.0), 1e-13, "A 10.0"); NumericAssert.AreAlmostEqual(-3.6017584308603731307, method.Interpolate(-10.0), 1e-13, "A -10.0"); }
public void TestMatrix_Multiplicative() { /* * MATLAB: * prod = ma3x2 * md2x4 * prod_s = ma3x2 * 2 */ Matrix prod = new Matrix(new double[][] { new double[] { -5, -4.2, -11, 8 }, new double[] { 11, 10.4, 19, -4 }, new double[] { 26, 31.7, 13, 74 } }); NumericAssert.AreAlmostEqual(prod, ma3x2 * md2x4, "prod 1"); NumericAssert.AreAlmostEqual(prod, ma3x2.Multiply(md2x4), "prod 2"); Matrix prod_s = new Matrix(new double[][] { new double[] { 2, -4 }, new double[] { -2, 8 }, new double[] { 10, 14 } }); NumericAssert.AreAlmostEqual(prod_s, ma3x2 * 2, "prod s 1"); Matrix prod_s_inplace = ma3x2.Clone(); prod_s_inplace.Multiply(2); NumericAssert.AreAlmostEqual(prod_s, prod_s_inplace, "prod s 2"); }
public void TestSpecialFunctions_Gamma() { // ensure poles return NaN Assert.IsTrue(double.IsNaN(Fn.Gamma(0.0)), "A1"); Assert.IsTrue(double.IsNaN(Fn.Gamma(-1.0)), "A2"); Assert.IsTrue(double.IsNaN(Fn.Gamma(-2.0)), "A3"); Assert.IsTrue(double.IsNaN(Fn.Gamma(-20.0)), "A4"); Assert.IsFalse(double.IsNaN(Fn.Gamma(-20.0000000001)), "A4b"); // Compare Gamma with Maple: "evalf(GAMMA(x),20);" NumericAssert.AreAlmostEqual(999.42377248459546611, Fn.Gamma(0.001), 1e-15, "B1"); NumericAssert.AreAlmostEqual(99.432585119150603714, Fn.Gamma(0.01), 1e-14, "B2"); NumericAssert.AreAlmostEqual(9.5135076986687318363, Fn.Gamma(0.1), 1e-13, "B3"); NumericAssert.AreAlmostEqual(4.5908437119988030532, Fn.Gamma(0.2), 1e-13, "B4"); NumericAssert.AreAlmostEqual(2.2181595437576882231, Fn.Gamma(0.4), 1e-13, "B5"); NumericAssert.AreAlmostEqual(1.4891922488128171024, Fn.Gamma(0.6), 1e-13, "B6"); NumericAssert.AreAlmostEqual(1.0686287021193193549, Fn.Gamma(0.9), 1e-14, "B7"); NumericAssert.AreAlmostEqual(1.0005782056293586480, Fn.Gamma(0.999), 1e-15, "B8"); NumericAssert.AreAlmostEqual(1.0, Fn.Gamma(1.0), 1e-13, "B9"); NumericAssert.AreAlmostEqual(.99942377248459546611, Fn.Gamma(1.001), 1e-15, "B10"); NumericAssert.AreAlmostEqual(.88622692545275801365, Fn.Gamma(1.5), 1e-14, "B11"); NumericAssert.AreAlmostEqual(.96176583190738741941, Fn.Gamma(1.9), 1e-14, "B12"); NumericAssert.AreAlmostEqual(1.0, Fn.Gamma(2.0), 1e-15, "B13"); NumericAssert.AreAlmostEqual(362880.0, Fn.Gamma(10.0), 1e-12, "B14"); NumericAssert.AreAlmostEqual(1159686.4489708177739, Fn.Gamma(10.51), 1e-12, "B15"); NumericAssert.AreAlmostEqual(.93326215443944152682e156, Fn.Gamma(100), 1e-9, "B16"); NumericAssert.AreAlmostEqual(-100.58719796441077919, Fn.Gamma(-0.01), 1e-14, "B17"); NumericAssert.AreAlmostEqual(-10.686287021193193549, Fn.Gamma(-0.1), 1e-14, "B18"); NumericAssert.AreAlmostEqual(-3.5449077018110320546, Fn.Gamma(-0.5), 1e-14, "B19"); NumericAssert.AreAlmostEqual(4.8509571405220973902, Fn.Gamma(-1.2), 1e-14, "B20"); NumericAssert.AreAlmostEqual(-49.547903041431840399, Fn.Gamma(-2.01), 1e-13, "B21"); NumericAssert.AreAlmostEqual(-.10234011287149294961e-155, Fn.Gamma(-100.01), 1e-9, "B22"); }
public void TestInterpolationMethod_Chebyshev1BarycentricPolynomial() { double[] x = new double[] { 0.0, 3.0, 2.5, 1.0, 3.0 }; IInterpolationMethod method = Interpolation.CreateOnChebyshevFirstKindPoints(0.0, 4.0, x); Assert.IsInstanceOfType(typeof(ChebyshevFirstKindPolynomialInterpolation), method, "Type"); double[] t = Interpolation.GenerateChebyshevFirstKindSamplePoints(0.0, 4.0, 5); for (int i = 0; i < 4; i++) { // verify the generated chebyshev1 points double tt = 2.0 + 2.0 * Math.Cos(Math.PI * 0.1 * (2 * i + 1)); NumericAssert.AreAlmostEqual(t[i], tt, "Point " + i.ToString()); // verify the interpolated values exactly at the sample points. NumericAssert.AreAlmostEqual(x[i], method.Interpolate(tt), "A Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},PolynomialInterpolation(evalf([[2*cos(Pi/10)+2,0],[2*cos(3*Pi/10)+2,3],[2*cos(5*Pi/10)+2,2.5],[2*cos(7*Pi/10)+2,1],[2*cos(9*Pi/10)+2,3]]), x)),20);" NumericAssert.AreAlmostEqual(2.9882560375702001608, method.Interpolate(0.1), 1e-15, "A 0.1"); NumericAssert.AreAlmostEqual(1.7097090371118968872, method.Interpolate(0.4), 1e-15, "A 0.4"); NumericAssert.AreAlmostEqual(1.0462830804302586508, method.Interpolate(1.1), 1e-15, "A 1.1"); NumericAssert.AreAlmostEqual(2.951922899377369724, method.Interpolate(3.2), 1e-15, "A 3.2"); NumericAssert.AreAlmostEqual(-5.394317844683536750, method.Interpolate(4.5), 1e-15, "A 4.5"); NumericAssert.AreAlmostEqual(-228.01438153088988107, method.Interpolate(10.0), 1e-13, "A 10.0"); NumericAssert.AreAlmostEqual(1979.2646653044133954, method.Interpolate(-10.0), 1e-12, "A -10.0"); }
public void IRID90_CholeskySolve() { Matrix i = Matrix.Identity(3, 3); double[][] pvals1 = { new double[] { 1.0, 1.0, 1.0 }, new double[] { 1.0, 2.0, 3.0 }, new double[] { 1.0, 3.0, 6.0 } }; Matrix m1 = new Matrix(pvals1); CholeskyDecomposition cd1 = new CholeskyDecomposition(m1); Matrix inv1a = cd1.Solve(i); Matrix test1a = m1 * inv1a; NumericAssert.AreAlmostEqual(i, test1a, "1A"); Matrix inv1b = m1.Inverse(); NumericAssert.AreAlmostEqual(inv1a, inv1b, "1B"); double[][] pvals2 = { new double[] { 25, -5, 10 }, new double[] { -5, 17, 10 }, new double[] { 10, 10, 62 } }; Matrix m2 = new Matrix(pvals2); CholeskyDecomposition cd2 = new CholeskyDecomposition(m2); Matrix inv2a = cd2.Solve(i); Matrix test2a = m2 * inv2a; NumericAssert.AreAlmostEqual(i, test2a, "2A"); Matrix inv2b = m2.Inverse(); NumericAssert.AreAlmostEqual(inv2a, inv2b, "2B"); }
public void TestInterpolationMethod_Chebyshev2BarycentricPolynomial() { double[] x = new double[] { 0.0, 3.0, 2.5, 1.0, 3.0 }; IInterpolationMethod method = Interpolation.CreateOnChebyshevSecondKindPoints(0.0, 4.0, x); Assert.IsInstanceOfType(typeof(ChebyshevSecondKindPolynomialInterpolation), method, "Type"); double[] t = Interpolation.GenerateChebyshevSecondKindSamplePoints(0.0, 4.0, 5); for (int i = 0; i < 4; i++) { // verify the generated chebyshev2 points double tt = 2.0 + 2.0 * Math.Cos(Math.PI * i * 0.25); NumericAssert.AreAlmostEqual(t[i], tt, "Point " + i.ToString()); // verify the interpolated values exactly at the sample points. NumericAssert.AreAlmostEqual(x[i], method.Interpolate(tt), "A Exact Point " + i.ToString()); } // Maple: "with(CurveFitting);" // Maple: "evalf(subs({x=0.1},PolynomialInterpolation(evalf([[2*cos(0*Pi/4)+2,0],[2*cos(1*Pi/4)+2,3],[2*cos(2*Pi/4)+2,2.5],[2*cos(3*Pi/4)+2,1],[2*cos(4*Pi/4)+2,3]]), x)),20);" NumericAssert.AreAlmostEqual(2.4826419375703841423, method.Interpolate(0.1), 1e-14, "A 0.1"); NumericAssert.AreAlmostEqual(1.3814129880730972522, method.Interpolate(0.4), 1e-14, "A 0.4"); NumericAssert.AreAlmostEqual(.8808232156067110292, method.Interpolate(1.1), 1e-15, "A 1.1"); NumericAssert.AreAlmostEqual(3.478116015902536997, method.Interpolate(3.2), 1e-15, "A 3.2"); NumericAssert.AreAlmostEqual(-5.035612822087164912, method.Interpolate(4.5), 1e-15, "A 4.5"); NumericAssert.AreAlmostEqual(-369.20562748477140583, method.Interpolate(10.0), 1e-13, "A 10.0"); NumericAssert.AreAlmostEqual(1199.4696961966999204, method.Interpolate(-10.0), 1e-12, "A -10.0"); }
public void TestContinuousDistributions_StudensT() { TestContinuousDistributionShapeMatchesCumulativeDensity( new StudentsTDistribution(2), -2.0, 5.0, 10, 100000, 0.01, "StudentsTDistribution(2)"); StudentsTDistribution d = new StudentsTDistribution(2); // PDF - Evaluated in Maple with "stats[statevalf,pdf,studentst[2]](x);" NumericAssert.AreAlmostEqual(0.3535533906, d.ProbabilityDensity(0.0), 1e-9, "pdf(0)"); NumericAssert.AreAlmostEqual(0.1924500897, d.ProbabilityDensity(1.0), 1e-9, "pdf(1)"); NumericAssert.AreAlmostEqual(0.06804138174, d.ProbabilityDensity(2.0), 1e-9, "pdf(2)"); NumericAssert.AreAlmostEqual(0.02741012223, d.ProbabilityDensity(3.0), 1e-9, "pdf(3)"); NumericAssert.AreAlmostEqual(0.01309457002, d.ProbabilityDensity(4.0), 1e-9, "pdf(4)"); NumericAssert.AreAlmostEqual(0.1924500897, d.ProbabilityDensity(-1.0), 1e-9, "pdf(-1)"); NumericAssert.AreAlmostEqual(0.06804138174, d.ProbabilityDensity(-2.0), 1e-9, "pdf(-2)"); NumericAssert.AreAlmostEqual(0.02741012223, d.ProbabilityDensity(-3.0), 1e-9, "pdf(-3)"); NumericAssert.AreAlmostEqual(0.01309457002, d.ProbabilityDensity(-4.0), 1e-9, "pdf(-4)"); // CDF - Evaluated in Maple with "stats[statevalf,cdf,studentst[2]](x);" NumericAssert.AreAlmostEqual(0.5000000000, d.CumulativeDistribution(0.0), "cdf(0)"); NumericAssert.AreAlmostEqual(0.7886751346, d.CumulativeDistribution(1.0), 1e-9, "cdf(1)"); NumericAssert.AreAlmostEqual(0.9082482905, d.CumulativeDistribution(2.0), 1e-9, "cdf(2)"); NumericAssert.AreAlmostEqual(0.9522670169, d.CumulativeDistribution(3.0), 1e-9, "cdf(3)"); NumericAssert.AreAlmostEqual(0.9714045208, d.CumulativeDistribution(4.0), 1e-9, "cdf(4)"); NumericAssert.AreAlmostEqual(0.2113248654, d.CumulativeDistribution(-1.0), 1e-9, "cdf(-1)"); NumericAssert.AreAlmostEqual(0.09175170954, d.CumulativeDistribution(-2.0), 1e-9, "cdf(-2)"); NumericAssert.AreAlmostEqual(0.04773298313, d.CumulativeDistribution(-3.0), 1e-9, "cdf(-3)"); NumericAssert.AreAlmostEqual(0.02859547921, d.CumulativeDistribution(-4.0), 1e-9, "cdf(-4)"); }
public void TestSpecialFunctions_BetaRegularized() { // Maple: Ix := (x,a,b) -> int(t^(a-1)*(1-t)^(b-1),t=0..x)/Beta(a,b); // Compare with Maple: "evalf(Ix(x,0.2,0.2),20);", with relative accuracy NumericAssert.AreAlmostEqual(0.0, Fn.BetaRegularized(0.2, 0.2, 0.0), 1e-13, "A1"); NumericAssert.AreAlmostEqual(.39272216435257082965, Fn.BetaRegularized(0.2, 0.2, 0.2), 1e-13, "A2"); NumericAssert.AreAlmostEqual(.50000000000000000000, Fn.BetaRegularized(0.2, 0.2, 0.5), 1e-13, "A3"); NumericAssert.AreAlmostEqual(.60727783564742917036, Fn.BetaRegularized(0.2, 0.2, 0.8), 1e-13, "A4"); NumericAssert.AreAlmostEqual(1.0000000000000000000, Fn.BetaRegularized(0.2, 0.2, 1.0), 1e-13, "A5"); // Compare with Maple: "evalf(Ix(x,0.6,1.2),20);", with relative accuracy NumericAssert.AreAlmostEqual(0.0, Fn.BetaRegularized(0.6, 1.2, 0.0), 1e-13, "B1"); NumericAssert.AreAlmostEqual(.42540331997033591754, Fn.BetaRegularized(0.6, 1.2, 0.2), 1e-13, "B2"); NumericAssert.AreAlmostEqual(.71641011564425207256, Fn.BetaRegularized(0.6, 1.2, 0.5), 1e-13, "B3"); NumericAssert.AreAlmostEqual(.91373194998181983314, Fn.BetaRegularized(0.6, 1.2, 0.8), 1e-13, "B4"); NumericAssert.AreAlmostEqual(1.0000000000000000000, Fn.BetaRegularized(0.6, 1.2, 1.0), 1e-13, "B5"); // Compare with Maple: "evalf(Ix(x,7.0,1.2),20);", with relative accuracy NumericAssert.AreAlmostEqual(0.0, Fn.BetaRegularized(7.0, 1.2, 0.0), 1e-13, "C1"); NumericAssert.AreAlmostEqual(.20126888449347947608e-4, Fn.BetaRegularized(7.0, 1.2, 0.2), 1e-13, "C2"); NumericAssert.AreAlmostEqual(.11371092280417448678e-1, Fn.BetaRegularized(7.0, 1.2, 0.5), 1e-13, "C3"); NumericAssert.AreAlmostEqual(.11102090346884848038, Fn.BetaRegularized(7.0, 1.2, 0.7), 1e-13, "C4"); NumericAssert.AreAlmostEqual(.26774648551269072265, Fn.BetaRegularized(7.0, 1.2, 0.8), 1e-12, "C5"); NumericAssert.AreAlmostEqual(.56477467605979107895, Fn.BetaRegularized(7.0, 1.2, 0.9), 1e-13, "C6"); NumericAssert.AreAlmostEqual(.77753405618146275868, Fn.BetaRegularized(7.0, 1.2, 0.95), 1e-13, "C7"); NumericAssert.AreAlmostEqual(1.0000000000000000000, Fn.BetaRegularized(7.0, 1.2, 1.0), 1e-13, "C8"); }
public void TestSpecialFunctions_Beta() { // Symmetry: NumericAssert.AreAlmostEqual(Fn.Beta(1.0, 0.1), Fn.Beta(0.1, 1.0), "A1"); NumericAssert.AreAlmostEqual(Fn.Beta(10.0, 0.1), Fn.Beta(0.1, 10.0), "A2"); NumericAssert.AreAlmostEqual(Fn.Beta(1.0, 0.5), Fn.Beta(0.5, 1.0), "A3"); NumericAssert.AreAlmostEqual(Fn.Beta(10.0, 0.5), Fn.Beta(0.5, 10.0), "A4"); NumericAssert.AreAlmostEqual(Fn.Beta(100.0, 10.0), Fn.Beta(10.0, 100.0), "A1"); // Compare with Maple: "evalf(Beta(0.1,x),20);", with relative accuracy NumericAssert.AreAlmostEqual(19.714639489050161663, Fn.Beta(0.1, 0.1), 1e-13, "B1"); NumericAssert.AreAlmostEqual(14.599371492764829943, Fn.Beta(0.1, 0.2), 1e-13, "B2"); NumericAssert.AreAlmostEqual(12.830598536321300437, Fn.Beta(0.1, 0.3), 1e-13, "B3"); NumericAssert.AreAlmostEqual(10.0, Fn.Beta(0.1, 1.0), 1e-13, "B4"); NumericAssert.AreAlmostEqual(9.0909090909090909091, Fn.Beta(0.1, 2.0), 1e-13, "B5"); NumericAssert.AreAlmostEqual(8.1743590791584497328, Fn.Beta(0.1, 5.0), 1e-13, "B6"); NumericAssert.AreAlmostEqual(7.5913800009109903433, Fn.Beta(0.1, 10.0), 1e-13, "B7"); NumericAssert.AreAlmostEqual(6.0053229390929389725, Fn.Beta(0.1, 100.0), 1e-13, "B8"); // Compare with Maple: "evalf(Beta(25.0,x),20);", with relative accuracy NumericAssert.AreAlmostEqual(6.9076854432998202098, Fn.Beta(25.0, 0.1), 1e-12, "C1"); NumericAssert.AreAlmostEqual(2.4193558279880311532, Fn.Beta(25.0, 0.2), 1e-12, "C2"); NumericAssert.AreAlmostEqual(1.1437887414566949564, Fn.Beta(25.0, 0.3), 1e-12, "C3"); NumericAssert.AreAlmostEqual(.40000000000000000000e-1, Fn.Beta(25.0, 1.0), 1e-11, "C4"); NumericAssert.AreAlmostEqual(.15384615384615384615e-2, Fn.Beta(25.0, 2.0), 1e-11, "C5"); NumericAssert.AreAlmostEqual(.16841396151740979327e-5, Fn.Beta(25.0, 5.0), 1e-11, "C6"); NumericAssert.AreAlmostEqual(.76261281522028757519e-9, Fn.Beta(25.0, 10.0), 1e-10, "C7"); NumericAssert.AreAlmostEqual(.38445319996184968535e-27, Fn.Beta(25.0, 100.0), 1e-11, "C8"); }
public void TestSpecialFunctions_Digamma() { // ensure poles return NaN Assert.IsTrue(double.IsNaN(Fn.Digamma(0.0)), "A1"); Assert.IsTrue(double.IsNaN(Fn.Digamma(-1.0)), "A2"); Assert.IsTrue(double.IsNaN(Fn.Digamma(-2.0)), "A3"); Assert.IsTrue(double.IsNaN(Fn.Digamma(-20.0)), "A4"); Assert.IsFalse(double.IsNaN(Fn.Digamma(-20.0000000001)), "A4b"); // Compare Gamma with Maple: "evalf(Psi(x),20);" NumericAssert.AreAlmostEqual(-1000.5755719318103005, Fn.Digamma(0.001), 1e-15, "B1"); NumericAssert.AreAlmostEqual(-100.56088545786867450, Fn.Digamma(0.01), 1e-15, "B2"); NumericAssert.AreAlmostEqual(-10.423754940411076795, Fn.Digamma(0.1), 1e-15, "B3"); NumericAssert.AreAlmostEqual(-5.2890398965921882955, Fn.Digamma(0.2), 1e-15, "B4"); NumericAssert.AreAlmostEqual(-2.5613845445851161457, Fn.Digamma(0.4), 1e-15, "B5"); NumericAssert.AreAlmostEqual(-1.5406192138931904148, Fn.Digamma(0.6), 1e-15, "B6"); NumericAssert.AreAlmostEqual(-.75492694994705139189, Fn.Digamma(0.9), 1e-15, "B7"); NumericAssert.AreAlmostEqual(-.57886180210864542646, Fn.Digamma(0.999), 1e-15, "B8"); NumericAssert.AreAlmostEqual(-.57721566490153286061, Fn.Digamma(1.0), 1e-15, "B9"); NumericAssert.AreAlmostEqual(-.57557193181030047147, Fn.Digamma(1.001), 1e-14, "B10"); NumericAssert.AreAlmostEqual(.36489973978576520559e-1, Fn.Digamma(1.5), 1e-14, "B11"); NumericAssert.AreAlmostEqual(.35618416116405971922, Fn.Digamma(1.9), 1e-15, "B12"); NumericAssert.AreAlmostEqual(.42278433509846713939, Fn.Digamma(2.0), 1e-15, "B13"); NumericAssert.AreAlmostEqual(2.2517525890667211076, Fn.Digamma(10.0), 1e-15, "B14"); NumericAssert.AreAlmostEqual(2.3039997054324985520, Fn.Digamma(10.51), 1e-15, "B15"); NumericAssert.AreAlmostEqual(4.6001618527380874002, Fn.Digamma(100), 1e-15, "B16"); NumericAssert.AreAlmostEqual(99.406213695944404856, Fn.Digamma(-0.01), 1e-15, "B17"); NumericAssert.AreAlmostEqual(9.2450730500529486081, Fn.Digamma(-0.1), 1e-15, "B18"); NumericAssert.AreAlmostEqual(.36489973978576520559e-1, Fn.Digamma(-0.5), 1e-14, "B19"); NumericAssert.AreAlmostEqual(4.8683247666271948739, Fn.Digamma(-1.2), 1e-15, "B20"); NumericAssert.AreAlmostEqual(100.89382514365634023, Fn.Digamma(-2.01), 1e-13, "B21"); NumericAssert.AreAlmostEqual(104.57736050326787844, Fn.Digamma(-100.01), 1e-12, "B22"); }
public static void ComplexTestImagZero(double[] samples) { for (int i = 1; i < samples.Length; i += 2) { NumericAssert.AreAlmostEqual(0, samples[i], "Complex: Zero Imaginary Part"); } }
public static void ComplexTestRealZero(double[] samples) { for (int i = 0; i < samples.Length; i += 2) { NumericAssert.AreAlmostEqual(0, samples[i], "Complex: Zero Real Part"); } ; }
public void TestSpecialFunctions_Sinc() { // Test at integers: for (int i = -10; i < 10; i++) { NumericAssert.AreAlmostEqual((i == 0) ? 1.0 : 0.0, Fn.Sinc(i), "sinc(" + i.ToString() + ")"); } }
public static void RealTestTimeEven(double[] samples) { int len = samples.Length; for (int i = 1; i < samples.Length; i++) { NumericAssert.AreAlmostEqual(samples[i], samples[len - i], "Real Even in Time Space"); } }
public void CodeSample_Combinatorics_Permutation() { int[] numbers = new int[] { 1, 2, 3, 4, 5 }; int count = numbers.Length; NumericAssert.AreAlmostEqual(120.0, Combinatorics.Permutations(count), "perm(5)"); int[] permutation = new int[count]; Combinatorics.RandomShuffle(numbers, permutation); }
public void CountingPermutations() { Assert.AreEqual(1, Combinatorics.Permutations(0), "Perm(0)"); Assert.AreEqual(1, Combinatorics.Permutations(1), "Perm(1)"); Assert.AreEqual(2, Combinatorics.Permutations(2), "Perm(2)"); Assert.AreEqual(40320, Combinatorics.Permutations(8), "Perm(8)"); Assert.AreEqual(1307674368000, Combinatorics.Permutations(15), "Perm(15)"); Assert.AreEqual(265252859812191058636308480000000d, Combinatorics.Permutations(30), "Perm(30)"); NumericAssert.AreAlmostEqual(0.3856204824e216, Combinatorics.Permutations(128), 1e-6, "Perm(128)"); }
public static void ComplexTestTimeEven(double[] samples) { int len = samples.Length; for (int i = 2; i < samples.Length / 2; i += 2) { NumericAssert.AreAlmostEqual(samples[i], samples[len - i], "Complex Even in Time Space: Real Part"); NumericAssert.AreAlmostEqual(samples[i + 1], samples[len + 1 - i], "Complex Even in Time Space: Imaginary Part"); } }
public static void RealTestTimeOdd(double[] samples) { int len = samples.Length; for (int i = 1; i < samples.Length; i++) { NumericAssert.AreAlmostEqual(samples[i], -samples[len - i], "Real Odd in Time Space"); } NumericAssert.AreAlmostEqual(0.0, samples[0], "Real Odd in Time Space: Periodic Continuation"); }
public void TestMatrix_AdditiveTranspose() { /* * MATLAB: * sum = ma3x2 + mb3x2 * diff = ma3x2 - mb3x2 * neg_m = -ma3x2 * trans_m = ma3x2' */ Matrix sum = new Matrix(new double[][] { new double[] { 11, 0.5 }, new double[] { -4, 2.5 }, new double[] { 24, 1 } }); NumericAssert.AreAlmostEqual(sum, ma3x2 + mb3x2, "sum 1"); Matrix sum_inplace = ma3x2.Clone(); sum_inplace.Add(mb3x2); NumericAssert.AreAlmostEqual(sum, sum_inplace, "sum 2"); Matrix diff = new Matrix(new double[][] { new double[] { -9, -4.5 }, new double[] { 2, 5.5 }, new double[] { -14, 13 } }); NumericAssert.AreAlmostEqual(diff, ma3x2 - mb3x2, "diff 1"); Matrix diff_inplace = ma3x2.Clone(); diff_inplace.Subtract(mb3x2); NumericAssert.AreAlmostEqual(diff, diff_inplace, "diff 2"); Matrix neg_m = new Matrix(new double[][] { new double[] { -1, 2 }, new double[] { 1, -4 }, new double[] { -5, -7 } }); NumericAssert.AreAlmostEqual(neg_m, -ma3x2, "neg 1"); Matrix trans_m = new Matrix(new double[][] { new double[] { 1, -1, 5 }, new double[] { -2, 4, 7 } }); NumericAssert.AreAlmostEqual(trans_m, Matrix.Transpose(ma3x2), "trans 1"); Matrix trans_inplace = ma3x2.Clone(); trans_inplace.Transpose(); NumericAssert.AreAlmostEqual(trans_m, trans_inplace, "trans 2"); }
public static void ComplexTestFreqOdd(double[] samples) { int len = samples.Length; for (int i = 0; i < samples.Length / 2; i += 2) { Assert.AreEqual(samples[i + 2], -samples[len - 2 - i], 0.00000001, "Complex Odd in Frequency Space: Real Part"); Assert.AreEqual(samples[i + 3], -samples[len - 1 - i], 0.00000001, "Complex Odd in Frequency Space: Imaginary Part"); } NumericAssert.AreAlmostEqual(0.0, samples[0], "Complex Odd in Frequency Space: Real Part: Periodic Continuation (No DC)"); NumericAssert.AreAlmostEqual(0.0, samples[1], "Complex Odd in Frequency Space: Imaginary Part: Periodic Continuation (No DC)"); }
public static void ComplexTestTimeOdd(double[] samples) { int len = samples.Length; for (int i = 2; i < samples.Length / 2; i += 2) { NumericAssert.AreAlmostEqual(samples[i], -samples[len - i], "Complex Odd in Time Space: Real Part"); NumericAssert.AreAlmostEqual(samples[i + 1], -samples[len + 1 - i], "Complex Odd in Time Space: Imaginary Part"); } NumericAssert.AreAlmostEqual(0.0, samples[0], "Complex Odd in Time Space: Real Part: Periodic Continuation"); NumericAssert.AreAlmostEqual(0.0, samples[1], "Complex Odd in Time Space: Imaginary Part: Periodic Continuation"); }
public void CountingVariationsTest() { Assert.AreEqual(1, Combinatorics.Variations(0, 0), "Var(0,0)"); Assert.AreEqual(1, Combinatorics.Variations(1, 0), "Var(1,0)"); Assert.AreEqual(0, Combinatorics.Variations(0, 1), "Var(0,1)"); Assert.AreEqual(1, Combinatorics.Variations(10, 0), "Var(10,0)"); Assert.AreEqual(90, Combinatorics.Variations(10, 2), "Var(10,2)"); Assert.AreEqual(5040, Combinatorics.Variations(10, 4), "Var(10,4)"); Assert.AreEqual(151200, Combinatorics.Variations(10, 6), "Var(10,6)"); NumericAssert.AreAlmostEqual(3628800, Combinatorics.Variations(10, 9), 1e-5, "Var(10,9)"); NumericAssert.AreAlmostEqual(3628800, Combinatorics.Variations(10, 10), 1e-5, "Var(10,10)"); Assert.AreEqual(0, Combinatorics.Variations(10, 11), "Var(10,11)"); }
public void IRID119_PolynomialExtrapolatePositiveDirection() { double[] x = new double[] { -6.060771484, -5.855378418, -1.794238281, -1.229428711, 0.89935791, 2.912121582, 4.699230957, 4.788347168, 7.728830566, 11.70989502 }; double[] y = new double[] { 0.959422052, 0.959447861, 0.959958017, 0.960028946, 0.960323274, 0.960636258, 0.960914195, 0.960928023, 0.96138531, 0.962004483 }; PolynomialInterpolationAlgorithm pia = new PolynomialInterpolationAlgorithm(10); SampleList sl = new SampleList(10); for (int i = 0; i < 10; i++) { sl.Add(x[i], y[i]); } pia.Prepare(sl); NumericAssert.AreAlmostEqual(0.9622, pia.Extrapolate(12), 1e-3, "extrapolate(12)"); }
public void IRID177_MatrixPseudoInverse() { Matrix a = new Matrix(new double[][] { new double[] { 15, 23, 44, 54 }, new double[] { 1, 5, 9, 4 }, new double[] { 8, 11, 4, 2 } }); Matrix aInverse = new Matrix(new double[][] { new double[] { 0.00729481932863557, -0.0906433578450537, 0.0629567950756452 }, new double[] { -0.00695248549232449, 0.0302767536403138, 0.0601374162387492 }, new double[] { -0.00876996343998189, 0.155054444209528, -0.033311997806593 }, new double[] { 0.0265993197732062, -0.114057602060568, -0.0159589740025151 } }); NumericAssert.AreAlmostEqual(aInverse, a.Inverse(), "A"); NumericAssert.AreAlmostEqual(Matrix.Transpose(aInverse), Matrix.Transpose(a).Inverse(), "B"); }