private static void sgmga_importance_to_aniso_test(int dim_num, double[] importance,
double[] level_weight)
//****************************************************************************80
//
// Purpose:
//
// SGMGA_IMPORTANCE_TO_ANISO_TEST calls SGMGA_IMPORTANCE_TO_ANISO.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 27 November 2009
//
// Author:
//
// John Burkardt
//
{
int dim;
Console.WriteLine("");
Console.WriteLine("SGMGA_IMPORTANCE_TO_ANISO_TEST");
Console.WriteLine(" Importances:");
string cout = "";
for (dim = 0; dim < dim_num; dim++)
{
cout += " " + importance[dim].ToString(CultureInfo.InvariantCulture).PadLeft(12);
}
Console.WriteLine(cout);
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
Console.WriteLine(" Anisotropic coefficients:");
cout = "";
for (dim = 0; dim < dim_num; dim++)
{
cout += " " + level_weight[dim].ToString(CultureInfo.InvariantCulture).PadLeft(12);
}
Console.WriteLine(cout);
}
private static void sgmga_unique_index_tests()
//****************************************************************************80
//
// Purpose:
//
// SGMGA_UNIQUE_INDEX_TESTS calls SGMGA_UNIQUE_INDEX_TEST.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 20 June 2010
//
// Author:
//
// John Burkardt
//
// Local Parameters:
//
// Local, double TOL, a tolerance for point equality.
// A value of sqrt ( eps ) is reasonable, and will allow the code to
// consolidate points which are equal, or very nearly so. A value of
// -1.0, on the other hand, will force the code to use every point,
// regardless of duplication.
//
{
int dim;
Console.WriteLine("");
Console.WriteLine("SGMGA_UNIQUE_INDEX_TESTS");
Console.WriteLine(" Call SGMGA_UNIQUE_INDEX_TEST with various arguments");
//
// Set the point equality tolerance.
//
double tol = Math.Sqrt(typeMethods.r8_epsilon());
Console.WriteLine("");
Console.WriteLine(" All tests will use a point equality tolerance of " + tol + "");
int dim_num = 2;
double[] importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
double[] level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
int level_max_min = 0;
int level_max_max = 2;
int[] np = new int[dim_num];
np[0] = 0;
np[1] = 0;
int np_sum = typeMethods.i4vec_sum(dim_num, np);
double[] p = new double[np_sum];
int[] rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
int[] growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
Func <int, int, double[], double[], double[]>[] gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
rule[2] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
growth[2] = 6;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
rule[2] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
growth[2] = 6;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 3;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = PattersonQuadrature.patterson_lookup_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 4;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 7;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Laguerre.QuadratureRule.laguerre_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 1;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
p[0] = 1.5;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 8;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Laguerre.QuadratureRule.gen_laguerre_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 2;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
p[0] = 0.5;
p[1] = 1.5;
rule = new int[dim_num];
rule[0] = 2;
rule[1] = 9;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = Fejer2.fejer2_compute_points_np;
gw_compute_points[1] = JacobiQuadrature.jacobi_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 1;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
p[0] = 2.0;
rule = new int[dim_num];
rule[0] = 6;
rule[1] = 10;
growth = new int[dim_num];
growth[0] = 3;
growth[1] = 4;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = HermiteQuadrature.gen_hermite_compute_points_np;
gw_compute_points[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 4;
rule[2] = 5;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
growth[2] = 3;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_points_np;
gw_compute_points[2] = HermiteQuadrature.hermite_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
//
// Repeat, treating rules #2 and #3 as Golub Welsch rules.
//
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 11;
rule[2] = 11;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
growth[2] = 3;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_points_np;
gw_compute_points[2] = HermiteQuadrature.hermite_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
//
// Try a case which includes a dimension of "0 importance".
//
dim_num = 3;
importance = new double[dim_num];
importance[0] = 1.0;
importance[1] = 0.0;
importance[2] = 1.0;
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 3;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
rule[2] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
growth[2] = 6;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[2] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
sgmga_unique_index_test(dim_num, importance, level_weight, level_max_min,
level_max_max, rule, growth, np, p, gw_compute_points, tol);
}
private static void sgmga_vcn_coef_tests()
//****************************************************************************80
//
// Purpose:
//
// SGMGA_VCN_COEF_TESTS calls SGMGA_VCN_COEF_TEST.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 27 November 2009
//
// Author:
//
// John Burkardt
//
{
int dim;
Console.WriteLine("");
Console.WriteLine("SGMGA_VCN_COEF_TESTS");
Console.WriteLine(" calls SGMGA_VCN_COEF_TEST.");
int dim_num = 2;
double[] importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
double[] level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
int level_max_min = 0;
int level_max_max = 4;
sgmga_vcn_coef_test(dim_num, importance, level_weight, level_max_min,
level_max_max);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 4;
sgmga_vcn_coef_test(dim_num, importance, level_weight, level_max_min,
level_max_max);
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 4;
sgmga_vcn_coef_test(dim_num, importance, level_weight, level_max_min,
level_max_max);
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 4;
sgmga_vcn_coef_test(dim_num, importance, level_weight, level_max_min,
level_max_max);
dim_num = 4;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 3;
sgmga_vcn_coef_test(dim_num, importance, level_weight, level_max_min,
level_max_max);
//
// Try a case with a dimension of "0 importance".
//
dim_num = 3;
importance = new double[dim_num];
importance[0] = 1.0;
importance[1] = 0.0;
importance[2] = 1.0;
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max_min = 0;
level_max_max = 3;
sgmga_vcn_coef_test(dim_num, importance, level_weight, level_max_min,
level_max_max);
}
private static void sgmga_write_tests()
//****************************************************************************80
//
// Purpose:
//
// SGMGA_WRITE_TESTS calls SGMGA_WRITE_TEST.
//
// Discussion:
//
// We can't test Golub-Welsch rules in this routine, because the program
// that writes out the files needs to know the integration region for each
// component, and we have not specified how that would be done with
// Golub Welsch rules.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 20 June 2010
//
// Author:
//
// John Burkardt
//
// Local Parameters:
//
// Local, double TOL, a tolerance for point equality.
// A value of sqrt ( eps ) is reasonable, and will allow the code to
// consolidate points which are equal, or very nearly so. A value of
// -1.0, on the other hand, will force the code to use every point,
// regardless of duplication.
//
{
int dim;
Console.WriteLine("");
Console.WriteLine("SGMGA_WRITE_TESTS");
Console.WriteLine(" Call SGMGA_WRITE_TEST with various arguments.");
//
// Set the point equality tolerance.
//
double tol = Math.Sqrt(typeMethods.r8_epsilon());
Console.WriteLine("");
Console.WriteLine(" All tests will use a point equality tolerance of " + tol + "");
int dim_num = 2;
double[] importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
double[] level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
int level_max = 2;
int[] rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
int[] growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
int[] np = new int[dim_num];
np[0] = 0;
np[1] = 0;
int np_sum = typeMethods.i4vec_sum(dim_num, np);
double[] p = new double[np_sum];
Func <int, int, double[], double[], double[]>[] gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
Func <int, int, double[], double[], double[]>[] gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
string file_name = "sgmga_d2_l2_ccxcc_iso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
file_name = "sgmga_d2_l2_ccxcc_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
rule[2] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
growth[2] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[2] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[2] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
file_name = "sgmga_d3_l2_ccxccxcc_iso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
rule[2] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
growth[2] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[2] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[2] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
file_name = "sgmga_d3_l2_ccxccxcc_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 3;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 3;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = PattersonQuadrature.patterson_lookup_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = PattersonQuadrature.patterson_lookup_weights_np;
file_name = "sgmga_d2_l3_ccxgp_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 4;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_weights_np;
file_name = "sgmga_d2_l2_ccxgl_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 7;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Laguerre.QuadratureRule.laguerre_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = Burkardt.Laguerre.QuadratureRule.laguerre_compute_weights_np;
file_name = "sgmga_d2_l2_ccxlg_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 8;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
np = new int[dim_num];
np[0] = 1;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
p[0] = 1.5;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Laguerre.QuadratureRule.gen_laguerre_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = Burkardt.Laguerre.QuadratureRule.gen_laguerre_compute_weights_np;
file_name = "sgmga_d2_l2_ccxglg_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 2;
rule[1] = 9;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
np = new int[dim_num];
np[0] = 0;
np[1] = 2;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
p[0] = 0.5;
p[1] = 1.5;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = Fejer2.fejer2_compute_points_np;
gw_compute_points[1] = JacobiQuadrature.jacobi_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = Fejer2.fejer2_compute_weights_np;
gw_compute_weights[1] = JacobiQuadrature.jacobi_compute_weights_np;
file_name = "sgmga_d2_l2_f2xgj_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 6;
rule[1] = 10;
growth = new int[dim_num];
growth[0] = 3;
growth[1] = 4;
np = new int[dim_num];
np[0] = 1;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
p[0] = 2.0;
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = HermiteQuadrature.gen_hermite_compute_points_np;
gw_compute_points[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = HermiteQuadrature.gen_hermite_compute_weights_np;
gw_compute_weights[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_weights_np;
file_name = "sgmga_d2_l2_gghxhgk_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
//
// LEVEL_MAX = 1
//
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 1;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
file_name = "sgmga_d2_l1_ccxcc_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
//
// LEVEL_MAX = 2 (already done)
//
// LEVEL_MAX = 3
//
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 3;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
file_name = "sgmga_d2_l3_ccxcc_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
//
// LEVEL_MAX = 4
//
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 4;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
file_name = "sgmga_d2_l4_ccxcc_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
//
// LEVEL_MAX = 5
//
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 5;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 1;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
file_name = "sgmga_d2_l5_ccxcc_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
//
// Dimension 3
//
dim_num = 3;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
rule = new int[dim_num];
rule[0] = 1;
rule[1] = 4;
rule[2] = 5;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 3;
growth[2] = 3;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = ClenshawCurtis.clenshaw_curtis_compute_points_np;
gw_compute_points[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_points_np;
gw_compute_points[2] = HermiteQuadrature.hermite_compute_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = ClenshawCurtis.clenshaw_curtis_compute_weights_np;
gw_compute_weights[1] = Burkardt.Legendre.QuadratureRule.legendre_compute_weights_np;
gw_compute_weights[2] = HermiteQuadrature.hermite_compute_weights_np;
file_name = "sgmga_d3_l2_ccxglxgh_aniso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
//
// Rule 3, LEVEL_MAX = 4
//
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 4;
rule = new int[dim_num];
rule[0] = 3;
rule[1] = 3;
growth = new int[dim_num];
growth[0] = 6;
growth[1] = 6;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = PattersonQuadrature.patterson_lookup_points_np;
gw_compute_points[1] = PattersonQuadrature.patterson_lookup_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = PattersonQuadrature.patterson_lookup_weights_np;
gw_compute_weights[1] = PattersonQuadrature.patterson_lookup_weights_np;
file_name = "sgmga_d2_l4_gpxgp_iso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
//
// Rule 3, Slow Exponential Growth, LEVEL_MAX = 4
//
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 4;
rule = new int[dim_num];
rule[0] = 3;
rule[1] = 3;
growth = new int[dim_num];
growth[0] = 4;
growth[1] = 4;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = PattersonQuadrature.patterson_lookup_points_np;
gw_compute_points[1] = PattersonQuadrature.patterson_lookup_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = PattersonQuadrature.patterson_lookup_weights_np;
gw_compute_weights[1] = PattersonQuadrature.patterson_lookup_weights_np;
file_name = "sgmga_d2_l4_gpsexgpse_iso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
//
// Rule 3, Moderate Exponential Growth, LEVEL_MAX = 4
//
dim_num = 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 4;
rule = new int[dim_num];
rule[0] = 3;
rule[1] = 3;
growth = new int[dim_num];
growth[0] = 5;
growth[1] = 5;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = typeMethods.i4vec_sum(dim_num, np);
p = new double[np_sum];
gw_compute_points = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_points[0] = PattersonQuadrature.patterson_lookup_points_np;
gw_compute_points[1] = PattersonQuadrature.patterson_lookup_points_np;
gw_compute_weights = new Func <int, int, double[], double[], double[]> [dim_num];
gw_compute_weights[0] = PattersonQuadrature.patterson_lookup_weights_np;
gw_compute_weights[1] = PattersonQuadrature.patterson_lookup_weights_np;
file_name = "sgmga_d2_l4_gpmexgpme_iso";
sgmga_write_test(dim_num, level_weight, level_max, rule, growth, np,
p, gw_compute_points, gw_compute_weights, tol, file_name);
}
private static void sgmga_vcn_ordered_tests()
//****************************************************************************80
//
// Purpose:
//
// SGMGA_VCN_ORDERED_TESTS calls SGMGA_VCN_ORDERED_TEST.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 21 May 2010
//
// Author:
//
// John Burkardt
//
{
int dim;
int dim_num;
int[] dim_num_array =
{
2, 2, 2, 2, 2,
3, 3, 3, 3, 3,
4, 4
};
double[] importance;
int level_max;
int[] level_max_array =
{
0, 1, 2, 3, 4,
0, 1, 2, 3, 4,
2, 3
};
double[] level_weight;
double q_max;
double q_min;
int test;
const int test_num = 12;
Console.WriteLine("");
Console.WriteLine("SGMGA_VCN_ORDERED_TESTS");
Console.WriteLine(" calls SGMGA_VCN_ORDERED_TEST.");
//
// Isotropic examples.
//
for (test = 0; test < test_num; test++)
{
dim_num = dim_num_array[test];
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = level_max_array[test];
q_min = level_max - typeMethods.r8vec_sum(dim_num, level_weight);
q_max = level_max;
sgmga_vcn_ordered_test(dim_num, importance, level_weight, q_min, q_max);
}
//
// Anisotropic examples.
//
for (test = 0; test < test_num; test++)
{
dim_num = dim_num_array[test];
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = level_max_array[test];
q_min = level_max - typeMethods.r8vec_sum(dim_num, level_weight);
q_max = level_max;
sgmga_vcn_ordered_test(dim_num, importance, level_weight, q_min, q_max);
}
}
private static void sgmga_vcn_timing_tests()
//****************************************************************************80
//
// Purpose:
//
// SGMGA_VCN_TIMING_TESTS calls SGMGA_VCN_TIMING_TEST.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 21 May 2010
//
// Author:
//
// John Burkardt
//
{
int dim;
double[] importance;
int level_max;
double[] level_weight;
double q_max;
double q_min;
int test;
Console.WriteLine("");
Console.WriteLine("SGMGA_VCN_TIMING_TESTS");
Console.WriteLine(" calls SGMGA_VCN_TIMING_TEST.");
//
// Isotropic examples.
//
int dim_num = 2;
for (test = 0; test < 2; test++)
{
dim_num *= 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = 1.0;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
q_min = level_max - typeMethods.r8vec_sum(dim_num, level_weight);
q_max = level_max;
sgmga_vcn_timing_test(dim_num, importance, level_weight, q_min, q_max);
}
//
// Anisotropic examples.
//
dim_num = 2;
for (test = 0; test < 2; test++)
{
dim_num *= 2;
importance = new double[dim_num];
for (dim = 0; dim < dim_num; dim++)
{
importance[dim] = dim + 1;
}
level_weight = new double[dim_num];
SGMGAniso.sgmga_importance_to_aniso(dim_num, importance, ref level_weight);
level_max = 2;
q_min = level_max - typeMethods.r8vec_sum(dim_num, level_weight);
q_max = level_max;
sgmga_vcn_timing_test(dim_num, importance, level_weight, q_min, q_max);
}
}
