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;
int dim_num;
int *growth;
GWPointer *gw_compute_points;
double *importance;
int level_max_max;
int level_max_min;
double *level_weight;
int *np;
int np_sum;
int *order_1d;
int order_nd;
double *p;
int *rule;
double tol;
std::cout << "\n";
std::cout << "SGMGA_UNIQUE_INDEX_TESTS\n";
std::cout << " Call SGMGA_UNIQUE_INDEX_TEST with various arguments\n";
//
// Set the point equality tolerance.
//
tol = std::sqrt ( webbur::r8_epsilon ( ) );
std::cout << "\n";
std::cout << " All tests will use a point equality tolerance of " << tol << "\n";
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];
webbur::sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 2;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
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];
webbur::sgmga_importance_to_aniso ( dim_num, importance, 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 = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 3;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, 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 = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 2;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 2;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 2;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 0;
np_sum = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 2;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 1;
np_sum = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 2;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 0;
np[1] = 2;
np_sum = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::fejer2_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 2;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = new int[dim_num];
np[0] = 1;
np[1] = 0;
np_sum = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::gen_hermite_compute_points_np;
gw_compute_points[1] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
dim_num = 3;
importance = new double[dim_num];
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, 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 = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::legendre_compute_points_np;
gw_compute_points[2] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
//
// 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] = ( double ) ( dim + 1 );
}
level_weight = new double[dim_num];
webbur::sgmga_importance_to_aniso ( dim_num, importance, 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 = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::legendre_compute_points_np;
gw_compute_points[2] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
//
// 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];
webbur::sgmga_importance_to_aniso ( dim_num, importance, 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 = webbur::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 GWPointer[dim_num];
gw_compute_points[0] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[1] = webbur::clenshaw_curtis_compute_points_np;
gw_compute_points[2] = webbur::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 );
delete [] growth;
delete [] gw_compute_points;
delete [] importance;
delete [] level_weight;
delete [] np;
delete [] p;
delete [] rule;
return;
}
void sgmga_unique_index_tests ( void )
/******************************************************************************/
/*
Purpose:
SGMGA_UNIQUE_INDEX_TESTS calls SGMGA_UNIQUE_INDEX_TEST.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
27 November 2009
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;
int dim_num;
GWPointer *gw_compute_points;
double *importance;
int level_max_max;
int level_max_min;
double *level_weight;
int *np;
int np_sum;
int *order_1d;
int order_nd;
double *p;
int *rule;
double tol;
printf ( "\n" );
printf ( "SGMGA_UNIQUE_INDEX_TESTS\n" );
printf ( " Call SGMGA_UNIQUE_INDEX_TEST with various arguments\n" );
/*
Set the point equality tolerance.
*/
tol = sqrt ( r8_epsilon ( ) );
printf ( "\n" );
printf ( " All tests will use a point equality tolerance of %e\n", tol );
dim_num = 2;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = 1.0;
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 1;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = clenshaw_curtis_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 2;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 1;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = clenshaw_curtis_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 3;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = 1.0;
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 1;
rule[2] = 1;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = clenshaw_curtis_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 3;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 1;
rule[2] = 1;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = clenshaw_curtis_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 2;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 3;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = patterson_lookup_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 2;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 4;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = legendre_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 2;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 7;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = laguerre_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 2;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 1;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
p[0] = 1.5;
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 8;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = gen_laguerre_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 2;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 2;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
p[0] = 0.5;
p[1] = 1.5;
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 2;
rule[1] = 9;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = fejer2_compute_points_np;
gw_compute_points[1] = jacobi_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 2;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 1;
np[1] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
p[0] = 2.0;
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 6;
rule[1] = 4;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = gen_hermite_compute_points_np;
gw_compute_points[1] = legendre_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
dim_num = 3;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 4;
rule[2] = 5;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = legendre_compute_points_np;
gw_compute_points[2] = hermite_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
/*
Repeat, treating rules #2 and #3 as Golub Welsch rules.
*/
dim_num = 3;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
for ( dim = 0; dim < dim_num; dim++ )
{
importance[dim] = ( double ) ( dim + 1 );
}
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 2;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 10;
rule[2] = 10;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = legendre_compute_points_np;
gw_compute_points[2] = hermite_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
/*
Try a case which includes a dimension of "0 importance".
*/
dim_num = 3;
importance = ( double * ) malloc ( dim_num * sizeof ( double ) );
importance[0] = 1.0;
importance[1] = 0.0;
importance[2] = 1.0;
level_weight = ( double * ) malloc ( dim_num * sizeof ( double ) );
sgmga_importance_to_aniso ( dim_num, importance, level_weight );
level_max_min = 0;
level_max_max = 3;
np = ( int * ) malloc ( dim_num * sizeof ( int ) );
np[0] = 0;
np[1] = 0;
np[2] = 0;
np_sum = i4vec_sum ( dim_num, np );
p = ( double * ) malloc ( np_sum * sizeof ( double ) );
rule = ( int * ) malloc ( dim_num * sizeof ( int ) );
rule[0] = 1;
rule[1] = 1;
rule[2] = 1;
gw_compute_points = ( GWPointer * ) malloc ( dim_num * sizeof ( GWPointer ) );
gw_compute_points[0] = clenshaw_curtis_compute_points_np;
gw_compute_points[1] = clenshaw_curtis_compute_points_np;
gw_compute_points[2] = clenshaw_curtis_compute_points_np;
sgmga_unique_index_test ( dim_num, importance, level_weight, level_max_min,
level_max_max, rule, np, p, gw_compute_points, tol );
free ( gw_compute_points );
free ( importance );
free ( level_weight );
free ( np );
free ( p );
free ( rule );
return;
}
