public static double[] lagrange_interp_2d(int mx, int my, double[] xd_1d, double[] yd_1d,
double[] zd, int ni, double[] xi, double[] yi)
//****************************************************************************80
//
// Purpose:
//
// LAGRANGE_INTERP_2D evaluates the Lagrange interpolant for a product grid.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 13 September 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int MX, MY, the polynomial degree in X and Y.
//
// Input, double XD_1D[MX+1], YD_1D[MY+1], the 1D data locations.
//
// Input, double ZD[(MX+1)*(MY+1)], the 2D array of data values.
//
// Input, int NI, the number of 2D interpolation points.
//
// Input, double XI[NI], YI[NI], the 2D interpolation points.
//
// Output, double LAGRANGE_INTERP_2D[NI], the interpolated values.
//
{
int k;
double[] zi = new double[ni];
for (k = 0; k < ni; k++)
{
int l = 0;
zi[k] = 0.0;
int j;
for (j = 0; j < my + 1; j++)
{
int i;
for (i = 0; i < mx + 1; i++)
{
double lx = Lagrange1D.lagrange_basis_function_1d(mx, xd_1d, i, xi[k]);
double ly = Lagrange1D.lagrange_basis_function_1d(my, yd_1d, j, yi[k]);
zi[k] += zd[l] * lx * ly;
l += 1;
}
}
}
return(zi);
}
public static double[] lagrange_interp_nd_value2(int m, int[] ind, double[] a, double[] b,
int nd, double[] zd, int ni, double[] xi)
//****************************************************************************80
//
// Purpose:
//
// LAGRANGE_INTERP_ND_VALUE2 evaluates an ND Lagrange interpolant.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 30 September 2012
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int M, the spatial dimension.
//
// Input, int IND[M], the index or level of the 1D rule
// to be used in each dimension.
//
// Input, double A[M], B[M], the lower and upper limits.
//
// Input, int ND, the number of points in the product grid.
//
// Input, double ZD[ND], the function evaluated at the points XD.
//
// Input, int NI, the number of points at which the
// interpolant is to be evaluated.
//
// Input, double XI[M*NI], the points at which the interpolant
// is to be evaluated.
//
// Output, double ZI[NI], the interpolant evaluated at the
// points XI.
//
{
int j;
typeMethods.r8vecDPData data = new();
double[] w = new double[nd];
double[] zi = new double[ni];
for (j = 0; j < ni; j++)
{
int i;
for (i = 0; i < nd; i++)
{
w[i] = 1.0;
}
for (i = 0; i < m; i++)
{
int n = Order.order_from_level_135(ind[i]);
double[] x_1d = ClenshawCurtis.cc_compute_points(n);
int k;
for (k = 0; k < n; k++)
{
x_1d[k] = 0.5 * ((1.0 - x_1d[k]) * a[i]
+ (1.0 + x_1d[k]) * b[i]);
}
double[] value = Lagrange1D.lagrange_base_1d(n, x_1d, 1, xi, xiIndex: +i + j * m);
typeMethods.r8vec_direct_product2(ref data, i, n, value, m, nd, ref w);
}
zi[j] = typeMethods.r8vec_dot_product(nd, w, zd);
}
return(zi);
}
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 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 + "");
}
