private static void nearest_interp_1d_test01(int prob, int ni)
//****************************************************************************80
//
// Purpose:
//
// NEAREST_INTERP_1D_TEST01 tests NEAREST_INTERP_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 05 September 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the index of the problem.
//
// Input, int NI, the number of interpolation points.
//
{
int j;
Console.WriteLine("");
Console.WriteLine("NEAREST_INTERP_1D_TEST01");
Console.WriteLine(" Sample the nearest neighbor interpolant for problem # " + prob + "");
int nd = TestInterp.p00_data_num(prob);
double[] d = TestInterp.p00_data(prob, 2, nd);
double[] xd = new double[nd];
double[] yd = new double[nd];
for (j = 0; j < nd; j++)
{
xd[j] = d[0 + j * 2];
yd[j] = d[1 + j * 2];
}
double xd_min = typeMethods.r8vec_min(nd, xd);
double xd_max = typeMethods.r8vec_max(nd, xd);
double[] xi = typeMethods.r8vec_linspace_new(ni, xd_min, xd_max);
double[] yi = Nearest1D.nearest_interp_1d(nd, xd, yd, ni, xi);
string title = "X, Y for problem " + prob;
typeMethods.r8vec2_print(ni, xi, yi, title);
}
private static void pwl_interp_1d_test01(int prob)
//****************************************************************************80
//
// Purpose:
//
// PWL_INTERP_1D_TEST01 tests PWL_INTERP_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 31 May 2013
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the problem index.
//
{
List <string> command_unit = new();
List <string> data_unit = new();
int i;
List <string> interp_unit = new();
int j;
Console.WriteLine("");
Console.WriteLine("PWL_INTERP_1D_TEST01:");
Console.WriteLine(" PWL_INTERP_1D evaluates the piecewise linear interpolant.");
Console.WriteLine(" Interpolate data from TEST_INTERP problem #" + prob + "");
int nd = TestInterp.p00_data_num(prob);
Console.WriteLine(" Number of data points = " + nd + "");
double[] xy = TestInterp.p00_data(prob, 2, nd);
typeMethods.r8mat_transpose_print(2, nd, xy, " Data array:");
double[] xd = new double[nd];
double[] yd = new double[nd];
for (i = 0; i < nd; i++)
{
xd[i] = xy[0 + 2 * i];
yd[i] = xy[1 + 2 * i];
}
//
// #1: Does interpolant match function at interpolation points?
//
int ni = nd;
double[] xi = new double[ni];
for (i = 0; i < ni; i++)
{
xi[i] = xd[i];
}
double[] yi = Interp1D.pwl_value_1d(nd, xd, yd, ni, xi);
double interp_error = typeMethods.r8vec_diff_norm(ni, yi, yd) / ni;
Console.WriteLine("");
Console.WriteLine(" L2 interpolation error averaged per interpolant node = " + interp_error + "");
//
// Create data file.
//
string data_filename = "data" + prob + ".txt";
for (j = 0; j < nd; j++)
{
data_unit.Add(" " + xd[j]
+ " " + yd[j] + "");
}
File.WriteAllLines(data_filename, data_unit);
Console.WriteLine("");
Console.WriteLine(" Created graphics data file \"" + data_filename + "\".");
//
// Create interp file.
//
ni = 501;
double xmin = typeMethods.r8vec_min(nd, xd);
double xmax = typeMethods.r8vec_max(nd, xd);
xi = typeMethods.r8vec_linspace_new(ni, xmin, xmax);
yi = Interp1D.pwl_value_1d(nd, xd, yd, ni, xi);
string interp_filename = "interp" + prob + ".txt";
for (j = 0; j < ni; j++)
{
interp_unit.Add(" " + xi[j]
+ " " + yi[j] + "");
}
File.WriteAllLines(interp_filename, interp_unit);
Console.WriteLine(" Created graphics interp file \"" + interp_filename + "\".");
//
// Plot the data and the interpolant.
//
string command_filename = "commands" + prob + ".txt";
string output_filename = "plot" + prob + ".png";
command_unit.Add("# " + command_filename + "");
command_unit.Add("#");
command_unit.Add("# Usage:");
command_unit.Add("# gnuplot < " + command_filename + "");
command_unit.Add("#");
command_unit.Add("set term png");
command_unit.Add("set output '" + output_filename + "'");
command_unit.Add("set xlabel '<---X--->'");
command_unit.Add("set ylabel '<---Y--->'");
command_unit.Add("set title 'Data versus Nearest Neighbor Interpolant'");
command_unit.Add("set grid");
command_unit.Add("set style data lines");
command_unit.Add("plot '" + data_filename
+ "' using 1:2 with points pt 7 ps 2 lc rgb 'blue',\\");
command_unit.Add(" '" + interp_filename
+ "' using 1:2 lw 3 linecolor rgb 'red'");
File.WriteAllLines(command_filename, command_unit);
Console.WriteLine(" Created graphics command file \"" + command_filename + "\".");
}
private static void test01(int prob, int m)
//****************************************************************************80
//
// Purpose:
//
// TEST01 tests VANDERMONDE_APPROX_1D_MATRIX.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 10 October 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the problem number.
//
// Input, int M, the polynomial degree.
//
{
const bool debug = false;
int i;
Console.WriteLine("");
Console.WriteLine("TEST01:");
Console.WriteLine(" Approximate data from TEST_INTERP problem #" + prob + "");
int nd = TestInterp.p00_data_num(prob);
Console.WriteLine(" Number of data points = " + nd + "");
double[] xy = TestInterp.p00_data(prob, 2, nd);
switch (debug)
{
case true:
typeMethods.r8mat_transpose_print(2, nd, xy, " Data array:");
break;
}
double[] xd = new double[nd];
double[] yd = new double[nd];
for (i = 0; i < nd; i++)
{
xd[i] = xy[0 + i * 2];
yd[i] = xy[1 + i * 2];
}
//
// Compute the Vandermonde matrix.
//
Console.WriteLine(" Using polynomial approximant of degree " + m + "");
double[] a = VandermondeMatrix.vandermonde_approx_1d_matrix(nd, m, xd);
//
// Solve linear system.
//
double[] c = QRSolve.qr_solve(nd, m + 1, a, yd);
//
// #1: Does approximant match function at data points?
//
int ni = nd;
double[] xi = typeMethods.r8vec_copy_new(ni, xd);
double[] yi = Polynomial.r8poly_values(m, c, ni, xi);
double app_error = typeMethods.r8vec_norm_affine(ni, yi, yd) / ni;
Console.WriteLine("");
Console.WriteLine(" L2 data approximation error = " + app_error + "");
//
// #2: Compare estimated curve length to piecewise linear (minimal) curve length.
// Assume data is sorted, and normalize X and Y dimensions by (XMAX-XMIN) and
// (YMAX-YMIN).
//
double xmin = typeMethods.r8vec_min(nd, xd);
double xmax = typeMethods.r8vec_max(nd, xd);
double ymin = typeMethods.r8vec_min(nd, yd);
double ymax = typeMethods.r8vec_max(nd, yd);
ni = 501;
xi = typeMethods.r8vec_linspace_new(ni, xmin, xmax);
yi = Polynomial.r8poly_values(m, c, ni, xi);
double ld = 0.0;
for (i = 0; i < nd - 1; i++)
{
ld += Math.Sqrt(Math.Pow((xd[i + 1] - xd[i]) / (xmax - xmin), 2)
+ Math.Pow((yd[i + 1] - yd[i]) / (ymax - ymin), 2));
}
double li = 0.0;
for (i = 0; i < ni - 1; i++)
{
li += Math.Sqrt(Math.Pow((xi[i + 1] - xi[i]) / (xmax - xmin), 2)
+ Math.Pow((yi[i + 1] - yi[i]) / (ymax - ymin), 2));
}
Console.WriteLine("");
Console.WriteLine(" Normalized length of piecewise linear interpolant = " + ld + "");
Console.WriteLine(" Normalized length of polynomial interpolant = " + li + "");
}
private static void test02(int prob)
//****************************************************************************80
//
// Purpose:
//
// TEST02 tests VANDERMONDE_INTERP_1D_MATRIX.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 02 June 2013
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the problem index.
//
{
List <string> command_unit = new();
List <string> data_unit = new();
int i;
List <string> interp_unit = new();
int j;
Console.WriteLine("");
Console.WriteLine("TEST02:");
Console.WriteLine(" VANDERMONDE_INTERP_1D_MATRIX sets the Vandermonde linear system");
Console.WriteLine(" for the interpolating polynomial.");
Console.WriteLine(" Interpolate data from TEST_INTERP problem #" + prob + "");
int nd = TestInterp.p00_data_num(prob);
Console.WriteLine(" Number of data points = " + nd + "");
double[] xy = TestInterp.p00_data(prob, 2, nd);
typeMethods.r8mat_transpose_print(2, nd, xy, " Data array:");
double[] xd = new double[nd];
double[] yd = new double[nd];
for (i = 0; i < nd; i++)
{
xd[i] = xy[0 + 2 * i];
yd[i] = xy[1 + 2 * i];
}
//
// Compute Vandermonde matrix and get condition number.
//
double[] ad = Vandermonde.vandermonde_matrix_1d(nd, xd);
//
// Solve linear system.
//
double[] cd = QRSolve.qr_solve(nd, nd, ad, yd);
//
// Create data file.
//
string data_filename = "data" + prob + ".txt";
for (j = 0; j < nd; j++)
{
data_unit.Add(" " + xd[j]
+ " " + yd[j] + "");
}
File.WriteAllLines(data_filename, data_unit);
Console.WriteLine("");
Console.WriteLine(" Created graphics data file \"" + data_filename + "\".");
//
// Create interp file.
//
int ni = 501;
double xmin = typeMethods.r8vec_min(nd, xd);
double xmax = typeMethods.r8vec_max(nd, xd);
double[] xi = typeMethods.r8vec_linspace_new(ni, xmin, xmax);
double[] yi = Vandermonde.vandermonde_value_1d(nd, cd, ni, xi);
string interp_filename = "interp" + prob + ".txt";
for (j = 0; j < ni; j++)
{
interp_unit.Add(" " + xi[j]
+ " " + yi[j] + "");
}
File.WriteAllLines(interp_filename, interp_unit);
Console.WriteLine(" Created graphics interp file \"" + interp_filename + "\".");
//
// Plot the data and the interpolant.
//
string command_filename = "commands" + prob + ".txt";
string output_filename = "plot" + prob + ".png";
command_unit.Add("# " + command_filename + "");
command_unit.Add("#");
command_unit.Add("# Usage:");
command_unit.Add("# gnuplot < " + command_filename + "");
command_unit.Add("#");
command_unit.Add("set term png");
command_unit.Add("set output '" + output_filename + "'");
command_unit.Add("set xlabel '<---X--->'");
command_unit.Add("set ylabel '<---Y--->'");
command_unit.Add("set title 'Data versus Vandermonde polynomial interpolant'");
command_unit.Add("set grid");
command_unit.Add("set style data lines");
command_unit.Add("plot '" + data_filename
+ "' using 1:2 with points pt 7 ps 2 lc rgb 'blue',\\");
command_unit.Add(" '" + interp_filename
+ "' using 1:2 lw 3 linecolor rgb 'red'");
File.WriteAllLines(command_filename, command_unit);
Console.WriteLine(" Created graphics command file \"" + command_filename + "\".");
}
private static void test01(int prob)
//****************************************************************************80
//
// Purpose:
//
// TEST01 tests VANDERMONDE_INTERP_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 07 October 2012
//
// Author:
//
// John Burkardt
//
{
const bool debug = false;
int i;
Console.WriteLine("");
Console.WriteLine("TEST01:");
Console.WriteLine(" Interpolate data from TEST_INTERP problem #" + prob + "");
int nd = TestInterp.p00_data_num(prob);
Console.WriteLine(" Number of data points = " + nd + "");
double[] xy = TestInterp.p00_data(prob, 2, nd);
switch (debug)
{
case true:
typeMethods.r8mat_transpose_print(2, nd, xy, " Data array:");
break;
}
double[] xd = new double[nd];
double[] yd = new double[nd];
for (i = 0; i < nd; i++)
{
xd[i] = xy[0 + i * 2];
yd[i] = xy[1 + i * 2];
}
//
// Compute Vandermonde matrix and get condition number.
//
double[] ad = Vandermonde.vandermonde_matrix_1d(nd, xd);
double condition = Matrix.condition_hager(nd, ad);
Console.WriteLine("");
Console.WriteLine(" Condition of Vandermonde matrix is " + condition + "");
//
// Solve linear system.
//
double[] cd = QRSolve.qr_solve(nd, nd, ad, yd);
//
// #1: Does interpolant match function at interpolation points?
//
int ni = nd;
double[] xi = typeMethods.r8vec_copy_new(ni, xd);
double[] yi = Vandermonde.vandermonde_value_1d(nd, cd, ni, xi);
double int_error = typeMethods.r8vec_norm_affine(ni, yi, yd) / ni;
Console.WriteLine("");
Console.WriteLine(" L2 interpolation error averaged per interpolant node = " + int_error + "");
//
// #2: Compare estimated curve length to piecewise linear (minimal) curve length.
// Assume data is sorted, and normalize X and Y dimensions by (XMAX-XMIN) and
// (YMAX-YMIN).
//
double xmin = typeMethods.r8vec_min(nd, xd);
double xmax = typeMethods.r8vec_max(nd, xd);
double ymin = typeMethods.r8vec_min(nd, yd);
double ymax = typeMethods.r8vec_max(nd, yd);
ni = 501;
xi = typeMethods.r8vec_linspace_new(ni, xmin, xmax);
yi = Vandermonde.vandermonde_value_1d(nd, cd, ni, xi);
double ld = 0.0;
for (i = 0; i < nd - 1; i++)
{
ld += Math.Sqrt(Math.Pow((xd[i + 1] - xd[i]) / (xmax - xmin), 2)
+ Math.Pow((yd[i + 1] - yd[i]) / (ymax - ymin), 2));
}
double li = 0.0;
for (i = 0; i < ni - 1; i++)
{
li += Math.Sqrt(Math.Pow((xi[i + 1] - xi[i]) / (xmax - xmin), 2)
+ Math.Pow((yi[i + 1] - yi[i]) / (ymax - ymin), 2));
}
Console.WriteLine("");
Console.WriteLine(" Normalized length of piecewise linear interpolant = " + ld + "");
Console.WriteLine(" Normalized length of polynomial interpolant = " + li + "");
}
private static void test01(int prob, double p)
//****************************************************************************80
//
// Purpose:
//
// TEST01 tests SHEPARD_VALUE_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 01 October 2012
//
// Author:
//
// John Burkardt
//
{
int i;
Console.WriteLine("");
Console.WriteLine("TEST01:");
Console.WriteLine(" Interpolate data from TEST_INTERP problem #" + prob + "");
Console.WriteLine(" using Shepard interpolation with P = " + p + "");
int dim_num = TestInterp.p00_dim_num(prob);
int nd = TestInterp.p00_data_num(prob);
Console.WriteLine(" Number of data points = " + nd + "");
double[] xy = TestInterp.p00_data(prob, dim_num, nd);
switch (p)
{
case 0.0:
typeMethods.r8mat_transpose_print(2, nd, xy, " Data array:");
break;
}
double[] xd = new double[nd];
double[] yd = new double[nd];
for (i = 0; i < nd; i++)
{
xd[i] = xy[0 + i * 2];
yd[i] = xy[1 + i * 2];
}
//
// #1: Does interpolant match function at interpolation points?
//
int ni = nd;
double[] xi = new double[ni];
for (i = 0; i < ni; i++)
{
xi[i] = xd[i];
}
double[] yi = Shepard.shepard_value_1d(nd, xd, yd, p, ni, xi);
double int_error = typeMethods.r8vec_norm_affine(nd, yi, yd) / ni;
Console.WriteLine("");
Console.WriteLine(" L2 interpolation error averaged per interpolant node = "
+ int_error + "");
//
// #2: Compare estimated curve length to piecewise linear (minimal) curve length.
// Assume data is sorted, and normalize X and Y dimensions by (XMAX-XMIN) and
// (YMAX-YMIN).
//
double xmin = typeMethods.r8vec_min(nd, xd);
double xmax = typeMethods.r8vec_max(nd, xd);
double ymin = typeMethods.r8vec_min(nd, yd);
double ymax = typeMethods.r8vec_max(nd, yd);
ni = 501;
xi = typeMethods.r8vec_linspace_new(ni, xmin, xmax);
yi = Shepard.shepard_value_1d(nd, xd, yd, p, ni, xi);
double ld = 0.0;
for (i = 0; i < nd - 1; i++)
{
ld += Math.Sqrt(Math.Pow((xd[i + 1] - xd[i]) / (xmax - xmin), 2)
+ Math.Pow((yd[i + 1] - yd[i]) / (ymax - ymin), 2));
}
double li = 0.0;
for (i = 0; i < ni - 1; i++)
{
li += Math.Sqrt(Math.Pow((xi[i + 1] - xi[i]) / (xmax - xmin), 2)
+ Math.Pow((yi[i + 1] - yi[i]) / (ymax - ymin), 2));
}
Console.WriteLine("");
Console.WriteLine(" Normalized length of piecewise linear interpolant = " + ld + "");
Console.WriteLine(" Normalized length of Shepard interpolant = " + li + "");
}
private static void newton_interp_1d_test01(int prob)
//****************************************************************************80
//
// Purpose:
//
// NEWTON_INTERP_1D_TEST01 tests NEWTON_INTERP_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 10 July 2015
//
// Author:
//
// John Burkardt
//
{
List <string> command_unit = new();
List <string> data_unit = new();
int i;
List <string> interp_unit = new();
int j;
Console.WriteLine("");
Console.WriteLine("NEWTON_INTERP_1D_TEST01:");
Console.WriteLine(" Interpolate data from TEST_INTERP problem #" + prob + "");
int nd = TestInterp.p00_data_num(prob);
Console.WriteLine(" Number of data points = " + nd + "");
double[] xy = TestInterp.p00_data(prob, 2, nd);
double[] xd = new double[nd];
double[] yd = new double[nd];
for (i = 0; i < nd; i++)
{
xd[i] = xy[0 + i * 2];
yd[i] = xy[1 + i * 2];
}
typeMethods.r8vec2_print(nd, xd, yd, " X, Y data:");
//
// Get the Newton coefficients.
//
double[] cd = Newton1D.newton_coef_1d(nd, xd, yd);
//
// #1: Does interpolant match function at interpolation points?
//
int ni = nd;
double[] xi = typeMethods.r8vec_copy_new(ni, xd);
double[] yi = Newton1D.newton_value_1d(nd, xd, cd, ni, xi);
double interp_error = typeMethods.r8vec_norm_affine(ni, yi, yd) / ni;
Console.WriteLine("");
Console.WriteLine(" L2 interpolation error averaged per interpolant node = " + interp_error + "");
//
// #2: Compare estimated curve length to piecewise linear (minimal) curve length.
// Assume data is sorted, and normalize X and Y dimensions by (XMAX-XMIN) and
// (YMAX-YMIN).
//
double xmin = typeMethods.r8vec_min(nd, xd);
double xmax = typeMethods.r8vec_max(nd, xd);
double ymin = typeMethods.r8vec_min(nd, yd);
double ymax = typeMethods.r8vec_max(nd, yd);
ni = 501;
xi = typeMethods.r8vec_linspace_new(ni, xmin, xmax);
yi = Newton1D.newton_value_1d(nd, xd, cd, ni, xi);
double ld = 0.0;
for (i = 0; i < nd - 1; i++)
{
ld += Math.Sqrt(Math.Pow((xd[i + 1] - xd[i]) / (xmax - xmin), 2)
+ Math.Pow((yd[i + 1] - yd[i]) / (ymax - ymin), 2));
}
double li = 0.0;
for (i = 0; i < ni - 1; i++)
{
li += Math.Sqrt(Math.Pow((xi[i + 1] - xi[i]) / (xmax - xmin), 2)
+ Math.Pow((yi[i + 1] - yi[i]) / (ymax - ymin), 2));
}
Console.WriteLine("");
Console.WriteLine(" Normalized length of piecewise linear interpolant = " + ld + "");
Console.WriteLine(" Normalized length of Newton interpolant = " + li + "");
//
// Create data file.
//
string data_filename = "data" + prob + ".txt";
for (j = 0; j < nd; j++)
{
data_unit.Add(" " + xd[j]
+ " " + yd[j] + "");
}
File.WriteAllLines(data_filename, data_unit);
Console.WriteLine("");
Console.WriteLine(" Created graphics data file \"" + data_filename + "\".");
//
// Create interp file.
//
ni = 501;
xmin = typeMethods.r8vec_min(nd, xd);
xmax = typeMethods.r8vec_max(nd, xd);
xi = typeMethods.r8vec_linspace_new(ni, xmin, xmax);
yi = Newton1D.newton_value_1d(nd, xd, cd, ni, xi);
string interp_filename = "interp" + prob + ".txt";
if (interp_filename == null)
{
throw new ArgumentNullException(nameof(interp_filename));
}
for (j = 0; j < ni; j++)
{
interp_unit.Add(" " + xi[j]
+ " " + yi[j] + "");
}
File.WriteAllLines(interp_filename, interp_unit);
Console.WriteLine(" Created graphics interp file \"" + interp_filename + "\".");
//
// Plot the data and the interpolant.
//
string command_filename = "commands" + prob + ".txt";
string output_filename = "plot" + prob + ".png";
command_unit.Add("# " + command_filename + "");
command_unit.Add("#");
command_unit.Add("# Usage:");
command_unit.Add("# gnuplot < " + command_filename + "");
command_unit.Add("#");
command_unit.Add("set term png");
command_unit.Add("set output '" + output_filename + "'");
command_unit.Add("set xlabel '<---X--->'");
command_unit.Add("set ylabel '<---Y--->'");
command_unit.Add("set title 'Data versus Newton polynomial interpolant'");
command_unit.Add("set grid");
command_unit.Add("set style data lines");
command_unit.Add("plot '" + data_filename
+ "' using 1:2 with points pt 7 ps 2 lc rgb 'blue',\\");
command_unit.Add(" '" + interp_filename
+ "' using 1:2 lw 3 linecolor rgb 'red'");
File.WriteAllLines(command_filename, command_unit);
Console.WriteLine(" Created graphics command file \"" + command_filename + "\".");
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for RBF_INTERP_1D_TEST.
//
// Discussion:
//
// RBF_INTERP_1D_TEST tests the RBF_INTERP_1D library.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 05 October 2012
//
// Author:
//
// John Burkardt
//
{
int prob;
Console.WriteLine("");
Console.WriteLine("RBF_INTERP_1D_TEST:");
Console.WriteLine(" Test the RBF_INTERP_1D library.");
Console.WriteLine(" The R8LIB library is needed.");
Console.WriteLine(" The test needs the TEST_INTERP library.");
int prob_num = TestInterp.p00_prob_num();
for (prob = 1; prob <= prob_num; prob++)
{
//
// Determine an appropriate value of R0, the spacing parameter.
//
int nd = TestInterp.p00_data_num(prob);
double[] xy = TestInterp.p00_data(prob, 2, nd);
double[] xd = new double[nd];
int i;
for (i = 0; i < nd; i++)
{
xd[i] = xy[0 + i * 2];
}
double xmax = typeMethods.r8vec_max(nd, xd);
double xmin = typeMethods.r8vec_min(nd, xd);
double r0 = (xmax - xmin) / (nd - 1);
test01(prob, RadialBasisFunctions.phi1, "phi1", r0);
test01(prob, RadialBasisFunctions.phi2, "phi2", r0);
test01(prob, RadialBasisFunctions.phi3, "phi3", r0);
test01(prob, RadialBasisFunctions.phi4, "phi4", r0);
}
/*
* Terminate.
*/
Console.WriteLine("");
Console.WriteLine("RBF_INTERP_1D_TEST:");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
private static void test01(int prob, Func <int, double[], double, double[], double[]> phi,
string phi_name, double r0)
//****************************************************************************80
//
// Purpose:
//
// TEST01 tests RBF_INTERP_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 05 October 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the index of the problem.
//
// Input, double PHI ( int n, double r[], double r0, double v[] ),
// the name of the radial basis function.
//
// Input, string PHI_NAME, the name of the radial basis function.
//
// Input, double R0, the scale factor. Typically, this might be
// a small multiple of the average distance between points.
//
{
const bool debug = false;
int i;
Console.WriteLine("");
Console.WriteLine("TEST01:");
Console.WriteLine(" Interpolate data from TEST_INTERP problem #" + prob + "");
Console.WriteLine(" using radial basis function \"" + phi_name + "\".");
Console.WriteLine(" Scale factor R0 = " + r0 + "");
int nd = TestInterp.p00_data_num(prob);
Console.WriteLine(" Number of data points = " + nd + "");
double[] xy = TestInterp.p00_data(prob, 2, nd);
switch (debug)
{
case true:
typeMethods.r8mat_transpose_print(2, nd, xy, " Data array:");
break;
}
double[] xd = new double[nd];
double[] yd = new double[nd];
for (i = 0; i < nd; i++)
{
xd[i] = xy[0 + i * 2];
yd[i] = xy[1 + i * 2];
}
int m = 1;
double[] w = RadialBasisFunctions.rbf_weight(m, nd, xd, r0, phi, yd);
//
// #1: Does interpolant match function at interpolation points?
//
int ni = nd;
double[] xi = typeMethods.r8vec_copy_new(ni, xd);
double[] yi = RadialBasisFunctions.rbf_interp(m, nd, xd, r0, phi, w, ni, xi);
double int_error = typeMethods.r8vec_norm_affine(ni, yi, yd) / ni;
Console.WriteLine("");
Console.WriteLine(" L2 interpolation error averaged per interpolant node = " + int_error + "");
//
// #2: Compare estimated curve length to piecewise linear (minimal) curve length.
// Assume data is sorted, and normalize X and Y dimensions by (XMAX-XMIN) and
// (YMAX-YMIN).
//
double xmax = typeMethods.r8vec_max(nd, xd);
double xmin = typeMethods.r8vec_min(nd, xd);
double ymax = typeMethods.r8vec_max(nd, yd);
double ymin = typeMethods.r8vec_min(nd, yd);
ni = 501;
xi = typeMethods.r8vec_linspace_new(ni, xmin, xmax);
yi = RadialBasisFunctions.rbf_interp(m, nd, xd, r0, phi, w, ni, xi);
double ld = 0.0;
for (i = 0; i < nd - 1; i++)
{
ld += Math.Sqrt(Math.Pow((xd[i + 1] - xd[i]) / (xmax - xmin), 2)
+ Math.Pow((yd[i + 1] - yd[i]) / (ymax - ymin), 2));
}
double li = 0.0;
for (i = 0; i < ni - 1; i++)
{
li += Math.Sqrt(Math.Pow((xi[i + 1] - xi[i]) / (xmax - xmin), 2)
+ Math.Pow((yi[i + 1] - yi[i]) / (ymax - ymin), 2));
}
Console.WriteLine(" Normalized length of piecewise linear interpolant = " + ld + "");
Console.WriteLine(" Normalized length of polynomial interpolant = " + li + "");
}