private static void test01(int prob, int grd, int m) //****************************************************************************80 // // Purpose: // // VANDERMONDE_APPROX_2D_TEST01 tests VANDERMONDE_APPROX_2D_MATRIX. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 11 October 2012 // // Author: // // John Burkardt // // Parameters: // // Input, int PROB, the problem number. // // Input, int GRD, the grid number. // (Can't use GRID as the name because that's also a plotting function.) // // Input, int M, the total polynomial degree. // { Console.WriteLine(""); Console.WriteLine("TEST01:"); Console.WriteLine(" Approximate data from TEST_INTERP_2D problem #" + prob + ""); Console.WriteLine(" Use grid from TEST_INTERP_2D with index #" + grd + ""); Console.WriteLine(" Using polynomial approximant of total degree " + m + ""); int nd = Data_2D.g00_size(grd); Console.WriteLine(" Number of data points = " + nd + ""); double[] xd = new double[nd]; double[] yd = new double[nd]; Data_2D.g00_xy(grd, nd, ref xd, ref yd); double[] zd = new double[nd]; Data_2D.f00_f0(prob, nd, xd, yd, ref zd); switch (nd) { case < 10: typeMethods.r8vec3_print(nd, xd, yd, zd, " X, Y, Z data:"); break; } // // Compute the Vandermonde matrix. // int tm = typeMethods.triangle_num(m + 1); double[] a = VandermondeMatrix.vandermonde_approx_2d_matrix(nd, m, tm, xd, yd); // // Solve linear system. // double[] c = QRSolve.qr_solve(nd, tm, a, zd); // // #1: Does approximant match function at data points? // int ni = nd; double[] xi = typeMethods.r8vec_copy_new(ni, xd); double[] yi = typeMethods.r8vec_copy_new(ni, yd); double[] zi = Polynomial.r8poly_values_2d(m, c, ni, xi, yi); double app_error = typeMethods.r8vec_norm_affine(ni, zi, zd) / ni; Console.WriteLine(""); Console.WriteLine(" L2 data approximation error = " + app_error + ""); }
private static void test01(int prob, int g, double p) //****************************************************************************80 // // Purpose: // // TEST01 tests SHEPARD_INTERP_2D. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 October 2012 // // Author: // // John Burkardt // // Parameters: // // Input, int PROB, the problem number. // // Input, int G, the grid number. // // Input, double P, the power used in the distance weighting. // { const bool debug = false; Console.WriteLine(""); Console.WriteLine("TEST01:"); Console.WriteLine(" Interpolate data from TEST_INTERP_2D problem #" + prob + ""); Console.WriteLine(" using grid #" + g + ""); Console.WriteLine(" using Shepard interpolation with P = " + p + ""); int nd = Data_2D.g00_size(g); Console.WriteLine(" Number of data points = " + nd + ""); double[] xd = new double[nd]; double[] yd = new double[nd]; Data_2D.g00_xy(g, nd, ref xd, ref yd); double[] zd = new double[nd]; Data_2D.f00_f0(prob, nd, xd, yd, ref zd); switch (debug) { case true: typeMethods.r8vec3_print(nd, xd, yd, zd, " X, Y, Z data:"); break; } // // #1: Does interpolant match function at interpolation points? // int ni = nd; double[] xi = typeMethods.r8vec_copy_new(ni, xd); double[] yi = typeMethods.r8vec_copy_new(ni, yd); double[] zi = Shepard.shepard_interp_2d(nd, xd, yd, zd, p, ni, xi, yi); double int_error = typeMethods.r8vec_norm_affine(ni, zi, zd) / ni; Console.WriteLine(""); Console.WriteLine(" L2 interpolation error averaged per interpolant node = " + int_error + ""); }
private static void test01(int prob, int g, Func <int, double[], double, double[], double[]> phi, string phi_name) //****************************************************************************80 // // Purpose: // // RBF_INTERP_2D_TEST01 tests RBF_INTERP_2D. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 06 October 2012 // // Author: // // John Burkardt // // Parameters: // // Input, int PROB, the index of the problem. // // Input, int G, the index of the grid. // // Input, void PHI ( int n, double r[], double r0, double v[] ), the // radial basis function. // // Input, string PHI_NAME, the name of the radial basis function. // { const bool debug = false; int i; Console.WriteLine(""); Console.WriteLine("RBF_INTERP_2D_TEST01:"); Console.WriteLine(" Interpolate data from TEST_INTERP_2D problem #" + prob + ""); Console.WriteLine(" using grid #" + g + ""); Console.WriteLine(" using radial basis function \"" + phi_name + "\"."); int nd = Data_2D.g00_size(g); Console.WriteLine(" Number of data points = " + nd + ""); double[] xd = new double[nd]; double[] yd = new double[nd]; Data_2D.g00_xy(g, nd, ref xd, ref yd); double[] zd = new double[nd]; Data_2D.f00_f0(prob, nd, xd, yd, ref zd); switch (debug) { case true: typeMethods.r8vec3_print(nd, xd, yd, zd, " X, Y, Z data:"); break; } const int m = 2; double[] xyd = new double[2 * nd]; for (i = 0; i < nd; i++) { xyd[0 + i * 2] = xd[i]; xyd[1 + i * 2] = yd[i]; } 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); double volume = (xmax - xmin) * (ymax - ymin); const double e = 1.0 / m; double r0 = Math.Pow(volume / nd, e); Console.WriteLine(" Setting R0 = " + r0 + ""); double[] w = RadialBasisFunctions.rbf_weight(m, nd, xyd, r0, phi, zd); // // #1: Does interpolant match function at interpolation points? // double[] xyi = typeMethods.r8mat_copy_new(2, nd, xyd); double[] zi = RadialBasisFunctions.rbf_interp(m, nd, xyd, r0, phi, w, nd, xyi); double int_error = typeMethods.r8vec_norm_affine(nd, zi, zd) / nd; Console.WriteLine(""); Console.WriteLine(" L2 interpolation error averaged per interpolant node = " + int_error + ""); }
private static void test03(int prob) //****************************************************************************80 // // Purpose: // // TEST03 tests PWL_INTERP_2D_SCATTERED_VALUE. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 25 October 2012 // // Author: // // John Burkardt // { int element_num = 0; int i; int j; const int ni = 25; double[] xi = new double[25]; double[] xyi = new double[2 * 25]; double[] yi = new double[25]; const int g = 2; int nd = Data_2D.g00_size(g); Console.WriteLine(""); Console.WriteLine("TEST03"); Console.WriteLine(" PWL_INTERP_2D_SCATTERED_VALUE evaluates a"); Console.WriteLine(" piecewise linear interpolant to scattered data."); Console.WriteLine(" Here, we use grid number " + g + ""); Console.WriteLine(" with " + nd + " scattered points in the unit square"); Console.WriteLine(" on problem " + prob + ""); // // Get the data points and evaluate the function there. // double[] xd = new double[nd]; double[] yd = new double[nd]; Data_2D.g00_xy(g, nd, ref xd, ref yd); double[] zd = new double[nd]; Data_2D.f00_f0(prob, nd, xd, yd, ref zd); double[] xyd = new double[2 * nd]; for (i = 0; i < nd; i++) { xyd[0 + i * 2] = xd[i]; xyd[1 + i * 2] = yd[i]; } // // Set up the Delaunay triangulation. // int[] element_neighbor = new int[3 * 2 * nd]; int[] triangle = new int[3 * 2 * nd]; Delauney.r8tris2(nd, ref xyd, ref element_num, ref triangle, ref element_neighbor); for (j = 0; j < element_num; j++) { for (i = 0; i < 3; i++) { switch (element_neighbor[i + j * 3]) { case > 0: element_neighbor[i + j * 3] -= 1; break; } } } // // Define the interpolation points. // int k = 0; for (i = 1; i <= 5; i++) { for (j = 1; j <= 5; j++) { xyi[0 + k * 2] = (2 * i - 1) / 10.0; xyi[1 + k * 2] = (2 * j - 1) / 10.0; k += 1; } } for (k = 0; k < ni; k++) { xi[k] = xyi[0 + k * 2]; yi[k] = xyi[1 + k * 2]; } double[] ze = new double[ni]; Data_2D.f00_f0(prob, ni, xi, yi, ref ze); // // Evaluate the interpolant. // double[] zi = Interp2D.pwl_interp_2d_scattered_value(nd, xyd, zd, element_num, triangle, element_neighbor, ni, xyi); double rms = 0.0; for (k = 0; k < ni; k++) { rms += Math.Pow(zi[k] - ze[k], 2); } rms = Math.Sqrt(rms / ni); Console.WriteLine(""); Console.WriteLine(" RMS error is " + rms + ""); Console.WriteLine(""); Console.WriteLine(" K Xi(K) Yi(K) Zi(K) Z(X,Y)"); Console.WriteLine(""); for (k = 0; k < ni; k++) { Console.WriteLine(" " + k.ToString().PadLeft(4) + " " + xyi[0 + k * 2].ToString(CultureInfo.InvariantCulture).PadLeft(10) + " " + xyi[1 + k * 2].ToString(CultureInfo.InvariantCulture).PadLeft(10) + " " + zi[k].ToString(CultureInfo.InvariantCulture).PadLeft(10) + " " + ze[k].ToString(CultureInfo.InvariantCulture).PadLeft(10) + ""); } }