SANDIA_RULES Quadrature Rules of Gaussian Type

SANDIA_RULES is a C library which generates a variety of quadrature rules of various orders.

This library is used, in turn, by several other libraries, including SPARSE_GRID_MIXED, SPARSE_GRID_MIXED_GROWTH, and SGMGA. This means that a program that calls any one of those libraries must have access to a compiled copy of SANDIA_RULES as well.

Name Usual domain Weight function
Gauss-Legendre [-1,+1] 1
Clenshaw-Curtis [-1,+1] 1
Fejer Type 2 [-1,+1] 1
Gauss-Chebyshev 1 [-1,+1] 1/sqrt(1-x2)
Gauss-Chebyshev 2 [-1,+1] sqrt(1-x2)
Gauss-Gegenbauer [-1,+1] (1-x2)alpha
Gauss-Jacobi [-1,+1] (1-x)alpha (1+x)beta
Gauss-Laguerre [0,+oo) e-x
Generalized Gauss-Laguerre [0,+oo) xalpha e-x
Gauss-Hermite (-oo,+oo) e-x*x
Generalized Gauss-Hermite (-oo,+oo) |x|alpha e-x*x

For example, a Gauss-Gegenbauer quadrature rule is used to approximate:

```        Integral ( -1 <= x <= +1 ) f(x) (1-x^2)^alpha dx
```
where alpha is a real parameter chosen by the user.

The approximation to the integral is formed by computing a weighted sum of function values at specific points:

```        Sum ( 1 <= i <= n ) w(i) * f(x(i))
```
The quantities x are the abscissas of the quadrature rule, the values w are the weights of the quadrature rule, and the number of terms n in the sum is the order of the quadrature rule.

As a matter of convenience, most of the quadrature rules are available through three related functions:

• name_COMPUTE returns points X and weights W;
• name_COMPUTE_POINTS returns points X;
• name_COMPUTE_WEIGHTS returns weights W;
In some cases, it is possible to compute points or weights separately; in other cases, the point and weight functions actually call the underlying function for the entire rule, and then discard the unrequested information.

Some of these quadrature rules expect a parameter ALPHA, and perhaps also a parameter BETA, in order to fully define the rule. Therefore, the argument lists of these functions vary. They always include the input quantity ORDER, but may have one or two additional inputs. In order to offer a uniform interface, there is also a family of functions with a standard set of input arguments, ORDER, NP, and P. Here NP is parameter counter, and P is the parameter value vector P. Using this interface, it is possible to call all the quadrature functions with the same argument list. The uniform interface functions can be identified by the suffix _NP that appears in their names. Generally, these functions "unpack" the parameter vector where needed, and then call the corresponding basic function. Of course, for many rules NP is zero and P may be a null pointer.

• name_COMPUTE_NP ( ORDER, NP, P, X, W ) unpacks parameters, calls name_COMPUTE, returns points X and weights W;
• name_COMPUTE_POINTS_NP ( ORDER, NP, P, X ) unpacks parameters, calls name_COMPUTE_POINTS, returns points X;
• name_COMPUTE_WEIGHTS_NP ( ORDER, NP, P, W ) unpacks parameters, calls name_COMPUTE_WEIGHTS, returns weights W;

Languages:

SANDIA_RULES is available in a C version and a C++ version and a FORTRAN90 version and a MATLAB version.

Related Data and Programs:

CHEBYSHEV1_RULE, is a C++ program which can compute and print a Gauss-Chebyshev type 1 quadrature rule.

CHEBYSHEV2_RULE, a C++ program which can compute and print a Gauss-Chebyshev type 2 quadrature rule.

GEGENBAUER_RULE, a C++ program which can compute and print a Gauss-Gegenbauer quadrature rule.

GEN_HERMITE_RULE, a C++ program which can compute and print a generalized Gauss-Hermite quadrature rule.

GEN_LAGUERRE_RULE, a C++ program which can compute and print a generalized Gauss-Laguerre quadrature rule.

HERMITE_RULE, a C++ program which can compute and print a Gauss-Hermite quadrature rule.

INT_EXACTNESS_GEN_HERMITE, a C++ program which checks the polynomial exactness of a generalized Gauss-Hermite quadrature rule.

INT_EXACTNESS_GEN_LAGUERRE, a C++ program which checks the polynomial exactness of a generalized Gauss-Laguerre quadrature rule.

INT_EXACTNESS_HERMITE, a C++ program which checks the polynomial exactness of a Gauss-Hermite quadrature rule.

INT_EXACTNESS_JACOBI, a C++ program which checks the polynomial exactness of a Gauss-Jacobi quadrature rule.

INT_EXACTNESS_LAGUERRE, a C++ program which checks the polynomial exactness of a Gauss-Laguerre quadrature rule.

INT_EXACTNESS_LEGENDRE, a C++ program which checks the polynomial exactness of a Gauss-Legendre quadrature rule.

INTLIB, a FORTRAN90 library which contains routines for numerical estimation of integrals in 1D.

JACOBI_RULE, a C++ program which can compute and print a Gauss-Jacobi quadrature rule.

LAGUERRE_RULE, a C++ program which can compute and print a Gauss-Laguerre quadrature rule.

LEGENDRE_RULE, is a C++ program which can compute and print a Gauss-Legendre quadrature rule.

PRODUCT_RULE, a C++ program which constructs a product rule from 1D factor rules.

QUADPACK a FORTRAN90 library which contains routines for numerical estimation of integrals in 1D.

QUADRATURE_RULES is a dataset directory which contains sets of files that define quadrature rules over various 1D intervals or multidimensional hypercubes.

QUADRATURE_RULES_LEGENDRE, a dataset directory which contains triples of files defining standard Gauss-Legendre quadrature rules.

SGMGA, a C++ library which creates sparse grids based on a mixture of 1D quadrature rules, allowing anisotropic weights for each dimension.

SPARSE_GRID_MIXED, a C++ library which creates a sparse grid dataset based on a mixed set of 1D factor rules.

SPARSE_GRID_MIXED_GROWTH, a C++ library which creates a sparse grid dataset based on a mixed set of 1D factor rules, and experiments with the use of a linear growth rate for the quadrature rules.

TEST_INT, a FORTRAN90 library which defines functions that may be used as test integrands for quadrature rules in 1D.

Reference:

1. Milton Abramowitz, Irene Stegun,
Handbook of Mathematical Functions,
National Bureau of Standards, 1964,
ISBN: 0-486-61272-4,
LC: QA47.A34.
2. William Cody,
An Overview of Software Development for Special Functions,
in Numerical Analysis Dundee, 1975,
edited by GA Watson,
Lecture Notes in Mathematics 506,
Springer, 1976.
3. Philip Davis, Philip Rabinowitz,
Methods of Numerical Integration,
Second Edition,
Dover, 2007,
ISBN: 0486453391,
LC: QA299.3.D28.
Fully symmetric interpolatory rules for multiple integrals over infinite regions with Gaussian weight,
Journal of Computational and Applied Mathematics,
Volume 71, 1996, pages 299-309.
5. John Hart, Ward Cheney, Charles Lawson, Hans Maehly, Charles Mesztenyi, John Rice, Henry Thatcher, Christoph Witzgall,
Computer Approximations,
Wiley, 1968,
LC: QA297.C64.
6. Arthur Stroud, Don Secrest,
Prentice Hall, 1966,
LC: QA299.4G3S7.
7. Shanjie Zhang, Jianming Jin,
Computation of Special Functions,
Wiley, 1996,
ISBN: 0-471-11963-6,
LC: QA351.C45

List of Routines:

• BINARY_VECTOR_NEXT generates the next binary vector.
• CHEBYSHEV1_COMPUTE computes a Chebyshev type 1 quadrature rule.
• CHEBYSHEV1_COMPUTE_NP computes a Chebyshev type 1 quadrature rule.
• CHEBYSHEV1_COMPUTE_POINTS computes Chebyshev type 1 quadrature points.
• CHEBYSHEV1_COMPUTE_POINTS_NP computes Chebyshev type 1 quadrature points.
• CHEBYSHEV1_COMPUTE_WEIGHTS computes Chebyshev type 1 quadrature weights.
• CHEBYSHEV1_COMPUTE_WEIGHTS_NP: Chebyshev type 1 quadrature weights.
• CHEBYSHEV1_INTEGRAL evaluates a monomial Chebyshev type 1 integral.
• CHEBYSHEV2_COMPUTE computes a Chebyshev type 2 quadrature rule.
• CHEBYSHEV2_COMPUTE_NP computes a Chebyshev type 2 quadrature rule.
• CHEBYSHEV2_COMPUTE_POINTS computes Chebyshev type 2 quadrature points.
• CHEBYSHEV2_COMPUTE_POINTS_NP computes Chebyshev type 2 quadrature points.
• CHEBYSHEV2_COMPUTE_WEIGHTS computes Chebyshev type 2 quadrature weights.
• CHEBYSHEV2_COMPUTE_WEIGHTS_NP: Chebyshev type 2 quadrature weights.
• CHEBYSHEV2_INTEGRAL evaluates a monomial Chebyshev type 2 integral.
• CLENSHAW_CURTIS_COMPUTE computes a Clenshaw Curtis quadrature rule.
• CLENSHAW_CURTIS_COMPUTE_NP computes a Clenshaw Curtis quadrature rule.
• CLENSHAW_CURTIS_COMPUTE_POINTS computes Clenshaw Curtis quadrature points.
• CLENSHAW_CURTIS_COMPUTE_POINTS_NP: Clenshaw Curtis quadrature points.
• CLENSHAW_CURTIS_COMPUTE_WEIGHTS computes Clenshaw Curtis quadrature weights.
• CLENSHAW_CURTIS_COMPUTE_WEIGHTS_NP: Clenshaw Curtis quadrature weights.
• COMP_NEXT computes the compositions of the integer N into K parts.
• CPU_TIME reports the total CPU time for a program.
• FEJER2_COMPUTE computes a Fejer type 2 rule.
• FEJER2_COMPUTE_NP computes a Fejer type 2 rule.
• FEJER2_COMPUTE_POINTS computes Fejer type 2 quadrature points.
• FEJER2_COMPUTE_POINTS_NP computes Fejer type 2 quadrature points.
• FEJER2_COMPUTE_WEIGHTS computes Fejer type 2 quadrature weights.
• FEJER2_COMPUTE_WEIGHTS_NP computes Fejer type 2 quadrature weights.
• GEGENBAUER_COMPUTE computes a Gegenbauer quadrature rule.
• GEGENBAUER_COMPUTE_NP computes a Gegenbauer quadrature rule.
• GEGENBAUER_COMPUTE_POINTS computes Gegenbauer quadrature points.
• GEGENBAUER_COMPUTE_POINTS_NP computes Gegenbauer quadrature points.
• GEGENBAUER_COMPUTE_WEIGHTS computes Gegenbauer quadrature weights.
• GEGENBAUER_COMPUTE_WEIGHTS_NP computes Gegenbauer quadrature weights.
• GEGENBAUER_INTEGRAL integrates a monomial with Gegenbauer weight.
• GEGENBAUER_RECUR evaluates a Gegenbauer polynomial.
• GEGENBAUER_ROOT improves an approximate root of a Gegenbauer polynomial.
• GEN_HERMITE_COMPUTE computes a Generalized Hermite quadrature rule.
• GEN_HERMITE_COMPUTE_NP computes a Generalized Hermite quadrature rule.
• GEN_HERMITE_COMPUTE_POINTS computes Generalized Hermite quadrature points.
• GEN_HERMITE_COMPUTE_POINTS_NP: Generalized Hermite quadrature points.
• GEN_HERMITE_COMPUTE_WEIGHTS computes Generalized Hermite quadrature weights.
• GEN_HERMITE_COMPUTE_WEIGHTS_NP: Generalized Hermite quadrature weights.
• GEN_HERMITE_INTEGRAL evaluates a monomial Generalized Hermite integral.
• GEN_LAGUERRE_COMPUTE computes a Generalized Laguerre quadrature rule.
• GEN_LAGUERRE_COMPUTE_NP computes a Generalized Laguerre quadrature rule.
• GEN_LAGUERRE_COMPUTE_POINTS: Generalized Laguerre quadrature points.
• GEN_LAGUERRE_COMPUTE_POINTS_NP: Generalized Laguerre quadrature points.
• GEN_LAGUERRE_COMPUTE_WEIGHTS: Generalized Laguerre quadrature weights.
• GEN_LAGUERRE_COMPUTE_WEIGHTS_NP: Generalized Laguerre quadrature weights.
• GEN_LAGUERRE_INTEGRAL evaluates a monomial Generalized Laguerre integral.
• GEN_LAGUERRE_RECUR evaluates a Generalized Laguerre polynomial.
• GEN_LAGUERRE_ROOT improves a root of a Generalized Laguerre polynomial.
• HERMITE_COMPUTE computes a Hermite quadrature rule.
• HERMITE_COMPUTE_NP computes a Hermite quadrature rule.
• HERMITE_COMPUTE_POINTS computes Hermite quadrature points.
• HERMITE_COMPUTE_POINTS_NP computes Hermite quadrature points.
• HERMITE_COMPUTE_WEIGHTS computes Hermite quadrature weights.
• HERMITE_COMPUTE_WEIGHTS_NP computes Hermite quadrature weights.
• HERMITE_GENZ_KEISTER_LOOKUP looks up a Genz-Keister Hermite rule.
• HERMITE_GENZ_KEISTER_LOOKUP_POINTS looks up Genz-Keister Hermite abscissas.
• HERMITE_GENZ_KEISTER_LOOKUP_POINTS_NP looks up Genz-Keister Hermite abscissas.
• HERMITE_GENZ_KEISTER_LOOKUP_WEIGHTS looks up Genz-Keister Hermite weights.
• HERMITE_GENZ_KEISTER_LOOKUP_WEIGHTS_NP looks up Genz-Keister Hermite weights.
• HERMITE_INTEGRAL evaluates a monomial Hermite integral.
• HERMITE_RECUR finds the value and derivative of a Hermite polynomial.
• HERMITE_ROOT improves an approximate root of a Hermite polynomial.
• I4_MAX returns the maximum of two I4's.
• I4_MIN returns the smaller of two I4's.
• I4_POWER returns the value of I^J.
• I4MAT_WRITE writes an I4MAT file.
• I4VEC_PRINT prints an I4VEC.
• I4VEC_PRODUCT multiplies the entries of an I4VEC.
• I4VEC_SUM sums the entries of an I4VEC.
• JACOBI_COMPUTE computes a Jacobi quadrature rule.
• JACOBI_COMPUTE_NP computes a Jacobi quadrature rule.
• JACOBI_COMPUTE_POINTS computes Jacobi quadrature points.
• JACOBI_COMPUTE_POINTS_NP computes Jacobi quadrature points.
• JACOBI_COMPUTE_WEIGHTS computes Jacobi quadrature weights.
• JACOBI_COMPUTE_WEIGHTS_NP computes Jacobi quadrature weights.
• JACOBI_INTEGRAL integrates a monomial with Jacobi weight.
• JACOBI_RECUR evaluates a Jacobi polynomial.
• JACOBI_ROOT improves an approximate root of a Jacobi polynomial.
• LAGUERRE_COMPUTE computes a Laguerre quadrature rule.
• LAGUERRE_COMPUTE_NP computes a Laguerre quadrature rule.
• LAGUERRE_COMPUTE_POINTS computes Laguerre quadrature points.
• LAGUERRE_COMPUTE_POINTS_NP computes Laguerre quadrature points.
• LAGUERRE_COMPUTE_WEIGHTS computes Laguerre quadrature weights.
• LAGUERRE_COMPUTE_WEIGHTS_NP computes Laguerre quadrature weights.
• LAGUERRE_INTEGRAL evaluates a monomial Laguerre integral.
• LAGUERRE_RECUR evaluates a Laguerre polynomial.
• LAGUERRE_ROOT improves a root of a Laguerre polynomial.
• LEGENDRE_COMPUTE computes a Legendre quadrature rule.
• LEGENDRE_COMPUTE_NP computes a Legendre quadrature rule.
• LEGENDRE_COMPUTE_POINTS computes Legendre quadrature points.
• LEGENDRE_COMPUTE_POINTS_NP computes Legendre quadrature points.
• LEGENDRE_COMPUTE_WEIGHTS computes Legendre quadrature weights.
• LEGENDRE_COMPUTE_WEIGHTS_NP computes Legendre quadrature weights.
• LEGENDRE_INTEGRAL evaluates a monomial Legendre integral.
• LEVEL_GROWTH_TO_ORDER: convert Level and Growth to Order.
• LEVEL_TO_ORDER_DEFAULT: default growth.
• LEVEL_TO_ORDER_EXPONENTIAL: exponential growth.
• LEVEL_TO_ORDER_EXPONENTIAL_SLOW: slow exponential growth;
• LEVEL_TO_ORDER_LINEAR: linear growth.
• NC_COMPUTE computes a Newton-Cotes quadrature rule.
• NCC_COMPUTE_POINTS: points of a Newton-Cotes Closed quadrature rule.
• NCC_COMPUTE_WEIGHTS: weights of a Newton-Cotes Closed quadrature rule.
• NCO_COMPUTE_POINTS: points of a Newton-Cotes Open quadrature rule.
• NCO_COMPUTE_WEIGHTS: weights of a Newton-Cotes Open quadrature rule.
• PATTERSON_LOOKUP looks up Patterson quadrature points and weights.
• PATTERSON_LOOKUP_POINTS looks up Patterson quadrature points.
• PATTERSON_LOOKUP_POINTS_NP looks up Patterson quadrature points.
• PATTERSON_LOOKUP_WEIGHTS looks up Patterson quadrature weights.
• PATTERSON_LOOKUP_WEIGHTS_NP looks up Patterson quadrature weights.
• POINT_RADIAL_TOL_UNIQUE_COUNT counts the tolerably unique points.
• POINT_RADIAL_TOL_UNIQUE_INDEX indexes the tolerably unique points.
• POINT_UNIQUE_INDEX indexes unique points.
• PRODUCT_MIXED_WEIGHT computes the weights of a mixed product rule.
• R8_ABS returns the absolute value of an R8.
• R8_CEILING returns the "ceiling" of an R8.
• R8_CHOOSE computes the binomial coefficient C(N,K) as an R8.
• R8_EPSILON returns the R8 round off unit.
• R8_FACTORIAL computes the factorial of N.
• R8_FACTORIAL2 computes the double factorial function.
• R8_FLOOR rounds an R8 "down" (towards -infinity) to the next integer.
• R8_GAMMA evaluates Gamma(X) for a real argument.
• R8_HUGE returns a "huge" R8.
• R8_HYPER_2F1 evaluates the hypergeometric function 2F1(A,B,C,X).
• R8_MAX returns the maximum of two R8's.
• R8_MIN returns the minimum of two R8's.
• R8_MOP returns the I-th power of -1 as an R8 value.
• R8_PSI evaluates the function Psi(X).
• R8COL_COMPARE compares two columns in an R8COL.
• R8COL_SORT_HEAP_A ascending heapsorts an R8COL.
• R8COL_SORT_HEAP_INDEX_A does an indexed heap ascending sort of an R8COL.
• R8COL_SORTED_UNIQUE_COUNT counts unique elements in a sorted R8COL.
• R8COL_SWAP swaps columns J1 and J2 of an R8COL.
• R8COL_TOL_UNDEX indexes tolerably unique entries in an R8COL.
• R8COL_TOL_UNIQUE_COUNT counts tolerably unique entries in an R8COL.
• R8COL_UNDEX returns unique sorted indexes for an R8COL.
• R8COL_UNIQUE_INDEX indexes the unique occurrence of values in an R8COL.
• R8MAT_TRANSPOSE_PRINT prints an R8MAT, transposed.
• R8MAT_TRANSPOSE_PRINT_SOME prints some of an R8MAT, transposed.
• R8MAT_WRITE writes an R8MAT file.
• R8VEC_COMPARE compares two R8VEC's.
• R8VEC_COPY copies an R8VEC.
• R8VEC_DIRECT_PRODUCT2 creates a direct product of R8VEC's.
• R8VEC_INDEX_SORTED_RANGE: search index sorted vector for elements in a range.
• R8VEC_MIN returns the value of the minimum element in an R8VEC.
• R8VEC_MIN_POS returns the minimum positive value of an R8VEC.
• R8VEC_PRINT prints an R8VEC.
• R8VEC_SORT_HEAP_INDEX_A does an indexed heap ascending sort of an R8VEC
• R8VEC_SUM returns the sum of an R8VEC.
• R8VEC_UNIFORM_01_NEW returns a unit pseudorandom R8VEC.
• SORT_HEAP_EXTERNAL externally sorts a list of items into ascending order.
• TIMESTAMP prints the current YMDHMS date as a time stamp.
• VEC_COLEX_NEXT3 generates vectors in colex order.

You can go up one level to the C source codes.

Last revised on 30 September 2010.