quadrule: Quadrule \(hy c library of quadrature rules

DESCRIPTION

APPROXIMATING INTEGRALS

The following functions apply an existing set of abscissas and weights to compute an approximation to an integral. double summer ( double func ( double x ), int order, double xtab[], double weight[] )

Carries out a quadrature rule over a single interval. double sum_sub ( double func ( double x ), double a, double b, int nsub, int order, double xlo, double xhi, double xtab[], double weight[] )

Carries out a composite quadrature rule.

xlo and xhi are the left and right endpoints of the interval over which the quadrature rule was defined.

a and b are the lower and upper limits of integration.

nsub is the number of equal subintervals into which the finite interval (a,b) is to be subdivided for higher accuracy. nsub must be at least 1. double bdf_sum ( double func ( double x ), int order, double xtab[], double weight[] )

Carries out explicit backward difference quadrature on [0,1]. Requires xtab and weight to be pre\(hycomputed from bdfc_set or bdfp_set. double laguerre_sum ( double func ( double x ), double a, int order, double xtab[], double weight[] )

Carries out Laguerre quadrature over [ A, +oo ). Requires xtab and weight to be pre\(hycomputed from laguerre_compute, gen_laguerre_compute, or laguerre_set. void summer_gk ( double func ( double x ), int orderg, double weightg[], double *resultg, int orderk , double xtabk[], double weightk[], double *resultk )

Carries out Gauss\(hyKronrod quadrature over a single interval. Before calling this function, weightg should be pre\(hycomputed from legendre_compute_dr or legendre_set. Also, xtabk and weightk should be pre\(hycomputed from kronrod_set. The orders should follow the relation orderk = 2 * orderg + 1. resultk will contain the result of the Gauss\(hyKronrod sum. resultg contains an intermediate sum, using only the Gauss quadrature. void sum_sub_gk ( double func ( double x ), double a, double b, int nsub, int orderg, double weightg[], double *resultg, int orderk, double xtabk[], double weightk[], double *resultk, double *error )

Carries out a composite Gauss\(hyKronrod rule. Approximates the integral of func from a to b, by dividing the domain into nsub subdomains, and applying a Gauss\(hyKronrod rule on each subdomain.

The following are utility function(s), to modify existing weights / abscissas before computing an integral. void rule_adjust ( double a, double b, double c, double d, int order, double xtab[], double weight[] )

Maps a quadrature rule from [A,B] to [C,D]. xtab and weight are overwritten.

COMPUTING QUADRATURE ABSCISSAS / WEIGHTS

The following functions compute arrays of abscissas and weights (xtab, weight) for a particular quadrature rule, for any given order. The range of the abscissas is ( -1 <= x < 1 ) unless otherwise given.

NOTE: xtab and weight must be allocated before calling these functions. void chebyshev1_compute ( int order, double xtab[], double weight[] )

Computes a Gauss\(hyChebyshev type 1 quadrature rule. void chebyshev2_compute ( int order, double xtab[], double weight[] )

Computes a Gauss\(hyChebyshev type 2 quadrature rule. void chebyshev3_compute ( int order, double xtab[], double weight[] )

Computes a Gauss\(hyChebyshev type 3 quadrature rule. void clenshaw_curtis_compute ( int order, double xtab[], double weight[] )

Computes a Clenshaw Curtis quadrature rule. void fejer1_compute ( int order, double xtab[], double weight[] )

Computes a Fejer type 1 quadrature rule. void fejer2_compute ( int order, double xtab[], double weight[] )

Computes a Fejer type 2 quadrature rule. void gegenbauer_compute ( int order, double alpha, double xtab[], double weight[] )

Computes a Gauss\(hyGegenbauer quadrature rule. void gen_hermite_compute ( int order, double alpha, double xtab[], double weight[] )

Computes a generalized Gauss\(hyHermite rule for the interval ( -infinity < x < +infinity ) void gen_laguerre_compute ( int order, double alpha, double xtab[], double weight[] )

Computes a generalized Gauss\(hyLaguerre quadrature rule for the interval ( alpha <= x < infinity ) void hermite_ek_compute ( int order, double xtab[], double weight[] )

Computes a Gauss\(hyHermite quadrature rule, using an algorithm by Elhay and Kautsky. Interval is ( -infinity < x < infinity ) void hermite_ss_compute ( int order, double xtab[], double weight[] )

Computes a Gauss\(hyHermite quadrature rule, using an algorithm by Arthur Stroud and Don Secrest. Interval is ( -infinity < x < infinity ) void jacobi_compute ( int order, double alpha, double beta, double xtab[], double weight[] )

Computes a Gauss\(hyJacobi quadrature rule. void laguerre_compute ( int order, double xtab[], double weight[] )

Computes a Gauss\(hyLaguerre quadrature rule for the inverval ( 0 <= x < infinity ) void legendre_compute_dr ( int order, double xtab[], double weight[] )

Gauss\(hyLegendre quadrature by Davis\(hyRabinowitz method. void lobatto_compute ( int order, double xtab[], double weight[] )

Computes a Lobatto quadrature rule. void nc_compute ( int order, double x_min, double x_max, double xtab[], double weight[] )

Computes a Newton\(hyCotes quadrature rule.

( x_min <= x <= x_max ) void ncc_compute ( int order, double xtab[], double weight[] )

Computes a Newton\(hyCotes Closed quadrature rule. void nco_compute ( int order, double xtab[], double weight[] )

Computes a Newton\(hyCotes Open quadrature rule. void ncoh_compute ( int order, double xtab[], double weight[] )

Computes a Newton\(hyCotes "open half" quadrature rule.

( x_min <= x <= x_max ) void radau_compute ( int order, double xtab[], double weight[] )

Computes a Radau quadrature rule.

PRE\(hyCOMPUTED QUADRATURES

The following functions return abscissas/weights for various quadrature rules, but only for particular orders.

NOTE: Check the valid range of order parameters for the particular function before using it. Using an unsupported order will cause an abort. void bashforth_set ( int order, double xtab[], double weight [] )

Sets an Adams\(hyBashforth quadrature for order = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, or 20. void bdfc_set ( int order, double xtab[], double weight[] )

Sets weights for backward differentiation corrector quadrature, for 1 <= order <= 19. void bdfp_set ( int order, double xtab[], double weight[] )

Sets weights for backward differentiation predictor quadrature, for 1 <= order <= 19. void cheb_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Chebyshev quadrature, for order = 1, 2, 3, 4, 5, 6, 7, or 9. void clenshaw_curtis_set ( int order, double xtab[], double weight[] )

Sets a Clenshaw\(hyCurtis quadrature rule, for order = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 33, 65, or 129. void fejer1_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Fejer type 1 quadrature, for order = 1, 2, 3, 4, 5, 6, 7, 8, 9, or 10. void fejer2_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Fejer type 2 quadrature, for order = 1, 2, 3, 4, 5, 6, 7, 8, 9, or 10. void hermite_genz_keister_set ( int order, double xtab[], double weight[] )

Sets a Hermite Genz\(hyKeister rule, for order = 1, 3, 7, 9, 17, 19, 31, 33, or 35. void hermite_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Hermite quadrature. The order must be between 1 and 20, or 31/32/33, 63/64/65, 127/128/129. void kronrod_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Gauss\(hyKronrod quadrature. The order may be 15, 21, 31 or 41, corresponding to Gauss\(hyLegendre rules of order 7, 10, 15 or 20. void laguerre_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Laguerre quadrature. The order must be between 1 and 20, or 31/32/33, 63/64/65, 127/128/129. void legendre_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Gauss\(hyLegendre quadrature. The order must be between 1 and 33 or 63/64/65, 127/128/129, 255/256/257. void legendre_set_cos ( int order, double xtab[], double weight[] )

Sets Gauss\(hyLegendre rules for COS(X)*F(X) on [-PI/2,PI/2]. The order must be 1, 2, 4, 8 or 16. void legendre_set_cos2 ( int order, double xtab[], double weight[] )

Sets Gauss\(hyLegendre rules for COS(X)*F(X) on [0,PI/2]. The order must be 2, 4, 8 or 16. void legendre_set_log ( int order, double xtab[], double weight[] )

Sets a Gauss\(hyLegendre rule for - LOG(X) * F(X) on [0,1]. The order must be between 1 through 8, or 16. void legendre_set_sqrtx_01 ( int order, double xtab[], double weight[] )

Sets Gauss\(hyLegendre rules for SQRT(X)*F(X) on [0,1]. The order must be between 1 and 16 or 63/64, 127/128. void legendre_set_sqrtx2_01 ( int order, double xtab[], double weight[] )

Sets Gauss\(hyLegendre rules for F(X)/SQRT(X) on [0,1]. The order must be be tween 1 and 16 or 63/64, 127/128. void legendre_set_x0_01 ( int order, double xtab[], double weight[] )

Sets a Gauss\(hyLegendre rule for F(X) on [0,1]. The order must be between 1 and 8. void legendre_set_x1 ( int order, double xtab[], double weight[] )

Sets a Gauss\(hyLegendre rule for ( 1 + X ) * F(X) on [-1,1]. The order must be between 1 and 9. void legendre_set_x1_01 ( int order, double xtab[], double weight[] )

Sets a Gauss\(hyLegendre rule for X * F(X) on [0,1]. The order must be between 1 and 8. void legendre_set_x2 ( int order, double xtab[], double weight[] )

Sets Gauss\(hyLegendre rules for ( 1 + X )^2*F(X) on [-1,1]. The order must be between 1 and 9. void legendre_set_x2_01 ( int order, double xtab[], double weight[] )

Sets a Gauss\(hyLegendre rule for X*X * F(X) on [0,1]. The order must be between 1 and 8. void lobatto_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Lobatto quadrature. The order must be between 2 and 20. void moulton_set ( int order, double xtab[], double weight[] )

Sets weights for Adams\(hyMoulton quadrature. The order must be between 1 and 10 or 12, 14, 16, 18 or 20. void ncc_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for closed Newton\(hyCotes quadrature. The order must be between 1 and 21. void nco_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for open Newton\(hyCotes quadrature. The order must be between 1 and 7, or 9. void ncoh_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Newton\(hyCotes "open half" rules. The order must be between 1 and 17. void patterson_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Gauss\(hyPatterson quadrature. The order must be 1, 3, 7, 15, 31, 63, 127 or 255. void radau_set ( int order, double xtab[], double weight[] )

Sets abscissas and weights for Radau quadrature. The order must be between 1 and 15.

quadrule (3)

SYNOPSIS

DESCRIPTION

AUTHOR

RELATED TO quadrule…