private static void sgmga_unique_index_test(int dim_num, double[] importance, double[] level_weight, int level_max_min, int level_max_max, int[] rule, int[] growth, int[] np, double[] p, Func <int, int, double[], double[], double[]>[] gw_compute_points, double tol) //***************************************************************************80 // // Purpose: // // SGMGA_UNIQUE_INDEX_TEST tests SGMGA_UNIQUE_INDEX. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 09 June 2010 // // Author: // // John Burkardt // // Parameters: // // Input, int DIM_NUM, the spatial dimension. // // Input, double IMPORTANCE[DIM_NUM], the importance for each dimension. // // Input, double LEVEL_WEIGHT[DIM_NUM], the weights for each dimension. // // Input, int LEVEL_MAX_MIN, LEVEL_MAX_MAX, the minimum and // maximum values of LEVEL_MAX. // // 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 GROWTH[DIM_NUM], the desired growth in each dimension. // 0, "DF", default growth associated with this quadrature rule; // 1, "SL", slow linear, L+1; // 2 "SO", slow linear odd, O=1+2((L+1)/2) // 3, "ML", moderate linear, 2L+1; // 4, "SE", slow exponential; // 5, "ME", moderate exponential; // 6, "FE", full exponential. // // Input, int NP[RULE_NUM], the number of parameters used by each rule. // // Input, double P[sum(NP[*])], the parameters needed by each rule. // // Input, void ( *GW_COMPUTE_POINTS[] ) ( int order, int np, double p[], double x[] ), // an array of pointers to functions which return the 1D quadrature points // associated with each spatial dimension for which a Golub Welsch rule // is used. // // Input, double TOL, a tolerance for point equality. // { int dim; int level_max; Console.WriteLine(""); Console.WriteLine("SGMGA_UNIQUE_INDEX_TEST"); Console.WriteLine(" SGMGA_UNIQUE_INDEX returns a mapping between"); Console.WriteLine(" the nonunique and unique points in a sparse grid."); Console.WriteLine(""); string cout = " IMPORTANCE: "; for (dim = 0; dim < dim_num; dim++) { cout += " " + importance[dim].ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); cout = " LEVEL_WEIGHT:"; for (dim = 0; dim < dim_num; dim++) { cout += " " + level_weight[dim].ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); Console.WriteLine(""); Console.WriteLine(" Dimension Rule Growth rate Parameters"); Console.WriteLine(""); int p_index = 0; for (dim = 0; dim < dim_num; dim++) { double alpha; int i; switch (rule[dim]) { case 1: case 2: case 3: case 4: case 5: Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + ""); break; case 6: alpha = p[p_index]; p_index += 1; Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); break; case 7: Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + ""); break; case 8: alpha = p[p_index]; p_index += 1; Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); break; case 9: alpha = p[p_index]; p_index += 1; double beta = p[p_index]; p_index += 1; Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + beta.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); break; case 10: Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + ""); break; case 11: { cout = " " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8); for (i = 0; i < np[dim]; i++) { alpha = p[p_index]; p_index += 1; cout += " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); break; } case 12: { cout = " " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8); for (i = 0; i < np[dim]; i++) { alpha = p[p_index]; p_index += 1; cout += " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); break; } default: Console.WriteLine(""); Console.WriteLine("SGMGA_UNIQUE_INDEX_TEST - Fatal error!"); Console.WriteLine(" Unexpected value of RULE = " + rule[dim] + ""); return; } } for (level_max = level_max_min; level_max <= level_max_max; level_max++) { int point_total_num = SGMGAniso.sgmga_size_total(dim_num, level_weight, level_max, rule, growth); int point_num = SGMGAniso.sgmga_size(dim_num, level_weight, level_max, rule, np, p, gw_compute_points, tol, growth); Console.WriteLine(""); Console.WriteLine(" LEVEL_MAX POINT_NUM POINT_NUM"); Console.WriteLine(" Unique Total"); Console.WriteLine(""); Console.WriteLine(" " + level_max.ToString().PadLeft(8) + " " + point_num.ToString().PadLeft(8) + " " + point_total_num.ToString().PadLeft(8) + ""); int[] sparse_unique_index = new int[point_total_num]; SGMGAniso.sgmga_unique_index(dim_num, level_weight, level_max, rule, np, p, gw_compute_points, tol, point_num, point_total_num, growth, ref sparse_unique_index); Console.WriteLine(""); Console.WriteLine(" POINT UNIQUE"); Console.WriteLine(""); int point; for (point = 0; point < point_total_num; point++) { Console.WriteLine(" " + point.ToString().PadLeft(8) + " " + sparse_unique_index[point].ToString().PadLeft(8) + ""); } } }
private static void sgmga_write_test(int dim_num, double[] level_weight, int level_max, int[] rule, int[] growth, int[] np, double[] p, Func <int, int, double[], double[], double[]>[] gw_compute_points, Func <int, int, double[], double[], double[]>[] gw_compute_weights, double tol, string file_name) //***************************************************************************80 // // Purpose: // // SGMGA_WRITE_TEST tests SGMGA_WRITE. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 07 June 2010 // // Author: // // John Burkardt // // Parameters: // // Input, integer DIM_NUM, the spatial dimension. // // Input, double LEVEL_WEIGHT[DIM_NUM], the weights for each dimension. // // Input, integer LEVEL_MAX, the level that defines the grid. // // 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 GROWTH[DIM_NUM], the desired growth in each dimension. // 0, "DF", default growth associated with this quadrature rule; // 1, "SL", slow linear, L+1; // 2 "SO", slow linear odd, O=1+2((L+1)/2) // 3, "ML", moderate linear, 2L+1; // 4, "SE", slow exponential; // 5, "ME", moderate exponential; // 6, "FE", full exponential. // // Input, int NP[RULE_NUM], the number of parameters used by each rule. // // Input, double P[sum(NP[*])], the parameters needed by each rule. // // Input, void ( *GW_COMPUTE_POINTS[] ) ( int order, int np, double p[], double x[] ), // an array of pointers to functions which return the 1D quadrature points // associated with each spatial dimension for which a Golub Welsch rule // is used. // // 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. // // Input, double TOL, a tolerance for point equality. // // Input, string FILE_NAME, the main name of the output files. // { Console.WriteLine(""); Console.WriteLine("SGMGA_WRITE_TEST"); Console.WriteLine(" SGMGA_WRITE writes a sparse grid rule to files."); // // Compute necessary data. // int point_total_num = SGMGAniso.sgmga_size_total(dim_num, level_weight, level_max, rule, growth); int point_num = SGMGAniso.sgmga_size(dim_num, level_weight, level_max, rule, np, p, gw_compute_points, tol, growth); int[] sparse_unique_index = new int[point_total_num]; SGMGAniso.sgmga_unique_index(dim_num, level_weight, level_max, rule, np, p, gw_compute_points, tol, point_num, point_total_num, growth, ref sparse_unique_index); int[] sparse_order = new int[dim_num * point_num]; int[] sparse_index = new int[dim_num * point_num]; SGMGAniso.sgmga_index(dim_num, level_weight, level_max, rule, point_num, point_total_num, sparse_unique_index, growth, ref sparse_order, ref sparse_index); // // Compute points and weights. // double[] sparse_point = new double [dim_num * point_num]; SGMGAniso.sgmga_point(dim_num, level_weight, level_max, rule, np, p, gw_compute_points, point_num, sparse_order, sparse_index, growth, ref sparse_point); double[] sparse_weight = new double[point_num]; SGMGAniso.sgmga_weight(dim_num, level_weight, level_max, rule, np, p, gw_compute_weights, point_num, point_total_num, sparse_unique_index, growth, sparse_weight); // // Write points and weights to files. // SGMGAniso.sgmga_write(dim_num, level_weight, rule, np, p, point_num, sparse_weight, sparse_point, file_name); }
private static void sgmga_weight_test(int dim_num, double[] importance, double[] level_weight, int level_max_min, int level_max_max, int[] rule, int[] growth, int[] np, double[] p, Func <int, int, double[], double[], double[]>[] gw_compute_points, Func <int, int, double[], double[], double[]>[] gw_compute_weights, double tol) //***************************************************************************80 // // Purpose: // // SGMGA_WEIGHT_TEST checks the sum of the quadrature weights. // // Discussion: // // If any component rule is of Golub-Welsch type, we cannot compute // the exact weight sum, which we set, instead, to zero. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 09 June 2010 // // Author: // // John Burkardt // // Parameters: // // Input, int DIM_NUM, the spatial dimension. // // Input, double IMPORTANCE[DIM_NUM], the anisotropic importance. // // Input, double LEVEL_WEIGHT[DIM_NUM], the anisotropic weights. // // Input, int LEVEL_MAX_MIN, LEVEL_MAX_MAX, the minimum and // maximum values of LEVEL_MAX. // // 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 GROWTH[DIM_NUM], the desired growth in each dimension. // 0, "DF", default growth associated with this quadrature rule; // 1, "SL", slow linear, L+1; // 2 "SO", slow linear odd, O=1+2((L+1)/2) // 3, "ML", moderate linear, 2L+1; // 4, "SE", slow exponential; // 5, "ME", moderate exponential; // 6, "FE", full exponential. // // Input, int NP[RULE_NUM], the number of parameters used by each rule. // // Input, double P[sum(NP[*])], the parameters needed by each rule. // // Input, void ( *GW_COMPUTE_POINTS[] ) ( int order, int np, double p[], double x[] ), // an array of pointers to functions which return the 1D quadrature points // associated with each spatial dimension for which a Golub Welsch rule // is used. // // 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. // // Input, double TOL, a tolerance for point equality. // { double alpha; double beta; int dim; int i; int level_max; string cout = ""; Console.WriteLine(""); Console.WriteLine("SGMGA_WEIGHT_TEST"); Console.WriteLine(" Compute the weights of a sparse grid."); Console.WriteLine(""); Console.WriteLine(" Each sparse grid is of spatial dimension DIM_NUM,"); Console.WriteLine(" and is made up of product grids of levels up to LEVEL_MAX."); Console.WriteLine(""); cout = " IMPORTANCE: "; for (dim = 0; dim < dim_num; dim++) { cout += " " + importance[dim].ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); cout = " LEVEL_WEIGHT:"; for (dim = 0; dim < dim_num; dim++) { cout += " " + level_weight[dim].ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); Console.WriteLine(""); Console.WriteLine(" Dimension Rule Growth rate Parameters"); Console.WriteLine(""); int p_index = 0; for (dim = 0; dim < dim_num; dim++) { switch (rule[dim]) { case 1: case 2: case 3: case 4: case 5: Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + ""); break; case 6: alpha = p[p_index]; p_index += 1; Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); break; case 7: Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + ""); break; case 8: alpha = p[p_index]; p_index += 1; Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); break; case 9: alpha = p[p_index]; p_index += 1; beta = p[p_index]; p_index += 1; Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + beta.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); break; case 10: Console.WriteLine(" " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8) + ""); break; case 11: { cout = " " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8); for (i = 0; i < np[dim]; i++) { alpha = p[p_index]; p_index += 1; cout += " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); break; } case 12: { cout = " " + dim.ToString().PadLeft(8) + " " + rule[dim].ToString().PadLeft(8) + " " + growth[dim].ToString().PadLeft(8); for (i = 0; i < np[dim]; i++) { alpha = p[p_index]; p_index += 1; cout += " " + alpha.ToString(CultureInfo.InvariantCulture).PadLeft(14); } Console.WriteLine(cout); break; } default: Console.WriteLine(""); Console.WriteLine("SGMGA_WEIGHT_TEST - Fatal error!"); Console.WriteLine(" Unexpected value of RULE = " + rule[dim] + ""); return; } } double weight_sum_exact = 1.0; p_index = 0; for (dim = 0; dim < dim_num; dim++) { switch (rule[dim]) { case 1: case 2: case 3: case 4: weight_sum_exact *= 2.0; break; case 5: weight_sum_exact *= Math.Sqrt(Math.PI); break; case 6: alpha = p[p_index]; p_index += 1; weight_sum_exact *= typeMethods.r8_gamma(0.5 * (alpha + 1.0)); break; case 7: weight_sum_exact *= 1.0; break; case 8: alpha = p[p_index]; p_index += 1; weight_sum_exact *= typeMethods.r8_gamma(alpha + 1.0); break; case 9: alpha = p[p_index]; p_index += 1; beta = p[p_index]; p_index += 1; double arg1 = -alpha; double arg2 = 1.0; double arg3 = beta + 2.0; double arg4 = -1.0; double value1 = typeMethods.r8_hyper_2f1(arg1, arg2, arg3, arg4); arg1 = -beta; arg2 = 1.0; arg3 = alpha + 2.0; arg4 = -1.0; double value2 = typeMethods.r8_hyper_2f1(arg1, arg2, arg3, arg4); weight_sum_exact *= value1 / (beta + 1.0) + value2 / (alpha + 1.0); break; case 10: weight_sum_exact *= Math.Sqrt(Math.PI); break; case 11: { for (i = 0; i < np[dim]; i++) { alpha = p[p_index]; p_index += 1; } weight_sum_exact = 0.0; break; } case 12: { for (i = 0; i < np[dim]; i++) { alpha = p[p_index]; p_index += 1; } weight_sum_exact = 0.0; break; } default: Console.WriteLine(""); Console.WriteLine("SGMGA_WEIGHT_TEST - Fatal error!"); Console.WriteLine(" Unexpected value of RULE[" + dim + "] = " + rule[dim] + "."); return; } } switch (weight_sum_exact) { case 0.0: Console.WriteLine(""); Console.WriteLine(" Because this rule includes Golub-Welsch components,"); Console.WriteLine(" we do not try to compute the exact weight sum."); break; default: Console.WriteLine(""); Console.WriteLine(" As a simple test, sum these weights."); Console.WriteLine(" They should sum to exactly " + weight_sum_exact + ""); break; } Console.WriteLine(""); Console.WriteLine(" Level Weight sum Expected sum Difference"); Console.WriteLine(""); for (level_max = level_max_min; level_max <= level_max_max; level_max++) { int point_total_num = SGMGAniso.sgmga_size_total(dim_num, level_weight, level_max, rule, growth); int point_num = SGMGAniso.sgmga_size(dim_num, level_weight, level_max, rule, np, p, gw_compute_points, tol, growth); int[] sparse_unique_index = new int[point_total_num]; SGMGAniso.sgmga_unique_index(dim_num, level_weight, level_max, rule, np, p, gw_compute_points, tol, point_num, point_total_num, growth, ref sparse_unique_index); double[] sparse_weight = new double[point_num]; SGMGAniso.sgmga_weight(dim_num, level_weight, level_max, rule, np, p, gw_compute_weights, point_num, point_total_num, sparse_unique_index, growth, sparse_weight); double weight_sum = typeMethods.r8vec_sum(point_num, sparse_weight); double weight_sum_error = typeMethods.r8_abs(weight_sum - weight_sum_exact); Console.WriteLine(" " + level_max.ToString().PadLeft(8) + " " + weight_sum.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + weight_sum_exact.ToString(CultureInfo.InvariantCulture).PadLeft(14) + " " + weight_sum_error.ToString(CultureInfo.InvariantCulture).PadLeft(14) + ""); } }
private static void sgmga_size_tabulate(int rule_1d, int growth_1d, int np_1d, double[] p_1d, int dim_min, int dim_max, int level_max_min, int level_max_max, Func <int, int, double[], double[], double[]> gw_compute_points_1d) //****************************************************************************80 // // Purpose: // // SGMGA_SIZE_TABULATE tests SGMGA_SIZE. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 07 June 2010 // // Author: // // John Burkardt // // Parameters: // // Input, int RULE_1D, the 1D rule. // 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 GROWTH_1D, the desired growth in each dimension. // 0, "DF", default growth associated with this quadrature rule; // 1, "SL", slow linear, L+1; // 2 "SO", slow linear odd, O=1+2((L+1)/2) // 3, "ML", moderate linear, 2L+1; // 4, "SE", slow exponential; // 5, "ME", moderate exponential; // 6, "FE", full exponential. // // Input, int NP_1D, the number of parameters in the 1D rule. // // Input, double P_1D[NP_1D], the parameters. // // Input, int DIM_MIN, the minimum spatial dimension to consider. // // Input, int DIM_MAX, the maximum spatial dimension to consider. // // Input, int LEVEL_MAX_MIN, the minimum value of LEVEL_MAX to consider. // // Input, int LEVEL_MAX_MAX, the maximum value of LEVEL_MAX to consider. // // Input, GW_COMPUTE_POINTS_1D ( int order, int np, double p[], double x[] ), // a function which return the 1D quadrature points. // { int dim_num; int level_max; Console.WriteLine(""); Console.WriteLine("SGMGA_SIZE_TABULATE"); Console.WriteLine(" SGMGA_SIZE returns the number of distinct"); Console.WriteLine(" points in a sparse grid."); Console.WriteLine(""); Console.WriteLine(" We use the same rule in all dimensions, and count the points,"); Console.WriteLine(" for a range of dimensions and levels."); Console.WriteLine(""); Console.WriteLine(" 1D rule index = " + rule_1d + ""); Console.WriteLine(" 1D growth rule = " + growth_1d + ""); Console.WriteLine(""); double tol = Math.Sqrt(typeMethods.r8_epsilon()); string cout = " DIM: "; for (dim_num = dim_min; dim_num <= dim_max; dim_num++) { cout += " " + dim_num.ToString().PadLeft(8); } Console.WriteLine(cout); Console.WriteLine(""); Console.WriteLine(" LEVEL_MAX"); Console.WriteLine(""); for (level_max = level_max_min; level_max <= level_max_max; level_max++) { cout = " " + level_max.ToString().PadLeft(4); for (dim_num = dim_min; dim_num <= dim_max; dim_num++) { double[] level_weight = new double[dim_num]; int[] rule = new int[dim_num]; int[] growth = new int[dim_num]; int[] np = new int[dim_num]; int np_sum = dim_num * np_1d; double[] p = new double[np_sum]; Func <int, int, double[], double[], double[]>[] gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num]; int dim; for (dim = 0; dim < dim_num; dim++) { level_weight[dim] = 1.0; rule[dim] = rule_1d; growth[dim] = growth_1d; np[dim] = np_1d; int i; for (i = 0; i < np_1d; i++) { p[i + dim * np_1d] = p_1d[i]; } gw_compute_points[dim] = gw_compute_points_1d; } int point_num = SGMGAniso.sgmga_size(dim_num, level_weight, level_max, rule, np, p, gw_compute_points, tol, growth); cout += " " + point_num.ToString().PadLeft(8); } Console.WriteLine(cout); } }