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");
}
