SANDIA_RULES\
Quadrature Rules of Gaussian Type {#sandia_rules-quadrature-rules-of-gaussian-type align=”center”}
=================================
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-x^2^)
Gauss-Chebyshev 2 [-1,+1] sqrt(1-x^2^)
Gauss-Gegenbauer [-1,+1] (1-x^2^)^alpha^
Gauss-Jacobi [-1,+1] (1-x)^alpha^ (1+x)^beta^
Gauss-Laguerre [0,+oo) e^-x^
Generalized Gauss-Laguerre [0,+oo) x^alpha^ e^-x^
Gauss-Hermite (-oo,+oo) e^-x*x^
Generalized Gauss-Hermite (-oo,+oo) |x|^alpha^ e^-x*x^
Hermite Genz-Keister (-oo,+oo) e^-x*x^
Newton-Cotes-Closed [-1,+1] 1
Newton-Cotes-Open [-1,+1] 1
Newton-Cotes-Open-Half [-1,+1] 1
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;
There is yet a third possible interface, in which no ALPHA or BETA
parameters appear in the function call; this interface is primarily
intended for a particular software environment. The interfaces are made
available in a separate library called SANDIA_RULES2.
Licensing: {#licensing align=”center”}
The computer code and data files described and made available on this
web page are distributed under the GNU LGPL
license.
Languages: {#languages align=”center”}
SANDIA_RULES is available in a C
version and a C++
version and a FORTRAN90
version and a MATLAB
version.
CHEBYSHEV1_RULE,
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.
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, a C++
program which can compute and print a Gauss-Legendre quadrature rule.
QUADRATURE_RULES,
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.
SANDIA_RULES2, a C++
library which contains a very small selection of functions which serve
as an interface between SANDIA_SGMG or SANDIA_SGMGA and SANDIA_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.
Reference: {#reference align=”center”}
- Milton Abramowitz, Irene Stegun,\
Handbook of Mathematical Functions,\
National Bureau of Standards, 1964,\
ISBN: 0-486-61272-4,\
LC: QA47.A34.
- 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.
- Philip Davis, Philip Rabinowitz,\
Methods of Numerical Integration,\
Second Edition,\
Dover, 2007,\
ISBN: 0486453391,\
LC: QA299.3.D28.
- Sylvan Elhay, Jaroslav Kautsky,\
Algorithm 655: IQPACK, FORTRAN Subroutines for the Weights of
Interpolatory Quadrature,\
ACM Transactions on Mathematical Software,\
Volume 13, Number 4, December 1987, pages 399-415.
- Alan Genz, Bradley Keister,\
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.
- John Hart, Ward Cheney, Charles Lawson, Hans Maehly, Charles
Mesztenyi, John Rice, Henry Thatcher, Christoph Witzgall,\
Computer Approximations,\
Wiley, 1968,\
LC: QA297.C64.
- Knut Petras,\
Smolyak Cubature of Given Polynomial Degree with Few Nodes for
Increasing Dimension,\
Numerische Mathematik,\
Volume 93, Number 4, February 2003, pages 729-753.
- Arthur Stroud, Don Secrest,\
Gaussian Quadrature Formulas,\
Prentice Hall, 1966,\
LC: QA299.4G3S7.
- Shanjie Zhang, Jianming Jin,\
Computation of Special Functions,\
Wiley, 1996,\
ISBN: 0-471-11963-6,\
LC: QA351.C45
Source Code: {#source-code align=”center”}
Examples and Tests: {#examples-and-tests align=”center”}
List of Routines: {#list-of-routines align=”center”}
- BINARY_VECTOR_NEXT generates the next binary vector.
- CCN_COMPUTE computes a nested Clenshaw Curtis quadrature rule.
- CCN_COMPUTE_NP computes a nested Clenshaw Curtis quadrature
rule.
- CCN_COMPUTE_POINTS: compute nested Clenshaw Curtis points.
- CCN_COMPUTE_POINTS_NP: nested Clenshaw Curtis quadrature
points.
- CCN_COMPUTE_WEIGHTS: weights for nested Clenshaw Curtis rule.
- CCN_COMPUTE_WEIGHTS_NP: nested Clenshaw Curtis quadrature
weights.
- 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 elapsed CPU time.
- DIF_DERIV computes the derivative of a polynomial in divided
difference form.
- DIF_SHIFT_X replaces one abscissa of a divided difference
table with a new one.
- DIF_SHIFT_ZERO shifts a divided difference table so that all
abscissas are zero.
- DIF_TO_R8POLY converts a divided difference table to a
standard polynomial.
- 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 Gauss-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_DR_COMPUTE computes a Generalized Hermite
quadrature rule.
- GEN_HERMITE_INTEGRAL evaluates a monomial Generalized Hermite
integral.
- GEN_LAGUERRE_COMPUTE: generalized Gauss-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_SS_COMPUTE computes a Generalized Laguerre
quadrature rule.
- GEN_LAGUERRE_SS_RECUR evaluates a Generalized Laguerre
polynomial.
- GEN_LAGUERRE_SS_ROOT improves a root of a Generalized
Laguerre polynomial.
- HC_COMPUTE_WEIGHTS_FROM_POINTS: Hermite-Cubic weights,
user-supplied points.
- HCC_COMPUTE computes a Hermite-Cubic-Chebyshev-Spacing
quadrature rule.
- HCC_COMPUTE_NP computes a Hermite-Cubic-Chebyshev-Spacing
quadrature rule.
- HCC_COMPUTE_POINTS computes Hermite-Cubic-Chebyshev-Spacing
quadrature points.
- HCC_COMPUTE_POINTS_NP: Hermite-Cubic-Chebyshev-Spacing
quadrature points.
- HCC_COMPUTE_WEIGHTS: Hermite-Cubic-Chebyshev-Spacing
quadrature weights.
- HCC_COMPUTE_WEIGHTS_NP: Hermite-Cubic-Chebyshev-Spacing
quadrature weights.
- HCE_COMPUTE computes a Hermite-Cubic-Equal-Spacing quadrature
rule.
- HCE_COMPUTE_NP computes a Hermite-Cubic-Equal-Spacing
quadrature rule.
- HCE_COMPUTE_POINTS computes Hermite-Cubic-Equal-Spacing
quadrature points.
- HCE_COMPUTE_POINTS_NP: Hermite-Cubic-Equal-Spacing quadrature
points.
- HCE_COMPUTE_WEIGHTS: Hermite-Cubic-Equal-Spacing quadrature
weights.
- HCE_COMPUTE_WEIGHTS_NP: Hermite-Cubic-Equal-Spacing
quadrature weights.
- HERMITE_COMPUTE computes a Gauss-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_GK18_LOOKUP_POINTS: abscissas of a Hermite
Genz-Keister 18 rule.
- HERMITE_GK22_LOOKUP_POINTS looks up Hermite Genz-Keister 22
points.
- HERMITE_GK24_LOOKUP_POINTS looks up Hermite Genz-Keister 24
points.
- HERMITE_INTEGRAL evaluates a monomial Hermite integral.
- HERMITE_INTERPOLANT sets up a divided difference table from
Hermite data.
- HERMITE_INTERPOLANT_RULE: quadrature rule for a Hermite
interpolant.
- HERMITE_INTERPOLANT_VALUE evaluates the Hermite interpolant
polynomial.
- HERMITE_LOOKUP looks up abscissas and weights for Gauss-Hermite
quadrature.
- HERMITE_LOOKUP_POINTS looks up abscissas for Hermite
quadrature.
- HERMITE_LOOKUP_WEIGHTS looks up weights for Hermite
quadrature.
- HERMITE_SS_COMPUTE computes a Hermite quadrature rule.
- HERMITE_SS_RECUR finds the value and derivative of a Hermite
polynomial.
- HERMITE_SS_ROOT improves an approximate root of a Hermite
polynomial.
- I4_CHOOSE computes the binomial coefficient C(N,K).
- I4_LOG_2 returns the integer part of the logarithm base 2 of
an I4.
- I4_MAX returns the maximum of two I4’s.
- I4_MIN returns the minimum of two I4’s.
- I4_POWER returns the value of I\^J.
- I4MAT_COPY copies one I4MAT to another.
- I4MAT_COPY_NEW copies an I4MAT to a “new” I4MAT.
- I4MAT_TRANSPOSE_PRINT prints an I4MAT, transposed.
- I4MAT_TRANSPOSE_PRINT_SOME prints some of an I4MAT,
transposed.
- I4MAT_WRITE writes an I4MAT file.
- I4VEC_ADD_NEW computes C = A + B for I4VEC’s.
- I4VEC_ANY_LT: ( any ( A < B ) ) for I4VEC’s.
- I4VEC_COPY copies an I4VEC.
- I4VEC_COPY_NEW copies an I4VEC to a “new” I4VEC.
- I4VEC_MIN_MV determines U(1:N) /\ V for vectors U and a
single vector V.
- I4VEC_PRINT prints an I4VEC.
- I4VEC_PRODUCT multiplies the entries of an I4VEC.
- I4VEC_SUM sums the entries of an I4VEC.
- I4VEC_ZERO zeroes an I4VEC.
- I4VEC_ZERO_NEW creates and zeroes an I4VEC.
- IMTQLX diagonalizes a symmetric tridiagonal matrix.
- JACOBI_COMPUTE: Elhay-Kautsky method for Gauss-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_SS_COMPUTE computes a Jacobi quadrature rule.
- JACOBI_SS_RECUR evaluates a Jacobi polynomial.
- JACOBI_SS_ROOT improves an approximate root of a Jacobi
polynomial.
- LAGUERRE_COMPUTE: Laguerre quadrature rule by the Elhay-Kautsky
method.
- 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_LOOKUP looks up abscissas and weights for Laguerre
quadrature.
- LAGUERRE_LOOKUP_POINTS looks up abscissas for Laguerre
quadrature.
- LAGUERRE_LOOKUP_WEIGHTS looks up weights for Laguerre
quadrature.
- LAGUERRE_SS_COMPUTE computes a Laguerre quadrature rule.
- LAGUERRE_SS_RECUR evaluates a Laguerre polynomial.
- LAGUERRE_SS_ROOT improves a root of a Laguerre polynomial.
- LEGENDRE_COMPUTE: Legendre quadrature rule by the Elhay-Kautsky
method.
- 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_DR_COMPUTE computes a Legendre quadrature rule.
- LEGENDRE_INTEGRAL evaluates a monomial Legendre integral.
- LEGENDRE_LOOKUP looks up abscissas and weights for
Gauss-Legendre quadrature.
- LEGENDRE_LOOKUP_POINTS looks up abscissas for Gauss-Legendre
quadrature.
- LEGENDRE_LOOKUP_WEIGHTS looks up weights for Gauss-Legendre
quadrature.
- LEGENDRE_ZEROS returns the zeros of the Legendre polynomial of
degree N.
- 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.
- LEVEL_TO_ORDER_EXP_CC is used for Clenshaw-Curtis type
rules.
- LEVEL_TO_ORDER_EXP_F2 is used for Fejer 2 type rules.
- LEVEL_TO_ORDER_EXP_GAUSS is used for Gauss type rules.
- LEVEL_TO_ORDER_EXP_GP is used for Gauss-Patterson type
rules.
- LEVEL_TO_ORDER_EXP_HGK is used for Hermite Genz-Keister type
rules.
- LEVEL_TO_ORDER_LINEAR_NN is used for non-nested Gauss type
rules.
- LEVEL_TO_ORDER_LINEAR_WN is used for weakly-nested Gauss
type rules.
- NC_COMPUTE computes a Newton-Cotes quadrature rule.
- NC_COMPUTE_NEW 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 for a Newton-Cotes Open quadrature
rule.
- NCO_COMPUTE_WEIGHTS: weights for a Newton-Cotes Open
quadrature rule.
- NCOH_COMPUTE_POINTS computes points for a Newton-Cotes “open
half” quadrature rule.
- NCOH_COMPUTE_WEIGHTS computes weights for a Newton-Cotes “open
half” 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_COUNT_INC1 counts the tolerably
unique points.
- POINT_RADIAL_TOL_UNIQUE_COUNT_INC2 counts the tolerably
unique points.
- POINT_RADIAL_TOL_UNIQUE_INDEX indexes the tolerably unique
points.
- POINT_RADIAL_TOL_UNIQUE_INDEX_INC1 indexes the tolerably
unique points.
- POINT_RADIAL_TOL_UNIQUE_INDEX_INC2 indexes unique temporary
points.
- POINT_RADIAL_TOL_UNIQUE_INDEX_INC3 merges index data.
- 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 rounds an R8 “up” (towards +oo) to the next integer.
- R8_CHOOSE computes the binomial coefficient C(N,K) as an R8.
- R8_EPSILON returns the R8 roundoff 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).
- R8_SIGN returns the sign of an R8.
- 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 of 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 first 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.
- R8POLY_ANT_VAL evaluates the antiderivative of an R8POLY in
standard form.
- R8VEC_CHEBYSHEV_NEW creates a vector of Chebyshev spaced
values.
- R8VEC_COMPARE compares two R8VEC’s.
- R8VEC_COPY copies an R8VEC.
- R8VEC_COPY_NEW copies an R8VEC to a “new” R8VEC.
- R8VEC_DIFF_NORM_LI returns the L-oo norm of the difference of
R8VEC’s.
- R8VEC_DIRECT_PRODUCT2 creates a direct product of R8VEC’s.
- R8VEC_DOT_PRODUCT computes the dot product of a pair of
R8VEC’s.
- R8VEC_I4VEC_DOT_PRODUCT computes the dot product of an R8VEC
and an I4VEC.
- R8VEC_INDEX_SORTED_RANGE: search index sorted vector for
elements in a range.
- R8VEC_INDEXED_HEAP_D creates a descending heap from an
indexed R8VEC.
- R8VEC_INDEXED_HEAP_D_EXTRACT: extract from heap descending
indexed R8VEC.
- R8VEC_INDEXED_HEAP_D_INSERT: insert value into heap
descending indexed R8VEC.
- R8VEC_INDEXED_HEAP_D_MAX: maximum value in heap descending
indexed R8VEC.
- R8VEC_LEGENDRE_NEW creates a vector of Chebyshev spaced
values.
- R8VEC_LINSPACE_NEW creates a vector of linearly spaced values.
- 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_SCALE multiples an R8VEC by a scale factor.
- R8VEC_SORT_HEAP_INDEX_A does an indexed heap ascending sort
of an R8VEC
- R8VEC_SORT_HEAP_INDEX_A_NEW does an indexed heap ascending
sort of an R8VEC
- R8VEC_STUTTER makes a “stuttering” copy of an R8VEC.
- R8VEC_SUM returns the sum of an R8VEC.
- R8VEC_UNIFORM_01 returns a unit pseudorandom R8VEC.
- R8VEC_UNIFORM_01_NEW returns a new unit pseudorandom R8VEC.
- R8VEC_ZERO zeroes an 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 31 December 2011.