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); }