/*************************************************************************
* Unset spline, i.e. initialize it with random garbage
*************************************************************************/
private static void unsetp2(ref pspline.pspline2interpolant p)
{
double[,] xy = new double[0, 0];
xy = new double[2, 2];
xy[0, 0] = -1;
xy[0, 1] = -1;
xy[1, 0] = +1;
xy[1, 1] = +1;
pspline.pspline2build(xy, 2, 1, 0, ref p);
}
public static bool testpsplineinterpolation(bool silent)
{
bool result = new bool();
bool waserrors = new bool();
bool p2errors = new bool();
bool p3errors = new bool();
double nonstrictthreshold = 0;
double threshold = 0;
int passcount = 0;
double lstep = 0;
double h = 0;
int maxn = 0;
int periodicity = 0;
int skind = 0;
int pkind = 0;
bool periodic = new bool();
double a = 0;
double b = 0;
int n = 0;
int tmpn = 0;
int i = 0;
int k = 0;
double vx = 0;
double vy = 0;
double vz = 0;
double vx2 = 0;
double vy2 = 0;
double vz2 = 0;
double vdx = 0;
double vdy = 0;
double vdz = 0;
double vdx2 = 0;
double vdy2 = 0;
double vdz2 = 0;
double vd2x = 0;
double vd2y = 0;
double vd2z = 0;
double vd2x2 = 0;
double vd2y2 = 0;
double vd2z2 = 0;
double v0 = 0;
double v1 = 0;
double[] x = new double[0];
double[] y = new double[0];
double[] z = new double[0];
double[] t = new double[0];
double[] t2 = new double[0];
double[] t3 = new double[0];
double[,] xy = new double[0, 0];
double[,] xyz = new double[0, 0];
pspline.pspline2interpolant p2 = new pspline.pspline2interpolant();
pspline.pspline3interpolant p3 = new pspline.pspline3interpolant();
spline1d.spline1dinterpolant s = new spline1d.spline1dinterpolant();
int i_ = 0;
waserrors = false;
passcount = 20;
lstep = 0.005;
h = 0.00001;
maxn = 10;
threshold = 10000 * AP.Math.MachineEpsilon;
nonstrictthreshold = 0.00001;
p2errors = false;
p3errors = false;
//
// Test basic properties of 2- and 3-dimensional splines:
// * PSpline2ParameterValues() properties
// * values at nodes
// * for periodic splines - periodicity properties
//
// Variables used:
// * N points count
// * SKind spline
// * PKind parameterization
// * Periodicity whether we have periodic spline or not
//
for (n = 2; n <= maxn; n++)
{
for (skind = 0; skind <= 2; skind++)
{
for (pkind = 0; pkind <= 2; pkind++)
{
for (periodicity = 0; periodicity <= 1; periodicity++)
{
periodic = periodicity == 1;
//
// skip unsupported combinations of parameters
//
if (periodic & n < 3)
{
continue;
}
if (periodic & skind == 0)
{
continue;
}
if (n < 5 & skind == 0)
{
continue;
}
//
// init
//
xy = new double[n, 2];
xyz = new double[n, 3];
apserv.taskgenint1dequidist(-1, +1, n, ref t2, ref x);
for (i_ = 0; i_ <= n - 1; i_++)
{
xy[i_, 0] = x[i_];
}
for (i_ = 0; i_ <= n - 1; i_++)
{
xyz[i_, 0] = x[i_];
}
apserv.taskgenint1dequidist(-1, +1, n, ref t2, ref y);
for (i_ = 0; i_ <= n - 1; i_++)
{
xy[i_, 1] = y[i_];
}
for (i_ = 0; i_ <= n - 1; i_++)
{
xyz[i_, 1] = y[i_];
}
apserv.taskgenint1dequidist(-1, +1, n, ref t2, ref z);
for (i_ = 0; i_ <= n - 1; i_++)
{
xyz[i_, 2] = z[i_];
}
unsetp2(ref p2);
unsetp3(ref p3);
if (periodic)
{
pspline.pspline2buildperiodic(xy, n, skind, pkind, ref p2);
pspline.pspline3buildperiodic(xyz, n, skind, pkind, ref p3);
}
else
{
pspline.pspline2build(xy, n, skind, pkind, ref p2);
pspline.pspline3build(xyz, n, skind, pkind, ref p3);
}
//
// PSpline2ParameterValues() properties
//
pspline.pspline2parametervalues(ref p2, ref tmpn, ref t2);
if (tmpn != n)
{
p2errors = true;
continue;
}
pspline.pspline3parametervalues(ref p3, ref tmpn, ref t3);
if (tmpn != n)
{
p3errors = true;
continue;
}
p2errors = p2errors | (double)(t2[0]) != (double)(0);
p3errors = p3errors | (double)(t3[0]) != (double)(0);
for (i = 1; i <= n - 1; i++)
{
p2errors = p2errors | (double)(t2[i]) <= (double)(t2[i - 1]);
p3errors = p3errors | (double)(t3[i]) <= (double)(t3[i - 1]);
}
if (periodic)
{
p2errors = p2errors | (double)(t2[n - 1]) >= (double)(1);
p3errors = p3errors | (double)(t3[n - 1]) >= (double)(1);
}
else
{
p2errors = p2errors | (double)(t2[n - 1]) != (double)(1);
p3errors = p3errors | (double)(t3[n - 1]) != (double)(1);
}
//
// Now we have parameter values stored at T,
// and want to test whether the actully correspond to
// points
//
for (i = 0; i <= n - 1; i++)
{
//
// 2-dimensional test
//
pspline.pspline2calc(ref p2, t2[i], ref vx, ref vy);
p2errors = p2errors | (double)(Math.Abs(vx - x[i])) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - y[i])) > (double)(threshold);
//
// 3-dimensional test
//
pspline.pspline3calc(ref p3, t3[i], ref vx, ref vy, ref vz);
p3errors = p3errors | (double)(Math.Abs(vx - x[i])) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - y[i])) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - z[i])) > (double)(threshold);
}
//
// Test periodicity (if needed)
//
if (periodic)
{
//
// periodicity at nodes
//
for (i = 0; i <= n - 1; i++)
{
//
// 2-dimensional test
//
pspline.pspline2calc(ref p2, t2[i] + AP.Math.RandomInteger(10) - 5, ref vx, ref vy);
p2errors = p2errors | (double)(Math.Abs(vx - x[i])) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - y[i])) > (double)(threshold);
pspline.pspline2diff(ref p2, t2[i] + AP.Math.RandomInteger(10) - 5, ref vx, ref vdx, ref vy, ref vdy);
p2errors = p2errors | (double)(Math.Abs(vx - x[i])) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - y[i])) > (double)(threshold);
pspline.pspline2diff2(ref p2, t2[i] + AP.Math.RandomInteger(10) - 5, ref vx, ref vdx, ref vd2x, ref vy, ref vdy, ref vd2y);
p2errors = p2errors | (double)(Math.Abs(vx - x[i])) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - y[i])) > (double)(threshold);
//
// 3-dimensional test
//
pspline.pspline3calc(ref p3, t3[i] + AP.Math.RandomInteger(10) - 5, ref vx, ref vy, ref vz);
p3errors = p3errors | (double)(Math.Abs(vx - x[i])) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - y[i])) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - z[i])) > (double)(threshold);
pspline.pspline3diff(ref p3, t3[i] + AP.Math.RandomInteger(10) - 5, ref vx, ref vdx, ref vy, ref vdy, ref vz, ref vdz);
p3errors = p3errors | (double)(Math.Abs(vx - x[i])) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - y[i])) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - z[i])) > (double)(threshold);
pspline.pspline3diff2(ref p3, t3[i] + AP.Math.RandomInteger(10) - 5, ref vx, ref vdx, ref vd2x, ref vy, ref vdy, ref vd2y, ref vz, ref vdz, ref vd2z);
p3errors = p3errors | (double)(Math.Abs(vx - x[i])) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - y[i])) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - z[i])) > (double)(threshold);
}
//
// periodicity between nodes
//
v0 = AP.Math.RandomReal();
pspline.pspline2calc(ref p2, v0, ref vx, ref vy);
pspline.pspline2calc(ref p2, v0 + AP.Math.RandomInteger(10) - 5, ref vx2, ref vy2);
p2errors = p2errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
pspline.pspline3calc(ref p3, v0, ref vx, ref vy, ref vz);
pspline.pspline3calc(ref p3, v0 + AP.Math.RandomInteger(10) - 5, ref vx2, ref vy2, ref vz2);
p3errors = p3errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - vz2)) > (double)(threshold);
//
// near-boundary test for continuity of function values and derivatives:
// 2-dimensional curve
//
System.Diagnostics.Debug.Assert(skind == 1 | skind == 2, "TEST: unexpected spline type!");
v0 = 100 * AP.Math.MachineEpsilon;
v1 = 1 - v0;
pspline.pspline2calc(ref p2, v0, ref vx, ref vy);
pspline.pspline2calc(ref p2, v1, ref vx2, ref vy2);
p2errors = p2errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
pspline.pspline2diff(ref p2, v0, ref vx, ref vdx, ref vy, ref vdy);
pspline.pspline2diff(ref p2, v1, ref vx2, ref vdx2, ref vy2, ref vdy2);
p2errors = p2errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vdx - vdx2)) > (double)(nonstrictthreshold);
p2errors = p2errors | (double)(Math.Abs(vdy - vdy2)) > (double)(nonstrictthreshold);
pspline.pspline2diff2(ref p2, v0, ref vx, ref vdx, ref vd2x, ref vy, ref vdy, ref vd2y);
pspline.pspline2diff2(ref p2, v1, ref vx2, ref vdx2, ref vd2x2, ref vy2, ref vdy2, ref vd2y2);
p2errors = p2errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vdx - vdx2)) > (double)(nonstrictthreshold);
p2errors = p2errors | (double)(Math.Abs(vdy - vdy2)) > (double)(nonstrictthreshold);
if (skind == 2)
{
//
// second derivative test only for cubic splines
//
p2errors = p2errors | (double)(Math.Abs(vd2x - vd2x2)) > (double)(nonstrictthreshold);
p2errors = p2errors | (double)(Math.Abs(vd2y - vd2y2)) > (double)(nonstrictthreshold);
}
//
// near-boundary test for continuity of function values and derivatives:
// 3-dimensional curve
//
System.Diagnostics.Debug.Assert(skind == 1 | skind == 2, "TEST: unexpected spline type!");
v0 = 100 * AP.Math.MachineEpsilon;
v1 = 1 - v0;
pspline.pspline3calc(ref p3, v0, ref vx, ref vy, ref vz);
pspline.pspline3calc(ref p3, v1, ref vx2, ref vy2, ref vz2);
p3errors = p3errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - vz2)) > (double)(threshold);
pspline.pspline3diff(ref p3, v0, ref vx, ref vdx, ref vy, ref vdy, ref vz, ref vdz);
pspline.pspline3diff(ref p3, v1, ref vx2, ref vdx2, ref vy2, ref vdy2, ref vz2, ref vdz2);
p3errors = p3errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - vz2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vdx - vdx2)) > (double)(nonstrictthreshold);
p3errors = p3errors | (double)(Math.Abs(vdy - vdy2)) > (double)(nonstrictthreshold);
p3errors = p3errors | (double)(Math.Abs(vdz - vdz2)) > (double)(nonstrictthreshold);
pspline.pspline3diff2(ref p3, v0, ref vx, ref vdx, ref vd2x, ref vy, ref vdy, ref vd2y, ref vz, ref vdz, ref vd2z);
pspline.pspline3diff2(ref p3, v1, ref vx2, ref vdx2, ref vd2x2, ref vy2, ref vdy2, ref vd2y2, ref vz2, ref vdz2, ref vd2z2);
p3errors = p3errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - vz2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vdx - vdx2)) > (double)(nonstrictthreshold);
p3errors = p3errors | (double)(Math.Abs(vdy - vdy2)) > (double)(nonstrictthreshold);
p3errors = p3errors | (double)(Math.Abs(vdz - vdz2)) > (double)(nonstrictthreshold);
if (skind == 2)
{
//
// second derivative test only for cubic splines
//
p3errors = p3errors | (double)(Math.Abs(vd2x - vd2x2)) > (double)(nonstrictthreshold);
p3errors = p3errors | (double)(Math.Abs(vd2y - vd2y2)) > (double)(nonstrictthreshold);
p3errors = p3errors | (double)(Math.Abs(vd2z - vd2z2)) > (double)(nonstrictthreshold);
}
}
}
}
}
}
//
// Test differentiation, tangents, calculation between nodes.
//
// Because differentiation is done in parameterization/spline/periodicity
// oblivious manner, we don't have to test all possible combinations
// of spline types and parameterizations.
//
// Actually we test special combination with properties which allow us
// to easily solve this problem:
// * 2 (3) variables
// * first variable is sampled from equidistant grid on [0,1]
// * other variables are random
// * uniform parameterization is used
// * periodicity - none
// * spline type - any (we use cubic splines)
// Same problem allows us to test calculation BETWEEN nodes.
//
for (n = 2; n <= maxn; n++)
{
//
// init
//
xy = new double[n, 2];
xyz = new double[n, 3];
apserv.taskgenint1dequidist(0, +1, n, ref t, ref x);
for (i_ = 0; i_ <= n - 1; i_++)
{
xy[i_, 0] = x[i_];
}
for (i_ = 0; i_ <= n - 1; i_++)
{
xyz[i_, 0] = x[i_];
}
apserv.taskgenint1dequidist(0, +1, n, ref t, ref y);
for (i_ = 0; i_ <= n - 1; i_++)
{
xy[i_, 1] = y[i_];
}
for (i_ = 0; i_ <= n - 1; i_++)
{
xyz[i_, 1] = y[i_];
}
apserv.taskgenint1dequidist(0, +1, n, ref t, ref z);
for (i_ = 0; i_ <= n - 1; i_++)
{
xyz[i_, 2] = z[i_];
}
unsetp2(ref p2);
unsetp3(ref p3);
pspline.pspline2build(xy, n, 2, 0, ref p2);
pspline.pspline3build(xyz, n, 2, 0, ref p3);
//
// Test 2D/3D spline:
// * build non-parametric cubic spline from T and X/Y
// * calculate its value and derivatives at V0
// * compare with Spline2Calc/Spline2Diff/Spline2Diff2
// Because of task properties both variants should
// return same answer.
//
v0 = AP.Math.RandomReal();
spline1d.spline1dbuildcubic(t, x, n, 0, 0.0, 0, 0.0, ref s);
spline1d.spline1ddiff(ref s, v0, ref vx2, ref vdx2, ref vd2x2);
spline1d.spline1dbuildcubic(t, y, n, 0, 0.0, 0, 0.0, ref s);
spline1d.spline1ddiff(ref s, v0, ref vy2, ref vdy2, ref vd2y2);
spline1d.spline1dbuildcubic(t, z, n, 0, 0.0, 0, 0.0, ref s);
spline1d.spline1ddiff(ref s, v0, ref vz2, ref vdz2, ref vd2z2);
//
// 2D test
//
pspline.pspline2calc(ref p2, v0, ref vx, ref vy);
p2errors = p2errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
pspline.pspline2diff(ref p2, v0, ref vx, ref vdx, ref vy, ref vdy);
p2errors = p2errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vdx - vdx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vdy - vdy2)) > (double)(threshold);
pspline.pspline2diff2(ref p2, v0, ref vx, ref vdx, ref vd2x, ref vy, ref vdy, ref vd2y);
p2errors = p2errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vdx - vdx2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vdy - vdy2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vd2x - vd2x2)) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vd2y - vd2y2)) > (double)(threshold);
//
// 3D test
//
pspline.pspline3calc(ref p3, v0, ref vx, ref vy, ref vz);
p3errors = p3errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - vz2)) > (double)(threshold);
pspline.pspline3diff(ref p3, v0, ref vx, ref vdx, ref vy, ref vdy, ref vz, ref vdz);
p3errors = p3errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - vz2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vdx - vdx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vdy - vdy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vdz - vdz2)) > (double)(threshold);
pspline.pspline3diff2(ref p3, v0, ref vx, ref vdx, ref vd2x, ref vy, ref vdy, ref vd2y, ref vz, ref vdz, ref vd2z);
p3errors = p3errors | (double)(Math.Abs(vx - vx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - vy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - vz2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vdx - vdx2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vdy - vdy2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vdz - vdz2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vd2x - vd2x2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vd2y - vd2y2)) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vd2z - vd2z2)) > (double)(threshold);
//
// Test tangents for 2D/3D
//
pspline.pspline2tangent(ref p2, v0, ref vx, ref vy);
p2errors = p2errors | (double)(Math.Abs(vx - vdx2 / apserv.safepythag2(vdx2, vdy2))) > (double)(threshold);
p2errors = p2errors | (double)(Math.Abs(vy - vdy2 / apserv.safepythag2(vdx2, vdy2))) > (double)(threshold);
pspline.pspline3tangent(ref p3, v0, ref vx, ref vy, ref vz);
p3errors = p3errors | (double)(Math.Abs(vx - vdx2 / apserv.safepythag3(vdx2, vdy2, vdz2))) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vy - vdy2 / apserv.safepythag3(vdx2, vdy2, vdz2))) > (double)(threshold);
p3errors = p3errors | (double)(Math.Abs(vz - vdz2 / apserv.safepythag3(vdx2, vdy2, vdz2))) > (double)(threshold);
}
//
// Arc length test.
//
// Simple problem with easy solution (points on a straight line with
// uniform parameterization).
//
for (n = 2; n <= maxn; n++)
{
xy = new double[n, 2];
xyz = new double[n, 3];
for (i = 0; i <= n - 1; i++)
{
xy[i, 0] = i;
xy[i, 1] = i;
xyz[i, 0] = i;
xyz[i, 1] = i;
xyz[i, 2] = i;
}
pspline.pspline2build(xy, n, 1, 0, ref p2);
pspline.pspline3build(xyz, n, 1, 0, ref p3);
a = AP.Math.RandomReal();
b = AP.Math.RandomReal();
p2errors = p2errors | (double)(Math.Abs(pspline.pspline2arclength(ref p2, a, b) - (b - a) * Math.Sqrt(2) * (n - 1))) > (double)(nonstrictthreshold);
p3errors = p3errors | (double)(Math.Abs(pspline.pspline3arclength(ref p3, a, b) - (b - a) * Math.Sqrt(3) * (n - 1))) > (double)(nonstrictthreshold);
}
//
// report
//
waserrors = p2errors | p3errors;
if (!silent)
{
System.Console.Write("TESTING SPLINE INTERPOLATION");
System.Console.WriteLine();
//
// Normal tests
//
System.Console.Write("2D TEST: ");
if (p2errors)
{
System.Console.Write("FAILED");
System.Console.WriteLine();
}
else
{
System.Console.Write("OK");
System.Console.WriteLine();
}
System.Console.Write("3D TEST: ");
if (p3errors)
{
System.Console.Write("FAILED");
System.Console.WriteLine();
}
else
{
System.Console.Write("OK");
System.Console.WriteLine();
}
if (waserrors)
{
System.Console.Write("TEST FAILED");
System.Console.WriteLine();
}
else
{
System.Console.Write("TEST PASSED");
System.Console.WriteLine();
}
System.Console.WriteLine();
System.Console.WriteLine();
}
//
// end
//
result = !waserrors;
return(result);
}
