public static double[] product_weights_open(int dim_num, int[] order_1d, int order_nd,
int rule)
//****************************************************************************80
//
// Purpose:
//
// PRODUCT_WEIGHTS_OPEN: weights for an open product rule.
//
// Discussion:
//
// This routine computes the weights for a quadrature rule which is
// a product of 1D rules of varying order.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 01 February 2009
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int DIM_NUM, the spatial dimension.
//
// Input, int ORDER_1D[DIM_NUM], the order of the 1D rules.
//
// Input, int ORDER_ND, the order of the product rule.
//
// Input, int RULE, the 1D quadrature rule being used.
// 2, Fejer Type 2 Rule;
// 3, Gauss-Patterson Rule,
// 4, Newton-Cotes Open Rule,
// 5, Tanh-Sinh Rule.
//
// Output, double PRODUCT_WEIGHTS_OPEN[DIM_NUM*ORDER_ND], the product
// rule weights.
//
{
int dim;
int order;
double[] w_1d = null;
typeMethods.r8vecDPData data = new();
double[] w_nd = new double[order_nd];
for (order = 0; order < order_nd; order++)
{
w_nd[order] = 1.0;
}
for (dim = 0; dim < dim_num; dim++)
{
w_1d = rule switch
{
2 => Fejer2.f2_weights(order_1d[dim]),
3 => PattersonQuadrature.gp_weights(order_1d[dim]),
4 => NewtonCotesQuadrature.nco_weights(order_1d[dim]),
5 => TanhSinh.ts_weights(order_1d[dim]),
_ => w_1d
};
typeMethods.r8vec_direct_product2(ref data, dim, order_1d[dim], w_1d, dim_num,
order_nd, ref w_nd);
}
return(w_nd);
}
}
public static double[] product_weights(int dim_num, int[] order_1d, int order_nd, int rule)
//****************************************************************************80
//
// Purpose:
//
// PRODUCT_WEIGHTS computes the weights of a product rule.
//
// Discussion:
//
// This routine computes the weights for a quadrature rule which is
// a product of closed rules of varying order.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 09 November 2007
//
// Author:
//
// John Burkardt
//
// Parameters:
//
// Input, int DIM_NUM, the spatial dimension.
//
// Input, int ORDER_1D[DIM_NUM], the order of the 1D rules.
//
// Input, int ORDER_ND, the order of the product rule.
//
// Input, int RULE, the index of the rule.
// 1, "CC", Clenshaw Curtis Closed Fully Nested rule.
// 2, "F1", Fejer 1 Open Fully Nested rule.
// 3, "F2", Fejer 2 Open Fully Nested rule.
// 4, "GP", Gauss Patterson Open Fully Nested rule.
// 5, "GL", Gauss Legendre Open Weakly Nested rule.
// 6, "GH", Gauss Hermite Open Weakly Nested rule.
// 7, "LG", Gauss Laguerre Open Non Nested rule.
//
// Output, double PRODUCT_WEIGHTS_CC[DIM_NUM*ORDER_ND],
// the product rule weights.
//
{
int dim;
int order;
typeMethods.r8vecDPData data = new();
double[] w_nd = new double[order_nd];
for (order = 0; order < order_nd; order++)
{
w_nd[order] = 1.0;
}
for (dim = 0; dim < dim_num; dim++)
{
double[] w_1d;
switch (rule)
{
case 1:
w_1d = ClenshawCurtis.cc_weights(order_1d[dim]);
break;
case 2:
w_1d = Fejer1.f1_weights(order_1d[dim]);
break;
case 3:
w_1d = Fejer2.f2_weights(order_1d[dim]);
break;
case 4:
w_1d = PattersonQuadrature.gp_weights(order_1d[dim]);
break;
case 5:
w_1d = GaussQuadrature.gl_weights(order_1d[dim]);
break;
case 6:
w_1d = GaussHermite.gh_weights(order_1d[dim]);
break;
case 7:
w_1d = Legendre.QuadratureRule.lg_weights(order_1d[dim]);
break;
default:
Console.WriteLine("");
Console.WriteLine("PRODUCT_WEIGHTS - Fatal error!");
Console.WriteLine(" Unrecognized rule number = " + rule + "");
return(null);
}
typeMethods.r8vec_direct_product2(ref data, dim, order_1d[dim], w_1d, dim_num,
order_nd, ref w_nd);
}
return(w_nd);
}