private static void lageven_interp_1d_test(int prob, int nd)
//****************************************************************************80
//
// Purpose:
//
// LAGEVEN_INTERP_1D_TEST tests LAGEVEN_INTERP_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 September 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the problem index.
//
// Input, int ND, the number of data points to use.
//
{
Console.WriteLine("");
Console.WriteLine("LAGEVEN_INTERP_1D_TEST:");
Console.WriteLine(" LAGEVEN_INTERP_1D uses even spacing for data points.");
Console.WriteLine(" Interpolate data from TEST_INTERP_1D problem #" + prob + "");
Console.WriteLine(" Number of data points = " + nd + "");
//
// Define the data.
//
const double a = 0.0;
const double b = +1.0;
double[] xd = typeMethods.r8vec_midspace_new(nd, a, b);
double[] yd = Data_1D.p00_f(prob, nd, xd);
switch (nd)
{
case < 10:
typeMethods.r8vec2_print(nd, xd, yd, " Data array:");
break;
}
//
// #1: Does the interpolant match the function at the interpolation points?
//
double[] xi = typeMethods.r8vec_copy_new(nd, xd);
double[] yi = BarycentricInterp1D.lageven_interp_1d(nd, xd, yd, nd, xi);
double int_error = typeMethods.r8vec_norm_affine(nd, yi, yd) / nd;
Console.WriteLine("");
Console.WriteLine(" L2 interpolation error averaged per interpolant node = " + int_error + "");
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for VANDERMONDE_APPROX_1D_TEST.
//
// Discussion:
//
// VANDERMONDE_APPROX_1D_TEST tests the VANDERMONDE_APPROX_1D library.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 10 October 2012
//
// Author:
//
// John Burkardt
//
{
int[] m_test = { 0, 1, 2, 3, 4, 5, 9, 12 };
const int m_test_num = 8;
int prob;
Console.WriteLine("");
Console.WriteLine("VANDERMONDE_APPROX_1D_TEST:");
Console.WriteLine(" Test the VANDERMONDE_APPROX_1D library.");
Console.WriteLine(" The R8LIB library is needed.");
Console.WriteLine(" The QR_SOLVE library is needed.");
Console.WriteLine(" The test needs the TEST_INTERP libary.");
int prob_num = Data_1D.p00_prob_num();
for (prob = 1; prob <= prob_num; prob++)
{
int j;
for (j = 0; j < m_test_num; j++)
{
int m = m_test[j];
test01(prob, m);
}
}
Console.WriteLine("");
Console.WriteLine("VANDERMONDE_APPROX_1D_TEST:");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for NEAREST_INTERP_1D_TEST.
//
// Discussion:
//
// NEAREST_INTERP_1D_TEST tests the NEAREST_INTERP_1D library.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 29 May 2013
//
// Author:
//
// John Burkardt
//
{
int prob;
Console.WriteLine("");
Console.WriteLine("NEAREST_INTERP_1D_TEST:");
Console.WriteLine(" Test the NEAREST_INTERP_1D library.");
Console.WriteLine(" The test needs the TEST_INTERP library.");
int prob_num = Data_1D.p00_prob_num();
int ni = 11;
for (prob = 1; prob <= prob_num; prob++)
{
nearest_interp_1d_test01(prob, ni);
}
for (prob = 1; prob <= prob_num; prob++)
{
nearest_interp_1d_test02(prob);
}
Console.WriteLine("");
Console.WriteLine("NEAREST_INTERP_1D_TEST:");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// NEWTON_INTERP_1D_TEST tests the NEWTON_INTERP_1D library.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 10 July 2015
//
// Author:
//
// John Burkardt
//
{
int prob;
Console.WriteLine("");
Console.WriteLine("NEWTON_INTERP_1D_TEST:");
Console.WriteLine(" Test the NEWTON_INTERP_1D library.");
Console.WriteLine(" The R8LIB library is needed.");
Console.WriteLine(" This test needs the TEST_INTERP library as well.");
newton_coef_1d_test();
newton_value_1d_test();
int prob_num = Data_1D.p00_prob_num();
for (prob = 1; prob <= prob_num; prob++)
{
newton_interp_1d_test01(prob);
}
Console.WriteLine("");
Console.WriteLine("NEWTON_INTERP_1D_TEST:");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
private static void test01(int prob, int nc, int nd)
//****************************************************************************80
//
// Purpose:
//
// TEST01 tests PWL_APPROX_1D.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 10 October 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the problem index.
//
// Input, int NC, the number of control points.
//
// Input, int ND, the number of data points.
//
{
Console.WriteLine("");
Console.WriteLine("TEST01:");
Console.WriteLine(" Approximate data from TEST_INTERP_1D problem #" + prob + "");
Console.WriteLine(" Number of control points = " + nc + "");
Console.WriteLine(" Number of data points = " + nd + "");
const double xmin = 0.0;
const double xmax = 1.0;
double[] xd = typeMethods.r8vec_linspace_new(nd, xmin, xmax);
double[] yd = Data_1D.p00_f(prob, nd, xd);
switch (nd)
{
case < 10:
typeMethods.r8vec2_print(nd, xd, yd, " Data array:");
break;
}
//
// Determine control values.
//
double[] xc = typeMethods.r8vec_linspace_new(nc, xmin, xmax);
double[] yc = Approx1D.pwl_approx_1d(nd, xd, yd, nc, xc);
//
// #1: Does approximant come close to function at data points?
//
double[] xi = typeMethods.r8vec_copy_new(nd, xd);
double[] yi = Approx1D.pwl_interp_1d(nc, xc, yc, nd, xi);
double app_error = typeMethods.r8vec_norm_affine(nd, yi, yd) / nd;
Console.WriteLine("");
Console.WriteLine(" L2 approximation error averaged per data node = " + app_error + "");
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for BARYCENTRIC_INTERP_1D_TEST.
//
// Discussion:
//
// BARYCENTRIC_INTERP_1D_TEST tests the BARYCENTRIC_INTERP_1D library.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 September 2012
//
// Author:
//
// John Burkardt
//
{
int i;
int nd;
int[] nd_test =
{
4, 8, 16, 32, 64, 1000
}
;
const int nd_test_num = 6;
int prob;
Console.WriteLine("");
Console.WriteLine("BARYCENTRIC_INTERP_1D_TEST:");
Console.WriteLine(" Test the BARYCENTRIC_INTERP_1D library.");
Console.WriteLine(" The R8LIB library is needed.");
Console.WriteLine(" The tests need the TEST_INTERP_1D library.");
int prob_num = Data_1D.p00_prob_num();
for (prob = 1; prob <= prob_num; prob++)
{
for (i = 0; i < nd_test_num; i++)
{
nd = nd_test[i];
lagcheby1_interp_1d_test(prob, nd);
}
}
for (prob = 1; prob <= prob_num; prob++)
{
for (i = 0; i < nd_test_num; i++)
{
nd = nd_test[i];
lagcheby2_interp_1d_test(prob, nd);
}
}
for (prob = 1; prob <= prob_num; prob++)
{
for (i = 0; i < nd_test_num; i++)
{
nd = nd_test[i];
lageven_interp_1d_test(prob, nd);
}
}
Console.WriteLine("");
Console.WriteLine("BARYCENTRIC_INTERP_1D_TEST:");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
private static void test02(int prob, int m, int nd)
//****************************************************************************80
//
// Purpose:
//
// TEST02 tests LAGRANGE_APPROX_1D with evenly spaced data
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 October 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the problem index.
//
// Input, int M, the polynomial approximant degree.
//
// Input, int ND, the number of data points.
//
{
Console.WriteLine("");
Console.WriteLine("TEST02:");
Console.WriteLine(" Approximate evenly spaced data from TEST_INTERP_1D problem #" + prob + "");
Console.WriteLine(" Use polynomial approximant of degree " + m + "");
Console.WriteLine(" Number of data points = " + nd + "");
const double a = 0.0;
const double b = 1.0;
double[] xd = typeMethods.r8vec_linspace_new(nd, a, b);
double[] yd = Data_1D.p00_f(prob, nd, xd);
switch (nd)
{
case < 10:
typeMethods.r8vec2_print(nd, xd, yd, " Data array:");
break;
}
//
// #1: Does approximant come close to function at data points?
//
int ni = nd;
double[] xi = typeMethods.r8vec_copy_new(ni, xd);
double[] yi = Lagrange1D.lagrange_approx_1d(m, nd, xd, yd, ni, xi);
double int_error = typeMethods.r8vec_norm_affine(nd, yi, yd) / ni;
Console.WriteLine("");
Console.WriteLine(" L2 approximation error averaged per data node = " + int_error + "");
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for LAGRANGE_APPROX_1D_TEST.
//
// Discussion:
//
// LAGRANGE_APPROX_1D_TEST tests the LAGRANGE_APPROX_1D library.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 October 2012
//
// Author:
//
// John Burkardt
//
{
int j;
int k;
int m;
int[] m_test =
{
0, 1, 2, 3, 4, 8, 16
}
;
const int m_test_num = 7;
int nd;
int[] nd_test =
{
16, 64, 1000
}
;
const int nd_test_num = 3;
int prob;
Console.WriteLine("");
Console.WriteLine("LAGRANGE_APPROX_1D_TEST:");
Console.WriteLine(" Test the LAGRANGE_APPROX_1D library.");
Console.WriteLine(" The R8LIB library is needed.");
Console.WriteLine(" The QR_SOLVE library is needed.");
Console.WriteLine(" These tests need the TEST_INTERP_1D library.");
int prob_num = Data_1D.p00_prob_num();
for (prob = 1; prob <= prob_num; prob++)
{
for (j = 0; j < m_test_num; j++)
{
m = m_test[j];
for (k = 0; k < nd_test_num; k++)
{
nd = nd_test[k];
test02(prob, m, nd);
}
}
}
for (prob = 1; prob <= prob_num; prob++)
{
for (j = 0; j < m_test_num; j++)
{
m = m_test[j];
for (k = 0; k < nd_test_num; k++)
{
nd = nd_test[k];
test03(prob, m, nd);
}
}
}
//
// Terminate.
//
Console.WriteLine("");
Console.WriteLine("LAGRANGE_APPROX_1D_TEST:");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for LAGRANGE_INTERP_1D_TEST.
//
// Discussion:
//
// LAGRANGE_INTERP_1D_TEST tests the LAGRANGE_INTERP_1D library.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 14 October 2012
//
// Author:
//
// John Burkardt
//
{
const int nd_test_num = 6;
int j;
int nd;
int[] nd_test =
{
4, 8, 16, 32, 64, 256
}
;
int prob;
Console.WriteLine("");
Console.WriteLine("LAGRANGE_INTERP_1D_TEST:");
Console.WriteLine(" Test the LAGRANGE_INTERP_1D library.");
Console.WriteLine(" The R8LIB library is needed.");
Console.WriteLine(" These tests need the TEST_INTERP_1D library.");
int prob_num = Data_1D.p00_prob_num();
for (prob = 1; prob <= prob_num; prob++)
{
for (j = 0; j < nd_test_num; j++)
{
nd = nd_test[j];
test01(prob, nd);
}
}
for (prob = 1; prob <= prob_num; prob++)
{
for (j = 0; j < nd_test_num; j++)
{
nd = nd_test[j];
test02(prob, nd);
}
}
//
// Terminate.
//
Console.WriteLine("");
Console.WriteLine("LAGRANGE_INTERP_1D_TEST:");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
private static void test01(int prob, int nd)
//*****************************************************************************80
//
// Purpose:
//
// TEST01 tests LAGRANGE_VALUE_1D with evenly spaced data.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 12 September 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int PROB, the problem index.
//
// Input, int ND, the number of data points to use.
//
{
int i;
Console.WriteLine("");
Console.WriteLine("TEST01:");
Console.WriteLine(" Interpolate data from TEST_INTERP_1D problem #" + prob + "");
Console.WriteLine(" Use even spacing for data points.");
Console.WriteLine(" Number of data points = " + nd + "");
const double a = 0.0;
const double b = 1.0;
double[] xd = typeMethods.r8vec_linspace_new(nd, a, b);
double[] yd = Data_1D.p00_f(prob, nd, xd);
switch (nd)
{
case < 10:
typeMethods.r8vec2_print(nd, xd, yd, " Data array:");
break;
}
//
// #1: Does interpolant match function at interpolation points?
//
int ni = nd;
double[] xi = typeMethods.r8vec_copy_new(ni, xd);
double[] yi = Lagrange1D.lagrange_value_1d(nd, xd, yd, 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 ymin = typeMethods.r8vec_min(nd, yd);
double ymax = typeMethods.r8vec_max(nd, yd);
ni = 501;
xi = typeMethods.r8vec_linspace_new(ni, a, b);
yi = Lagrange1D.lagrange_value_1d(nd, xd, yd, ni, xi);
double ld = 0.0;
for (i = 0; i < nd - 1; i++)
{
ld += Math.Sqrt(Math.Pow((xd[i + 1] - xd[i]) / (b - a), 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]) / (b - a), 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 + "");
}
