private static void hermite_polynomial_test07() //****************************************************************************80 // // Purpose: // // HERMITE_POLYNOMIAL_TEST07 tests HE_QUADRATURE_RULE. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 08 March 2012 // // Author: // // John Burkardt // { int e; double[] f; int i; int n; double q; double q_exact; double[] w; double[] x; Console.WriteLine(""); Console.WriteLine("HERMITE_POLYNOMIAL_TEST07:"); Console.WriteLine(" HE_QUADRATURE_RULE computes the quadrature rule"); Console.WriteLine(" associated with He(n,x)"); n = 7; x = new double[n]; w = new double[n]; HermiteQuadrature.he_quadrature_rule(n, ref x, ref w); typeMethods.r8vec2_print(n, x, w, " X W"); Console.WriteLine(""); Console.WriteLine(" Use the quadrature rule to estimate:"); Console.WriteLine(""); Console.WriteLine(" Q = Integral ( -oo < X < +00 ) X^E exp(-X^2) dx"); Console.WriteLine(""); Console.WriteLine(" E Q_Estimate Q_Exact"); Console.WriteLine(""); f = new double[n]; for (e = 0; e <= 2 * n - 1; e++) { switch (e) { case 0: { for (i = 0; i < n; i++) { f[i] = 1.0; } break; } default: { for (i = 0; i < n; i++) { f[i] = Math.Pow(x[i], e); } break; } } q = typeMethods.r8vec_dot_product(n, w, f); q_exact = Integral.he_integral(e); Console.WriteLine(" " + e.ToString().PadLeft(2) + " " + q.ToString().PadLeft(14) + " " + q_exact.ToString().PadLeft(14) + ""); } }
public static double[] burgers_viscous_time_exact1(double nu, int vxn, double[] vx, int vtn, double[] vt) //****************************************************************************80 // // Purpose: // // BURGERS_VISCOUS_TIME_EXACT1 evaluates solution #1 to the Burgers equation. // // Discussion: // // The form of the Burgers equation considered here is // // du du d^2 u // -- + u * -- = nu * ----- // dt dx dx^2 // // for -1.0 < x < +1.0, and 0 < t. // // Initial conditions are u(x,0) = - sin(pi*x). Boundary conditions // are u(-1,t) = u(+1,t) = 0. The viscosity parameter nu is taken // to be 0.01 / pi, although this is not essential. // // The authors note an integral representation for the solution u(x,t), // and present a better version of the formula that is amenable to // approximation using Hermite quadrature. // // This program library does little more than evaluate the exact solution // at a user-specified set of points, using the quadrature rule. // Internally, the order of this quadrature rule is set to 8, but the // user can easily modify this value if greater accuracy is desired. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 18 November 2011 // // Author: // // John Burkardt. // // Reference: // // Claude Basdevant, Michel Deville, Pierre Haldenwang, J Lacroix, // J Ouazzani, Roger Peyret, Paolo Orlandi, Anthony Patera, // Spectral and finite difference solutions of the Burgers equation, // Computers and Fluids, // Volume 14, Number 1, 1986, pages 23-41. // // Parameters: // // Input, double NU, the viscosity. // // Input, int VXN, the number of spatial grid points. // // Input, double VX[VXN], the spatial grid points. // // Input, int VTN, the number of time grid points. // // Input, double VT[VTN], the time grid points. // // Output, double BURGERS_VISCOUS_TIME_EXACT1[VXN*VTN], the solution of // the Burgers equation at each space and time grid point. // { const int qn = 8; int vti; // // Compute the rule. // double[] qx = new double[qn]; double[] qw = new double[qn]; HermiteQuadrature.hermite_ek_compute(qn, ref qx, ref qw); // // Evaluate U(X,T) for later times. // double[] vu = new double[vxn * vtn]; for (vti = 0; vti < vtn; vti++) { int vxi; switch (vt[vti]) { case 0.0: { for (vxi = 0; vxi < vxn; vxi++) { vu[vxi + vti * vxn] = -Math.Sin(Math.PI * vx[vxi]); } break; } default: { for (vxi = 0; vxi < vxn; vxi++) { double top = 0.0; double bot = 0.0; int qi; for (qi = 0; qi < qn; qi++) { double c = 2.0 * Math.Sqrt(nu * vt[vti]); top -= qw[qi] * c *Math.Sin(Math.PI *(vx[vxi] - c * qx[qi])) * Math.Exp(-Math.Cos(Math.PI * (vx[vxi] - c * qx[qi])) / (2.0 * Math.PI * nu)); bot += qw[qi] * c * Math.Exp(-Math.Cos(Math.PI * (vx[vxi] - c * qx[qi])) / (2.0 * Math.PI *nu)); vu[vxi + vti * vxn] = top / bot; } } break; } } } return(vu); }
public static void product_mixed_growth_weight(int dim_num, int[] order_1d, int order_nd, int[] rule, int[] np, double[] p, Func <int, int, double[], double[], double[]>[] gw_compute_weights, ref double[] weight_nd) //****************************************************************************80 // // Purpose: // // PRODUCT_MIXED_GROWTH_WEIGHT computes the weights of a mixed product rule. // // Discussion: // // This routine computes the weights for a quadrature rule which is // a product of 1D rules of varying order and kind. // // The user must preallocate space for the output array WEIGHT_ND. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 20 June 2010 // // Author: // // John Burkardt // // Reference: // // Fabio Nobile, Raul Tempone, Clayton Webster, // A Sparse Grid Stochastic Collocation Method for Partial Differential // Equations with Random Input Data, // SIAM Journal on Numerical Analysis, // Volume 46, Number 5, 2008, pages 2309-2345. // // Parameters: // // Input, int DIM_NUM, the spatial dimension. // // Input, int ORDER_1D[DIM_NUM], the order of the 1D rules. // // Input, int ORDER_ND, the order of the product rule. // // Input, int RULE[DIM_NUM], the rule in each dimension. // 1, "CC", Clenshaw Curtis, Closed Fully Nested. // 2, "F2", Fejer Type 2, Open Fully Nested. // 3, "GP", Gauss Patterson, Open Fully Nested. // 4, "GL", Gauss Legendre, Open Weakly Nested. // 5, "GH", Gauss Hermite, Open Weakly Nested. // 6, "GGH", Generalized Gauss Hermite, Open Weakly Nested. // 7, "LG", Gauss Laguerre, Open Non Nested. // 8, "GLG", Generalized Gauss Laguerre, Open Non Nested. // 9, "GJ", Gauss Jacobi, Open Non Nested. // 10, "HGK", Hermite Genz-Keister, Open Fully Nested. // 11, "UO", User supplied Open, presumably Non Nested. // 12, "UC", User supplied Closed, presumably Non Nested. // // Input, int NP[DIM_NUM], the number of parameters used by each rule. // // Input, double P[sum(NP[*])], the parameters needed by each rule. // // Input, void ( *GW_COMPUTE_WEIGHTS[] ) ( int order, int np, double p[], double w[] ), // an array of pointers to functions which return the 1D quadrature weights // associated with each spatial dimension for which a Golub Welsch rule // is used. // // Output, double WEIGHT_ND[ORDER_ND], the product rule weights. // { int dim; int i; typeMethods.r8vecDPData data = new(); for (i = 0; i < order_nd; i++) { weight_nd[i] = 1.0; } int p_index = 0; for (dim = 0; dim < dim_num; dim++) { double[] weight_1d = new double[order_1d[dim]]; switch (rule[dim]) { case 1: ClenshawCurtis.clenshaw_curtis_compute_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 2: Fejer2.fejer2_compute_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 3: PattersonQuadrature.patterson_lookup_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 4: Legendre.QuadratureRule.legendre_compute_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 5: HermiteQuadrature.hermite_compute_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 6: HermiteQuadrature.gen_hermite_compute_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 7: Laguerre.QuadratureRule.laguerre_compute_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 8: Laguerre.QuadratureRule.gen_laguerre_compute_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 9: JacobiQuadrature.jacobi_compute_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 10: HermiteQuadrature.hermite_genz_keister_lookup_weights_np( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; case 11: case 12: gw_compute_weights[dim]( order_1d[dim], np[dim], p.Skip(+p_index).ToArray(), weight_1d); break; default: Console.WriteLine(""); Console.WriteLine("PRODUCT_MIXED_GROWTH_WEIGHT - Fatal error!"); Console.WriteLine(" Unexpected value of RULE[" + dim + "] = " + rule[dim] + "."); return; } p_index += np[dim]; typeMethods.r8vec_direct_product2(ref data, dim, order_1d[dim], weight_1d, dim_num, order_nd, ref weight_nd); } }
public static void sparse_grid_hermite_index(int dim_num, int level_max, int point_num, ref int[] grid_index, ref int[] grid_base) //****************************************************************************80 // // Purpose: // // SPARSE_GRID_HERMITE_INDEX indexes points in a Gauss-Hermite sparse grid. // // Discussion: // // The sparse grid is assumed to be formed from 1D Gauss-Hermite rules // of ODD order, which have the property that only the central abscissa, // X = 0.0, is "nested". // // The necessary dimensions of GRID_INDEX can be determined by // calling SPARSE_GRID_HERMITE_SIZE first. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 05 July 2008 // // Author: // // John Burkardt // // Reference: // // Fabio Nobile, Raul Tempone, Clayton Webster, // A Sparse Grid Stochastic Collocation Method for Partial Differential // Equations with Random Input Data, // SIAM Journal on Numerical Analysis, // Volume 46, Number 5, 2008, pages 2309-2345. // // Parameters: // // Input, int DIM_NUM, the spatial dimension. // // Input, int LEVEL_MAX, the maximum value of LEVEL. // // Input, int POINT_NUM, the total number of points in the grids. // // Output, int GRID_INDEX[DIM_NUM*POINT_NUM], a list of // point indices, representing a subset of the product grid of level // LEVEL_MAX, representing (exactly once) each point that will show up in a // sparse grid of level LEVEL_MAX. // // Output, int GRID_BASE[DIM_NUM*POINT_NUM], a list of // the orders of the Gauss-Hermite rules associated with each point // and dimension. // { int level; // // The outer loop generates LEVELs from LEVEL_MIN to LEVEL_MAX. // int point_num2 = 0; int level_min = Math.Max(0, level_max + 1 - dim_num); int[] grid_base2 = new int[dim_num]; int[] level_1d = new int[dim_num]; int[] order_1d = new int[dim_num]; for (level = level_min; level <= level_max; level++) { // // The middle loop generates the next partition LEVEL_1D(1:DIM_NUM) // that adds up to LEVEL. // bool more = false; int h = 0; int t = 0; for (;;) { Comp.comp_next(level, dim_num, ref level_1d, ref more, ref h, ref t); // // Transform each 1D level to a corresponding 1D order. // ClenshawCurtis.level_to_order_open(dim_num, level_1d, ref order_1d); int dim; for (dim = 0; dim < dim_num; dim++) { grid_base2[dim] = (order_1d[dim] - 1) / 2; } // // The product of the 1D orders gives us the number of points in this grid. // int order_nd = typeMethods.i4vec_product(dim_num, order_1d); // // The inner (hidden) loop generates all points corresponding to given grid. // int[] grid_index2 = Multigrid.multigrid_index_z(dim_num, order_1d, order_nd); // // Determine the first level of appearance of each of the points. // This allows us to flag certain points as being repeats of points // generated on a grid of lower level. // // This is SLIGHTLY tricky. // int[] grid_level = HermiteQuadrature.index_level_hermite(level, level_max, dim_num, order_nd, grid_index2, grid_base2); // // Only keep those points which first appear on this level. // int point; for (point = 0; point < order_nd; point++) { if (grid_level[point] != level) { continue; } for (dim = 0; dim < dim_num; dim++) { grid_index[dim + point_num2 * dim_num] = grid_index2[dim + point * dim_num]; grid_base[dim + point_num2 * dim_num] = grid_base2[dim]; } point_num2 += 1; } if (!more) { break; } } } }
public static void sparse_grid_hermite(int dim_num, int level_max, int point_num, ref double[] grid_weight, ref double[] grid_point) //****************************************************************************80 // // Purpose: // // SPARSE_GRID_HERMITE computes a sparse grid of Gauss-Hermite points. // // Discussion: // // The quadrature rule is associated with a sparse grid derived from // a Smolyak construction using a 1D Gauss-Hermite quadrature rule. // // The user specifies: // * the spatial dimension of the quadrature region, // * the level that defines the Smolyak grid. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 05 July 2008 // // Author: // // John Burkardt // // Reference: // // Fabio Nobile, Raul Tempone, Clayton Webster, // A Sparse Grid Stochastic Collocation Method for Partial Differential // Equations with Random Input Data, // SIAM Journal on Numerical Analysis, // Volume 46, Number 5, 2008, pages 2309-2345. // // Parameters: // // Input, int DIM_NUM, the spatial dimension. // // Input, int LEVEL_MAX, controls the size of the final sparse grid. // // Input, int POINT_NUM, the number of points in the grid, as determined // by SPARSE_GRID_HERM_SIZE. // // Output, double GRID_WEIGHT[POINT_NUM], the weights. // // Output, double GRID_POINT[DIM_NUM*POINT_NUM], the points. // { int level; int point; int point3 = 0; for (point = 0; point < point_num; point++) { grid_weight[point] = 0.0; } // // The outer loop generates LEVELs from LEVEL_MIN to LEVEL_MAX. // int point_num2 = 0; int level_min = Math.Max(0, level_max + 1 - dim_num); int[] grid_base2 = new int[dim_num]; int[] level_1d = new int[dim_num]; int[] order_1d = new int[dim_num]; for (level = level_min; level <= level_max; level++) { // // The middle loop generates the next partition LEVEL_1D(1:DIM_NUM) // that adds up to LEVEL. // bool more = false; int h = 0; int t = 0; for (;;) { Comp.comp_next(level, dim_num, ref level_1d, ref more, ref h, ref t); // // Transform each 1D level to a corresponding 1D order. // The relationship is the same as for other OPEN rules. // The GL rule differs from the other OPEN rules only in the nesting behavior. // ClenshawCurtis.level_to_order_open(dim_num, level_1d, ref order_1d); int dim; for (dim = 0; dim < dim_num; dim++) { grid_base2[dim] = (order_1d[dim] - 1) / 2; } // // The product of the 1D orders gives us the number of points in this grid. // int order_nd = typeMethods.i4vec_product(dim_num, order_1d); // // Compute the weights for this product grid. // double[] grid_weight2 = HermiteQuadrature.product_weight_hermite(dim_num, order_1d, order_nd); // // Now determine the coefficient of the weight. // int coeff = (int)(Math.Pow(-1, level_max - level) * Binomial.choose(dim_num - 1, level_max - level)); // // The inner (hidden) loop generates all points corresponding to given grid. // The grid indices will be between -M to +M, where 2*M + 1 = ORDER_1D(DIM). // int[] grid_index2 = Multigrid.multigrid_index_z(dim_num, order_1d, order_nd); // // Determine the first level of appearance of each of the points. // This allows us to flag certain points as being repeats of points // generated on a grid of lower level. // // This is SLIGHTLY tricky. // int[] grid_level = HermiteQuadrature.index_level_hermite(level, level_max, dim_num, order_nd, grid_index2, grid_base2); // // Only keep those points which first appear on this level. // for (point = 0; point < order_nd; point++) { // // Either a "new" point (increase count, create point, create weight) // if (grid_level[point] == level) { HermiteQuadrature.hermite_abscissa(dim_num, 1, grid_index2, grid_base2, ref grid_point, gridIndex: +point * dim_num, gridPointIndex: +point_num2 * dim_num); grid_weight[point_num2] = coeff * grid_weight2[point]; point_num2 += 1; } // // or an already existing point (create point temporarily, find match, // add weight to matched point's weight). // else { double[] grid_point_temp = new double[dim_num]; HermiteQuadrature.hermite_abscissa(dim_num, 1, grid_index2, grid_base2, ref grid_point_temp, gridIndex: +point * dim_num); int point2; for (point2 = 0; point2 < point_num2; point2++) { point3 = point2; for (dim = 0; dim < dim_num; dim++) { if (!(Math.Abs(grid_point[dim + point2 * dim_num] - grid_point_temp[dim]) > double.Epsilon)) { continue; } point3 = -1; break; } if (point3 == point2) { break; } } switch (point3) { case -1: Console.WriteLine(""); Console.WriteLine("SPARSE_GRID_HERM - Fatal error!"); Console.WriteLine(" Could not match point."); return; default: grid_weight[point3] += coeff * grid_weight2[point]; break; } } } if (!more) { break; } } } }
private static void Main(string[] args) //****************************************************************************80 // // Purpose: // // MAIN is the main program for INT_GEN_EXACTNESS_HERMITE. // // Discussion: // // This program investigates a generalized Gauss-Hermite quadrature rule // by using it to integrate monomials over (-oo,+oo), and comparing the // approximate result to the known exact value. // // The user specifies: // * the "root" name of the R, W and X files that specify the rule; // * DEGREE_MAX, the maximum monomial degree to be checked. // * ALPHA, the power of X used in the weight. // * OPTION, whether the rule is for |x|^alpha*exp(-x*x)*f(x) or f(x). // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 05 August 2009 // // Author: // // John Burkardt // { double alpha; int degree; int degree_max; int i; int option; string quad_filename; Console.WriteLine(""); Console.WriteLine("INT_EXACTNESS_GEN_HERMITE"); Console.WriteLine(""); Console.WriteLine(" Investigate the polynomial exactness of a generalized Gauss-Hermite"); Console.WriteLine(" quadrature rule by integrating exponentially weighted"); Console.WriteLine(" monomials up to a given degree over the (-oo,+oo) interval."); // // Get the quadrature file rootname. // try { quad_filename = args[0]; } catch { Console.WriteLine(""); Console.WriteLine(" Enter the quadrature file rootname:"); quad_filename = Console.ReadLine(); } Console.WriteLine(""); Console.WriteLine(" The quadrature file rootname is \"" + quad_filename + "\"."); // // Create the names of: // the quadrature X file; // the quadrature W file; // the quadrature R file; // string quad_w_filename = quad_filename + "_w.txt"; string quad_x_filename = quad_filename + "_x.txt"; string quad_r_filename = quad_filename + "_r.txt"; // // Get the maximum degree: // try { degree_max = Convert.ToInt32(args[1]); } catch { Console.WriteLine(""); Console.WriteLine(" Enter DEGREE_MAX, the maximum monomial degree to check."); degree_max = Convert.ToInt32(Console.ReadLine()); } Console.WriteLine(""); Console.WriteLine(" The requested maximum monomial degree is = " + degree_max + ""); // // Get the power of X: // try { alpha = Convert.ToDouble(args[2]); } catch { Console.WriteLine(""); Console.WriteLine(" ALPHA is the power of |X| in the weighting function"); Console.WriteLine(""); Console.WriteLine(" ALPHA is a real number greater than -1.0."); Console.WriteLine(""); Console.WriteLine(" Please enter ALPHA."); alpha = Convert.ToDouble(Console.ReadLine()); } Console.WriteLine(""); Console.WriteLine(" The requested power of |X| is = " + alpha + ""); // // The fourth command line argument is OPTION. // 0 for the standard rule for integrating |x|^alpha*exp(-x*x)*f(x), // 1 for a rule for integrating f(x). // try { option = Convert.ToInt32(args[3]); } catch { Console.WriteLine(""); Console.WriteLine("OPTION chooses the standard or modified rule."); Console.WriteLine("0: standard rule for integrating |x|^alpha*exp(-x*x)*f(x)"); Console.WriteLine("1: modified rule for integrating f(x)"); option = Convert.ToInt32(Console.ReadLine()); } // // Summarize the input. // Console.WriteLine(""); Console.WriteLine("INT_EXACTNESS_GEN_HERMITE: User input:"); Console.WriteLine(" Quadrature rule X file = \"" + quad_x_filename + "\"."); Console.WriteLine(" Quadrature rule W file = \"" + quad_w_filename + "\"."); Console.WriteLine(" Quadrature rule R file = \"" + quad_r_filename + "\"."); Console.WriteLine(" Maximum degree to check = " + degree_max + ""); Console.WriteLine(" Power of |X|, ALPHA = " + alpha + ""); switch (option) { case 0: Console.WriteLine(" OPTION = 0, integrate |x|^alpha*exp(-x*x)*f(x)"); break; default: Console.WriteLine(" OPTION = 1, integrate f(x)"); break; } // // Read the X file. // TableHeader h = typeMethods.r8mat_header_read(quad_x_filename); int dim_num = h.m; int order = h.n; if (dim_num != 1) { Console.WriteLine(""); Console.WriteLine("INT_EXACTNESS_GEN_HERMITE - Fatal error!"); Console.WriteLine(" The spatial dimension of X should be 1."); Console.WriteLine(" The implicit input dimension was DIM_NUM = " + dim_num + ""); return; } Console.WriteLine(""); Console.WriteLine(" Spatial dimension = " + dim_num + ""); Console.WriteLine(" Number of points = " + order + ""); double[] x = typeMethods.r8mat_data_read(quad_x_filename, dim_num, order); // // Read the W file. // h = typeMethods.r8mat_header_read(quad_w_filename); int dim_num2 = h.m; int point_num = h.n; if (dim_num2 != 1) { Console.WriteLine(""); Console.WriteLine("INT_EXACTNESS_GEN_HERMITE - Fatal error!"); Console.WriteLine(" The quadrature weight file should have exactly"); Console.WriteLine(" one value on each line."); return; } if (point_num != order) { Console.WriteLine(""); Console.WriteLine("INT_EXACTNESS_GEN_HERMITE - Fatal error!"); Console.WriteLine(" The quadrature weight file should have exactly"); Console.WriteLine(" the same number of lines as the abscissa file."); return; } double[] w = typeMethods.r8mat_data_read(quad_w_filename, dim_num, order); // // Read the R file. // h = typeMethods.r8mat_header_read(quad_r_filename); dim_num2 = h.m; int point_num2 = h.n; if (dim_num2 != dim_num) { Console.WriteLine(""); Console.WriteLine("INT_EXACTNESS_GEN_HERMITE - Fatal error!"); Console.WriteLine(" The quadrature region file should have the"); Console.WriteLine(" same number of values on each line as the"); Console.WriteLine(" abscissa file does."); return; } if (point_num2 != 2) { Console.WriteLine(""); Console.WriteLine("INT_EXACTNESS_GEN_HERMITE - Fatal error!"); Console.WriteLine(" The quadrature region file should have two lines."); return; } double[] r = typeMethods.r8mat_data_read(quad_r_filename, dim_num, point_num2); // // Print the input quadrature rule. // Console.WriteLine(""); Console.WriteLine(" The quadrature rule to be tested is"); Console.WriteLine(" a generalized Gauss-Hermite rule"); Console.WriteLine(" ORDER = " + order + ""); Console.WriteLine(" ALPHA = " + alpha + ""); Console.WriteLine(""); switch (option) { case 0: Console.WriteLine(" OPTION = 0: Standard rule:"); Console.WriteLine(" Integral ( -oo < x < +oo ) |x|^alpha exp(-x*x) f(x) dx"); Console.WriteLine(" is to be approximated by"); Console.WriteLine(" sum ( 1 <= I <= ORDER ) w(i) * f(x(i))."); break; default: Console.WriteLine(" OPTION = 1: Modified rule:"); Console.WriteLine(" Integral ( -oo < x < +oo ) f(x) dx"); Console.WriteLine(" is to be approximated by"); Console.WriteLine(" sum ( 1 <= I <= ORDER ) w(i) * f(x(i))."); break; } Console.WriteLine(""); Console.WriteLine(" Weights W:"); Console.WriteLine(""); for (i = 0; i < order; i++) { Console.WriteLine(" w[" + i.ToString().PadLeft(2) + "] = " + w[i].ToString("0.################").PadLeft(24) + ""); } Console.WriteLine(""); Console.WriteLine(" Abscissas X:"); Console.WriteLine(""); for (i = 0; i < order; i++) { Console.WriteLine(" x[" + i.ToString().PadLeft(2) + "] = " + x[i].ToString("0.################").PadLeft(24) + ""); } Console.WriteLine(""); Console.WriteLine(" Region R:"); Console.WriteLine(""); for (i = 0; i < 2; i++) { Console.WriteLine(" r[" + i.ToString().PadLeft(2) + "] = " + r[i].ToString("0.################").PadLeft(24) + ""); } // // Explore the monomials. // Console.WriteLine(""); Console.WriteLine(" A generalized Gauss-Hermite rule would be able to exactly"); Console.WriteLine(" integrate monomials up to and including degree = " + (2 * order - 1) + ""); Console.WriteLine(""); Console.WriteLine(" Error Degree"); Console.WriteLine(""); for (degree = 0; degree <= degree_max; degree++) { double quad_error = HermiteQuadrature.monomial_quadrature_gen_hermite(degree, alpha, order, option, w, x); Console.WriteLine(" " + quad_error.ToString("0.################").PadLeft(24) + " " + degree.ToString().PadLeft(2) + ""); } Console.WriteLine(""); Console.WriteLine("INT_EXACTNESS_GEN_HERMITE:"); Console.WriteLine(" Normal end of execution."); Console.WriteLine(""); }
private static void test05(int dim_num, int level_max, int degree_max) //****************************************************************************80 // // Purpose: // // TEST05 tests a Gauss-Hermite sparse grid rule for monomial exactness. // // Discussion: // // This test is going to check EVERY monomial of total degree DEGREE_MAX // or less. Even for a moderately high dimension of DIM_NUM = 10, you // do NOT want to use a large value of DEGREE_MAX, since there are // // 1 monomials of total degree 0, // DIM_NUM monomials of total degree 1, // DIM_NUM^2 monomials of total degree 2, // DIM_NUM^3 monomials of total degree 3, and so on. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 05 July 2008 // // Author: // // John Burkardt // // Parameters: // // Input, int DIM_NUM, the spatial dimension. // // Input, int LEVEL_MAX, the level. // // Input, int DEGREE_MAX, the maximum monomial total degree to check. // { int degree; Console.WriteLine(""); Console.WriteLine("TEST05"); Console.WriteLine(" Check the exactness of a Gauss-Hermite sparse"); Console.WriteLine(" grid quadrature rule, applied to all monomials "); Console.WriteLine(" of orders 0 to DEGREE_MAX."); int level_min = Math.Max(0, level_max + 1 - dim_num); Console.WriteLine(""); Console.WriteLine(" LEVEL_MIN = " + level_min + ""); Console.WriteLine(" LEVEL_MAX = " + level_max + ""); Console.WriteLine(" Spatial dimension DIM_NUM = " + dim_num + ""); Console.WriteLine(""); Console.WriteLine(" The maximum total degree to be checked is DEGREE_MAX = " + degree_max + ""); // // Determine the number of points in the rule. // int point_num = Grid_Hermite.sparse_grid_hermite_size(dim_num, level_max); Console.WriteLine(""); Console.WriteLine(" Number of unique points in the grid = " + point_num + ""); // // Allocate space for the weights and points. // double[] grid_weight = new double[point_num]; double[] grid_point = new double[dim_num * point_num]; // // Compute the weights and points. // Grid_Hermite.sparse_grid_hermite(dim_num, level_max, point_num, ref grid_weight, ref grid_point); // // Explore the monomials. // int[] expon = new int[dim_num]; Console.WriteLine(""); Console.WriteLine(" Error Total Monomial"); Console.WriteLine(" Degree Exponents"); for (degree = 0; degree <= degree_max; degree++) { bool more = false; int h = 0; int t = 0; Console.WriteLine(""); for (;;) { Comp.comp_next(degree, dim_num, ref expon, ref more, ref h, ref t); double quad_error = HermiteQuadrature.monomial_quadrature_hermite(dim_num, expon, point_num, grid_weight, grid_point); string cout = " " + quad_error.ToString("0.#").PadLeft(12) + " " + degree.ToString(CultureInfo.InvariantCulture).PadLeft(2) + " "; int dim; for (dim = 0; dim < dim_num; dim++) { cout += expon[dim].ToString(CultureInfo.InvariantCulture).PadLeft(3); } Console.WriteLine(cout); if (!more) { break; } } } }