129 double *level_weight2;
130 double level_weight_min;
133 if ( alpha_max < 1.0 )
136 std::cerr <<
"SGMGA_ANISO_BALANCE - Fatal error!\n";
137 std::cerr <<
" ALPHA_MAX < 1.0\n";
143 level_weight_min = webbur->r8_huge ( );
146 for ( dim = 0; dim < dim_num; dim++ )
148 if ( 0.0 < level_weight[dim] )
150 if ( level_weight[dim] < level_weight_min )
152 level_weight_min = level_weight[dim];
153 nonzero_num = nonzero_num + 1;
158 if ( nonzero_num == 0 )
161 std::cerr <<
"SGMGA_ANISO_BALANCE - Fatal error!\n";
162 std::cerr <<
" Could not find a positive entry in LEVEL_WEIGHT.\n";
168 level_weight2 =
new double[dim_num];
169 for ( dim = 0; dim < dim_num; dim++ )
171 level_weight2[dim] = level_weight[dim] / level_weight_min;
176 for ( dim = 0; dim < dim_num; dim++ )
178 level_weight2[dim] = webbur->r8_min ( alpha_max, level_weight2[dim] );
180 return level_weight2;
188 double level_weight[]
258 double level_weight_min;
259 double level_weight_sum;
269 else if ( option == 1 )
271 level_weight_min = webbur->r8_huge ( );
273 for ( dim = 0; dim < dim_num; dim++ )
275 if ( 0.0 < level_weight[dim] )
277 if ( level_weight[dim] < level_weight_min )
279 level_weight_min = level_weight[dim];
288 std::cerr <<
"SGMGA_ANISO_NORMALIZE - Fatal error!\n";
289 std::cerr <<
" Could not find a positive entry in LEVEL_WEIGHT.\n";
293 for ( dim = 0; dim < dim_num; dim++ )
295 level_weight[dim] = level_weight[dim] / level_weight_min;
301 else if ( option == 2 )
303 level_weight_sum = webbur->r8vec_sum ( dim_num, level_weight );
305 if ( level_weight_sum <= 0.0 )
308 std::cerr <<
"SGMGA_ANISO_NORMALIZE - Fatal error!\n";
309 std::cerr <<
" Sum of level weights is not positive.\n";
312 for ( dim = 0; dim < dim_num; dim++ )
314 level_weight[dim] = ( ( double ) ( dim_num ) * level_weight[dim] )
327 double level_weight[]
408 for ( dim = 0; dim < dim_num; dim++ )
410 if ( importance[dim] < 0.0 )
413 std::cerr <<
"SGMGA_IMPORTANCE_TO_ANISO - Fatal error!\n";
414 std::cerr <<
" Some IMPORTANCE entries are not positive.\n";
421 for ( dim = 0; dim < dim_num; dim++ )
423 if ( 0.0 < importance[dim] )
425 level_weight[dim] = 1.0 / importance[dim];
430 level_weight[dim] = 0.0;
437 std::cerr <<
"SGMGA_IMPORTANCE_TO_ANISO - Fatal error!\n";
438 std::cerr <<
" No importance entry is positive.\n";
449 double level_weight[],
453 int sparse_unique_index[],
455 int (
SandiaRules::*gw_compute_order[] ) (
int level,
int growth ),
549 double level_weight_min_pos;
568 if ( level_max == 0 )
571 for ( dim = 0; dim < dim_num; dim++ )
573 sparse_order[dim+point*dim_num] = 1;
574 sparse_index[dim+point*dim_num] = 1;
581 for ( point = 0; point < point_num; point++ )
583 for ( dim = 0; dim < dim_num; dim++ )
585 sparse_order[dim+point*dim_num] = -1;
586 sparse_index[dim+point*dim_num] = -1;
592 level_1d =
new int[dim_num];
593 level_1d_max =
new int[dim_num];
594 order_1d =
new int[dim_num];
595 point_index =
new int[dim_num];
599 level_weight_min_pos = webbur->r8vec_min_pos ( dim_num, level_weight );
600 q_min = ( double ) ( level_max ) * level_weight_min_pos
601 - webbur->r8vec_sum ( dim_num, level_weight );
602 q_max = ( double ) ( level_max ) * level_weight_min_pos;
603 for ( dim = 0; dim < dim_num; dim++ )
605 if ( 0.0 < level_weight[dim] )
607 level_1d_max[dim] = ( int )( webbur->r8_floor ( q_max / level_weight[dim] ) ) + 1;
608 if ( q_max <= ( level_1d_max[dim] - 1 ) * level_weight[dim] )
610 level_1d_max[dim] = level_1d_max[dim] - 1;
615 level_1d_max[dim] = 0;
628 sgmga_vcn_ordered ( dim_num, level_weight, level_1d_max,
629 level_1d, q_min, q_max, &more_grids );
638 coef = sgmga_vcn_coef ( dim_num, level_weight, level_1d,
648 for ( dim = 0; dim < dim_num; dim++ )
650 order_1d[dim] = ((*webbur).*gw_compute_order[dim])(level_1d[dim],growth);
659 webbur->vec_colex_next3 ( dim_num, order_1d, point_index, &more_points );
665 point_unique = sparse_unique_index[point_count];
666 for ( dim = 0; dim < dim_num; dim++ )
668 sparse_order[dim+point_unique*dim_num] = order_1d[dim];
670 for ( dim = 0; dim < dim_num; dim++ )
672 sparse_index[dim+point_unique*dim_num] = point_index[dim];
674 point_count = point_count + 1;
679 delete [] level_1d_max;
681 delete [] point_index;
690 double level_weight[],
692 void (
SandiaRules2::*gw_compute_points[] ) (
int order,
int dim,
double x[] ),
697 int (
SandiaRules::*gw_compute_order[] ) (
int level,
int growth ),
698 double sparse_point[]
785 double level_weight_min_pos;
791 for ( point = 0; point < point_num; point++ )
793 for ( dim = 0; dim < dim_num; dim++ )
795 sparse_point[dim+point*dim_num] = - webbur->r8_huge ( );
801 level_1d_max =
new int[dim_num];
802 level_weight_min_pos = webbur->r8vec_min_pos ( dim_num, level_weight );
803 q_max = ( double ) ( level_max ) * level_weight_min_pos;
805 for ( dim = 0; dim < dim_num; dim++ )
807 if ( 0.0 < level_weight[dim] )
809 level_1d_max[dim] = ( int ) ( webbur->r8_floor ( q_max / level_weight[dim] ) ) + 1;
810 if ( q_max <= ( level_1d_max[dim] - 1 ) * level_weight[dim] )
812 level_1d_max[dim] = level_1d_max[dim] - 1;
817 level_1d_max[dim] = 0;
820 for ( level = 0; level <= level_1d_max[dim]; level++ )
822 order = ((*webbur).*gw_compute_order[dim]) ( level, growth );
824 points =
new double[order];
826 ((*webbur2).*gw_compute_points[dim]) ( order, dim, points );
828 for ( point = 0; point < point_num; point++ )
830 if ( sparse_order[dim+point*dim_num] == order )
832 sparse_point[dim+point*dim_num] =
833 points[sparse_index[dim+point*dim_num]-1];
842 for ( point = 0; point < point_num; point++ )
844 for ( dim = 0; dim < dim_num; dim++ )
846 if ( sparse_point[dim+point*dim_num] == - webbur-> r8_huge ( ) )
849 std::cerr <<
"SGMGA_POINT - Fatal error!\n";
850 std::cerr <<
" At least one point component was not assigned.\n";
851 std::cerr <<
" POINT = " << point <<
"\n";
852 std::cerr <<
" DIM = " << dim <<
"\n";
853 std::cerr <<
" SPARSE_ORDER(DIM,POINT) = "
854 << sparse_order[dim+point*dim_num] <<
"\n";
855 std::cerr <<
" LEVEL_WEIGHT(DIM) = " << level_weight[dim] <<
"\n";
861 delete [] level_1d_max;
872 void (
SandiaRules2::*gw_compute_weights[] ) (
int order,
int dim,
double w[] ),
935 for ( i = 0; i < order_nd; i++ )
940 for ( dim = 0; dim < dim_num; dim++ )
942 weight_1d =
new double[order_1d[dim]];
944 ((*webbur2).*gw_compute_weights[dim]) ( order_1d[dim], dim, weight_1d );
946 webbur->r8vec_direct_product2 ( dim, order_1d[dim], weight_1d, dim_num,
947 order_nd, weight_nd );
958 double level_weight[],
960 void (
SandiaRules2::*gw_compute_points[] ) (
int order,
int dim,
double x[] ),
963 int (
SandiaRules::*gw_compute_order[] ) (
int level,
int growth )
1046 double level_weight_min_pos;
1054 int point_total_num;
1055 int point_total_num2;
1060 int *sparse_total_index;
1061 int *sparse_total_order;
1062 double *sparse_total_point;
1066 if ( level_max < 0 )
1072 if ( level_max == 0 )
1080 point_total_num = sgmga_size_total ( dim_num, level_weight,
1081 level_max, growth, gw_compute_order );
1086 sparse_total_order =
new int[dim_num*point_total_num];
1087 sparse_total_index =
new int[dim_num*point_total_num];
1089 point_total_num2 = 0;
1091 level_1d =
new int[dim_num];
1092 level_1d_max =
new int[dim_num];
1093 order_1d =
new int[dim_num];
1094 point_index =
new int[dim_num];
1098 level_weight_min_pos = webbur->r8vec_min_pos ( dim_num, level_weight );
1099 q_min = ( double ) ( level_max ) * level_weight_min_pos
1100 - webbur->r8vec_sum ( dim_num, level_weight );
1101 q_max = ( double ) ( level_max ) * level_weight_min_pos;
1102 for ( dim = 0; dim < dim_num; dim++ )
1104 if ( 0.0 < level_weight[dim] )
1106 level_1d_max[dim] = ( int ) ( webbur->r8_floor ( q_max / level_weight[dim] ) ) + 1;
1107 if ( q_max <= ( level_1d_max[dim] - 1 ) * level_weight[dim] )
1109 level_1d_max[dim] = level_1d_max[dim] - 1;
1114 level_1d_max[dim] = 0;
1127 sgmga_vcn_ordered ( dim_num, level_weight, level_1d_max,
1128 level_1d, q_min, q_max, &more_grids );
1137 coef = sgmga_vcn_coef ( dim_num, level_weight, level_1d,
1147 for ( dim = 0; dim < dim_num; dim++ )
1149 order_1d[dim] = ((*webbur).*gw_compute_order[dim])(level_1d[dim],growth);
1154 more_points =
false;
1158 webbur->vec_colex_next3 ( dim_num, order_1d, point_index, &more_points );
1164 for ( dim = 0; dim < dim_num; dim++ )
1166 sparse_total_order[dim+point_total_num2*dim_num] = order_1d[dim];
1168 for ( dim = 0; dim < dim_num; dim++ )
1170 sparse_total_index[dim+point_total_num2*dim_num] = point_index[dim];
1172 point_total_num2 = point_total_num2 + 1;
1177 delete [] point_index;
1181 sparse_total_point =
new double[dim_num*point_total_num];
1183 for ( point = 0; point < point_total_num; point++ )
1185 for ( dim = 0; dim < dim_num; dim++ )
1187 sparse_total_point[dim+point*dim_num] = webbur->r8_huge ( );
1193 level_1d_max =
new int[dim_num];
1194 level_weight_min_pos = webbur->r8vec_min_pos ( dim_num, level_weight );
1195 q_max = ( double ) ( level_max ) * level_weight_min_pos;
1197 for ( dim = 0; dim < dim_num; dim++ )
1199 if ( 0.0 < level_weight[dim] )
1201 level_1d_max[dim] = ( int ) ( webbur->r8_floor ( q_max / level_weight[dim] ) ) + 1;
1202 if ( q_max <= ( level_1d_max[dim] - 1 ) * level_weight[dim] )
1204 level_1d_max[dim] = level_1d_max[dim] - 1;
1209 level_1d_max[dim] = 0;
1212 for ( level = 0; level <= level_1d_max[dim]; level++ )
1214 order = ((*webbur).*gw_compute_order[dim]) ( level, growth );
1216 points =
new double[order];
1218 ((*webbur2).*gw_compute_points[dim]) ( order, dim, points );
1220 for ( point = 0; point < point_total_num; point++ )
1222 if ( sparse_total_order[dim+point*dim_num] == order )
1224 sparse_total_point[dim+point*dim_num] =
1225 points[sparse_total_index[dim+point*dim_num]-1];
1236 point_num = webbur->point_radial_tol_unique_count ( dim_num, point_total_num,
1237 sparse_total_point, tol, &seed );
1239 delete [] level_1d_max;
1240 delete [] sparse_total_index;
1241 delete [] sparse_total_order;
1242 delete [] sparse_total_point;
1251 double level_weight[],
1254 int (
SandiaRules::*gw_compute_order[] ) (
int level,
int growth )
1348 double level_weight_min_pos;
1351 int point_total_num;
1357 if ( level_max == 0 )
1359 point_total_num = 1;
1360 return point_total_num;
1363 point_total_num = 0;
1365 level_1d =
new int[dim_num];
1366 level_1d_max =
new int[dim_num];
1367 order_1d =
new int[dim_num];
1371 level_weight_min_pos = webbur->r8vec_min_pos ( dim_num, level_weight );
1372 q_min = ( double ) ( level_max ) * level_weight_min_pos
1373 - webbur->r8vec_sum ( dim_num, level_weight );
1374 q_max = ( double ) ( level_max ) * level_weight_min_pos;
1375 for ( dim = 0; dim < dim_num; dim++ )
1377 if ( 0.0 < level_weight[dim] )
1379 level_1d_max[dim] = ( int ) ( webbur->r8_floor ( q_max / level_weight[dim] ) ) + 1;
1380 if ( q_max <= ( level_1d_max[dim] - 1 ) * level_weight[dim] )
1382 level_1d_max[dim] = level_1d_max[dim] - 1;
1387 level_1d_max[dim] = 0;
1400 sgmga_vcn_ordered ( dim_num, level_weight, level_1d_max,
1401 level_1d, q_min, q_max, &more_grids );
1410 coef = sgmga_vcn_coef ( dim_num, level_weight, level_1d,
1420 for ( dim = 0; dim < dim_num; dim++ )
1422 order_1d[dim] = ((*webbur).*gw_compute_order[dim])(level_1d[dim],growth);
1424 point_total_num = point_total_num + webbur->i4vec_product ( dim_num,
1428 delete [] level_1d_max;
1431 return point_total_num;
1438 double level_weight[],
1440 void (
SandiaRules2::*gw_compute_points[] ) (
int order,
int dim,
double x[] ),
1443 int point_total_num,
1445 int (
SandiaRules::*gw_compute_order[] ) (
int level,
int growth ),
1446 int sparse_unique_index[]
1540 double level_weight_min_pos;
1548 int point_total_num2;
1554 int *sparse_total_index;
1555 int *sparse_total_order;
1556 double *sparse_total_point;
1561 if ( level_max < 0 )
1566 if ( level_max == 0 )
1568 sparse_unique_index[0] = 0;
1575 sparse_total_order =
new int[dim_num*point_total_num];
1576 sparse_total_index =
new int[dim_num*point_total_num];
1578 level_1d =
new int[dim_num];
1579 level_1d_max =
new int[dim_num];
1580 order_1d =
new int[dim_num];
1581 point_index =
new int[dim_num];
1583 point_total_num2 = 0;
1587 level_weight_min_pos = webbur->r8vec_min_pos ( dim_num, level_weight );
1588 q_min = ( double ) ( level_max ) * level_weight_min_pos
1589 - webbur->r8vec_sum ( dim_num, level_weight );
1590 q_max = ( double ) ( level_max ) * level_weight_min_pos;
1591 for ( dim = 0; dim < dim_num; dim++ )
1593 if ( 0.0 < level_weight[dim] )
1595 level_1d_max[dim] = ( int ) ( webbur->r8_floor ( q_max / level_weight[dim] ) ) + 1;
1596 if ( q_max <= ( level_1d_max[dim] - 1 ) * level_weight[dim] )
1598 level_1d_max[dim] = level_1d_max[dim] - 1;
1603 level_1d_max[dim] = 0;
1616 sgmga_vcn_ordered ( dim_num, level_weight, level_1d_max,
1617 level_1d, q_min, q_max, &more_grids );
1626 coef = sgmga_vcn_coef ( dim_num, level_weight, level_1d,
1636 for ( dim = 0; dim < dim_num; dim++ )
1638 order_1d[dim] = ((*webbur).*gw_compute_order[dim])(level_1d[dim],growth);
1643 more_points =
false;
1647 webbur->vec_colex_next3 ( dim_num, order_1d, point_index, &more_points );
1653 for ( dim = 0; dim < dim_num; dim++ )
1655 sparse_total_order[dim+point_total_num2*dim_num] = order_1d[dim];
1657 for ( dim = 0; dim < dim_num; dim++ )
1659 sparse_total_index[dim+point_total_num2*dim_num] = point_index[dim];
1661 point_total_num2 = point_total_num2 + 1;
1665 delete [] level_1d_max;
1667 delete [] point_index;
1671 sparse_total_point =
new double[dim_num*point_total_num];
1673 for ( point = 0; point < point_total_num; point++ )
1675 for ( dim = 0; dim < dim_num; dim++ )
1677 sparse_total_point[dim+point*dim_num] = webbur->r8_huge ( );
1683 level_1d_max =
new int[dim_num];
1684 level_weight_min_pos = webbur->r8vec_min_pos ( dim_num, level_weight );
1685 q_max = ( double ) ( level_max ) * level_weight_min_pos;
1687 for ( dim = 0; dim < dim_num; dim++ )
1689 if ( 0.0 < level_weight[dim] )
1691 level_1d_max[dim] = ( int ) ( webbur->r8_floor ( q_max / level_weight[dim] ) ) + 1;
1692 if ( q_max <= ( level_1d_max[dim] - 1 ) * level_weight[dim] )
1694 level_1d_max[dim] = level_1d_max[dim] - 1;
1699 level_1d_max[dim] = 0;
1702 for ( level = 0; level <= level_1d_max[dim]; level++ )
1704 order = ((*webbur).*gw_compute_order[dim]) ( level, growth );
1706 points =
new double[order];
1708 ((*webbur2).*gw_compute_points[dim]) ( order, dim, points );
1710 for ( point = 0; point < point_total_num; point++ )
1712 if ( sparse_total_order[dim+point*dim_num] == order )
1714 sparse_total_point[dim+point*dim_num] =
1715 points[sparse_total_index[dim+point*dim_num]-1];
1726 undx =
new int[point_num];
1730 webbur->point_radial_tol_unique_index ( dim_num, point_total_num,
1731 sparse_total_point, tol, &seed, undx, sparse_unique_index );
1733 for ( point = 0; point < point_total_num; point++ )
1735 rep = undx[sparse_unique_index[point]];
1738 for ( dim = 0; dim < dim_num; dim++ )
1740 sparse_total_point[dim+point*dim_num] = sparse_total_point[dim+rep*dim_num];
1747 webbur->point_unique_index ( dim_num, point_total_num, sparse_total_point,
1748 point_num, undx, sparse_unique_index );
1750 delete [] sparse_total_index;
1751 delete [] sparse_total_order;
1752 delete [] sparse_total_point;
1895 for ( i = 0; i < n; i++ )
1908 if ( nstart == - 1 )
1911 std::cerr <<
" SGMGA_VCN - Fatal error!\n";
1912 std::cerr <<
" No weight is positive.\n";
1918 for ( i = 0; i < n; i++ )
1946 else if ( dir == - 1 || dir == 0 )
1958 else if ( nstart < n2 )
1962 for ( i = n2 + 1; i < n; i++ )
1964 t = t - w[i] * ( double ) x[i];
1966 xmax[n2] = ( int ) ( webbur->r8_floor ( t / w[n2] ) );
1968 else if ( n2 == nstart && dir == - 1 )
1971 for ( i = n2 + 1; i < n; i++ )
1973 t = t - w[i] * ( double ) x[i];
1975 xmin = ( int ) ( webbur->r8_ceiling ( t / w[n2] ) );
1981 for ( i = 0; i < n2; i++ )
1983 t = t + w[i] * ( double ) x[i];
1985 t = t + w[n2] * xmin;
1986 for ( i = n2 + 1; i < n; i++ )
1988 t = t + w[i] * ( double ) x[i];
1996 for ( i = n2 + 1; i < n; i++ )
1998 t = t - w[i] * ( double ) x[i];
2000 xmax[n2] = ( int ) ( webbur->r8_floor ( t / w[n2] ) );
2003 if ( xmax[n2] < xmin )
2016 else if ( dir == 0 )
2019 if ( x[n2] <= xmax[n2] )
2039 else if ( dir == + 1 )
2055 if ( x[n2] < xmax[n2] )
2072 double level_weight[],
2213 b =
new int[dim_num];
2215 for ( i = 0; i < dim_num; i++ )
2227 while ( i < dim_num - 1 )
2233 if ( level_weight[i] == 0.0 )
2239 else if ( b[i] == 1 )
2256 for ( j = 0; j < dim_num; j++ )
2258 q = q + level_weight[j] * ( double ) ( x[j] + b[j] );
2273 while ( i < dim_num - 1 )
2277 if ( level_weight[i] == 0.0 )
2280 else if ( b[i] == 1 )
2295 for ( j = 0; j < dim_num; j++ )
2297 b_sum = b_sum + b[j];
2302 c = c + 1 - 2 * ( b_sum % 2 );
2311 coef = ( double ) ( c );
2321 double level_weight[],
2407 b =
new int[dim_num];
2409 for ( i = 0; i < dim_num; i++ )
2420 webbur->binary_vector_next ( dim_num, b );
2421 b_sum = webbur->i4vec_sum ( dim_num, b );
2434 for ( i = 0; i < dim_num; i++ )
2436 if ( x_max[i] < x[i] + b[i] )
2450 for ( i = 0; i < dim_num; i++ )
2452 q = q + level_weight[i] * ( double ) ( x[i] + b[i] );
2457 coef = coef + webbur->r8_mop ( b_sum );
2470 double level_weight[],
2603 for ( i = 0; i < dim_num; i++ )
2609 for ( i = 0; i < dim_num; i++ )
2611 q = q + level_weight[i] * ( double ) ( x[i] );
2614 if ( q_min < q && q <= q_max )
2626 if ( x[j] < x_max[j] )
2631 if ( dim_num - 1 <= j )
2640 for ( i = 0; i < j; i++ )
2646 for ( i = 0; i < dim_num; i++ )
2648 q = q + level_weight[i] * ( double ) ( x[i] );
2651 if ( q_min < q && q <= q_max )
2664 double level_weight[],
2798 static double q_max2;
2799 static double q_min2;
2806 q_max2 = webbur->r8_min ( q_min + 1.0, q_max );
2813 sgmga_vcn ( dim_num, level_weight, x, q_min2,
2825 if ( q_max2 < q_max )
2828 q_max2 = webbur->r8_min ( q_max2 + 1.0, q_max );
2846 double level_weight[],
2980 static double q_max2;
2981 static double q_min2;
2988 q_max2 = webbur->r8_min ( q_min + 1.0, q_max );
2995 sgmga_vcn_naive ( dim_num, level_weight, x_max, x, q_min2,
3007 if ( q_max2 < q_max )
3010 q_max2 = webbur->r8_min ( q_max2 + 1.0, q_max );
3028 double level_weight[],
3030 void (
SandiaRules2::*gw_compute_weights[] ) (
int order,
int dim,
double w[] ),
3032 int point_total_num,
3033 int sparse_unique_index[],
3035 int (
SandiaRules::*gw_compute_order[] ) (
int level,
int growth ),
3036 double sparse_weight[]
3113 double *grid_weight;
3117 double level_weight_min_pos;
3128 for ( point = 0; point < point_num; point++ )
3130 sparse_weight[point] = 0.0;
3135 level_1d =
new int[dim_num];
3136 order_1d =
new int[dim_num];
3137 level_1d_max =
new int[dim_num];
3141 level_weight_min_pos = webbur->r8vec_min_pos ( dim_num, level_weight );
3142 q_min = ( double ) ( level_max ) * level_weight_min_pos
3143 - webbur->r8vec_sum ( dim_num, level_weight );
3144 q_max = ( double ) ( level_max ) * level_weight_min_pos;
3145 for ( dim = 0; dim < dim_num; dim++ )
3147 if ( 0.0 < level_weight[dim] )
3149 level_1d_max[dim] = ( int ) ( webbur->r8_floor ( q_max / level_weight[dim] ) ) + 1;
3150 if ( q_max <= ( level_1d_max[dim] - 1 ) * level_weight[dim] )
3152 level_1d_max[dim] = level_1d_max[dim] - 1;
3157 level_1d_max[dim] = 0;
3170 sgmga_vcn_ordered ( dim_num, level_weight, level_1d_max,
3171 level_1d, q_min, q_max, &more_grids );
3180 coef = sgmga_vcn_coef ( dim_num, level_weight, level_1d,
3190 for ( dim = 0; dim < dim_num; dim++ )
3192 order_1d[dim] = ((*webbur).*gw_compute_order[dim])(level_1d[dim],growth);
3197 order_nd = webbur->i4vec_product ( dim_num, order_1d );
3206 grid_weight =
new double[order_nd];
3208 sgmga_product_weight ( dim_num, order_1d, order_nd,
3209 gw_compute_weights, grid_weight );
3213 for ( order = 0; order < order_nd; order++ )
3215 point_unique = sparse_unique_index[point_total];
3217 point_total = point_total + 1;
3219 sparse_weight[point_unique] = sparse_weight[point_unique]
3220 + coef * grid_weight[order];
3223 delete [] grid_weight;
3227 delete [] level_1d_max;
double sgmga_vcn_coef_naive(int n, double level_weight[], int x_max[], int x[], double q_min, double q_max)
void sgmga_weight(int dim_num, double level_weight[], int level_max, void(SandiaRules2::*gw_compute_weights[])(int order, int dim, double w[]), int point_num, int point_total_num, int sparse_unique_index[], int growth, int(SandiaRules::*gw_compute_order[])(int level, int growth), double sparse_weight[])
void sgmga_product_weight(int dim_num, int order_1d[], int order_nd, void(SandiaRules2::*gw_compute_weights[])(int order, int dim, double w[]), double weight_nd[])
int sgmga_size_total(int dim_num, double level_weight[], int level_max, int growth, int(SandiaRules::*gw_compute_order[])(int level, int growth))
void sgmga_vcn_ordered(int dim_num, double level_weight[], int x_max[], int x[], double q_min, double q_max, bool *more)
void sgmga_point(int dim_num, double level_weight[], int level_max, void(SandiaRules2::*gw_compute_points[])(int order, int dim, double x[]), int point_num, int sparse_order[], int sparse_index[], int growth, int(SandiaRules::*gw_compute_order[])(int level, int growth), double sparse_point[])
double * sgmga_aniso_balance(double alpha_max, int dim_num, double level_weight[])
void sgmga_vcn(int n, double level_weight[], int x[], double q_min, double q_max, bool *more)
int sgmga_size(int dim_num, double level_weight[], int level_max, void(SandiaRules2::*gw_compute_points[])(int order, int dim, double x[]), double tol, int growth, int(SandiaRules::*gw_compute_order[])(int level, int growth))
double sgmga_vcn_coef(int n, double level_weight[], int x[], double q_max)
void sgmga_vcn_ordered_naive(int dim_num, double level_weight[], int x_max[], int x[], double q_min, double q_max, bool *more)
void sgmga_unique_index(int dim_num, double level_weight[], int level_max, void(SandiaRules2::*gw_compute_points[])(int order, int dim, double x[]), double tol, int point_num, int point_total_num, int growth, int(SandiaRules::*gw_compute_order[])(int level, int growth), int sparse_unique_index[])
void sgmga_importance_to_aniso(int dim_num, double importance[], double level_weight[])
void sgmga_index(int dim_num, double level_weight[], int level_max, int point_num, int point_total_num, int sparse_unique_index[], int growth, int(SandiaRules::*gw_compute_order[])(int level, int growth), int sparse_order[], int sparse_index[])
void sgmga_vcn_naive(int n, double level_weight[], int x_max[], int x[], double q_min, double q_max, bool *more)
void sgmga_aniso_normalize(int option, int dim_num, double level_weight[])