double class_matrix ( int kind, int m, double alpha, double beta, double aj[],
double bj[] )
/******************************************************************************/
/*
Purpose:
CLASS_MATRIX computes the Jacobi matrix for a quadrature rule.
Discussion:
This routine computes the diagonal AJ and sub-diagonal BJ
elements of the order M tridiagonal symmetric Jacobi matrix
associated with the polynomials orthogonal with respect to
the weight function specified by KIND.
For weight functions 1-7, M elements are defined in BJ even
though only M-1 are needed. For weight function 8, BJ(M) is
set to zero.
The zero-th moment of the weight function is returned in ZEMU.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
11 January 2010
Author:
Original FORTRAN77 version by Sylvan Elhay, Jaroslav Kautsky.
C version by John Burkardt.
Reference:
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.
Parameters:
Input, int KIND, the rule.
1, Legendre, (a,b) 1.0
2, Chebyshev Type 1, (a,b) ((b-x)*(x-a))^(-0.5)
3, Gegenbauer, (a,b) ((b-x)*(x-a))^alpha
4, Jacobi, (a,b) (b-x)^alpha*(x-a)^beta
5, Generalized Laguerre, (a,inf) (x-a)^alpha*exp(-b*(x-a))
6, Generalized Hermite, (-inf,inf) |x-a|^alpha*exp(-b*(x-a)^2)
7, Exponential, (a,b) |x-(a+b)/2.0|^alpha
8, Rational, (a,inf) (x-a)^alpha*(x+b)^beta
Input, int M, the order of the Jacobi matrix.
Input, double ALPHA, the value of Alpha, if needed.
Input, double BETA, the value of Beta, if needed.
Output, double AJ[M], BJ[M], the diagonal and subdiagonal
of the Jacobi matrix.
Output, double CLASS_MATRIX, the zero-th moment.
*/
{
double a2b2;
double ab;
double aba;
double abi;
double abj;
double abti;
double apone;
int i;
const double pi = 3.14159265358979323846264338327950;
double temp;
double temp2;
double zemu;
temp = r8_epsilon ( );
parchk ( kind, 2 * m - 1, alpha, beta );
temp2 = 0.5;
if ( 500.0 * temp < r8_abs ( pow ( r8_gamma ( temp2 ), 2 ) - pi ) )
{
printf ( "\n" );
printf ( "CLASS_MATRIX - Fatal error!\n" );
printf ( " Gamma function does not match machine parameters.\n" );
exit ( 1 );
}
if ( kind == 1 )
{
ab = 0.0;
zemu = 2.0 / ( ab + 1.0 );
for ( i = 0; i < m; i++ )
{
aj[i] = 0.0;
}
for ( i = 1; i <= m; i++ )
{
abi = i + ab * ( i % 2 );
abj = 2 * i + ab;
bj[i-1] = sqrt ( abi * abi / ( abj * abj - 1.0 ) );
}
}
else if ( kind == 2 )
{
zemu = pi;
for ( i = 0; i < m; i++ )
{
aj[i] = 0.0;
}
bj[0] = sqrt ( 0.5 );
for ( i = 1; i < m; i++ )
{
bj[i] = 0.5;
}
}
else if ( kind == 3 )
{
ab = alpha * 2.0;
zemu = pow ( 2.0, ab + 1.0 ) * pow ( r8_gamma ( alpha + 1.0 ), 2 )
/ r8_gamma ( ab + 2.0 );
for ( i = 0; i < m; i++ )
{
aj[i] = 0.0;
}
bj[0] = sqrt ( 1.0 / ( 2.0 * alpha + 3.0 ) );
for ( i = 2; i <= m; i++ )
{
bj[i-1] = sqrt ( i * ( i + ab ) / ( 4.0 * pow ( i + alpha, 2 ) - 1.0 ) );
}
}
else if ( kind == 4 )
{
ab = alpha + beta;
abi = 2.0 + ab;
zemu = pow ( 2.0, ab + 1.0 ) * r8_gamma ( alpha + 1.0 )
* r8_gamma ( beta + 1.0 ) / r8_gamma ( abi );
aj[0] = ( beta - alpha ) / abi;
bj[0] = sqrt ( 4.0 * ( 1.0 + alpha ) * ( 1.0 + beta )
/ ( ( abi + 1.0 ) * abi * abi ) );
a2b2 = beta * beta - alpha * alpha;
for ( i = 2; i <= m; i++ )
{
abi = 2.0 * i + ab;
aj[i-1] = a2b2 / ( ( abi - 2.0 ) * abi );
abi = abi * abi;
bj[i-1] = sqrt ( 4.0 * i * ( i + alpha ) * ( i + beta ) * ( i + ab )
/ ( ( abi - 1.0 ) * abi ) );
}
}
else if ( kind == 5 )
{
zemu = r8_gamma ( alpha + 1.0 );
for ( i = 1; i <= m; i++ )
{
aj[i-1] = 2.0 * i - 1.0 + alpha;
bj[i-1] = sqrt ( i * ( i + alpha ) );
}
}
else if ( kind == 6 )
{
zemu = r8_gamma ( ( alpha + 1.0 ) / 2.0 );
for ( i = 0; i < m; i++ )
{
aj[i] = 0.0;
}
for ( i = 1; i <= m; i++ )
{
bj[i-1] = sqrt ( ( i + alpha * ( i % 2 ) ) / 2.0 );
}
}
else if ( kind == 7 )
{
ab = alpha;
zemu = 2.0 / ( ab + 1.0 );
for ( i = 0; i < m; i++ )
{
aj[i] = 0.0;
}
for ( i = 1; i <= m; i++ )
{
abi = i + ab * ( i % 2 );
abj = 2 * i + ab;
bj[i-1] = sqrt ( abi * abi / ( abj * abj - 1.0 ) );
}
}
else if ( kind == 8 )
{
ab = alpha + beta;
zemu = r8_gamma ( alpha + 1.0 ) * r8_gamma ( - ( ab + 1.0 ) )
/ r8_gamma ( - beta );
apone = alpha + 1.0;
aba = ab * apone;
aj[0] = - apone / ( ab + 2.0 );
bj[0] = - aj[0] * ( beta + 1.0 ) / ( ab + 2.0 ) / ( ab + 3.0 );
for ( i = 2; i <= m; i++ )
{
abti = ab + 2.0 * i;
aj[i-1] = aba + 2.0 * ( ab + i ) * ( i - 1 );
aj[i-1] = - aj[i-1] / abti / ( abti - 2.0 );
}
for ( i = 2; i <= m - 1; i++ )
{
abti = ab + 2.0 * i;
bj[i-1] = i * ( alpha + i ) / ( abti - 1.0 ) * ( beta + i )
/ ( abti * abti ) * ( ab + i ) / ( abti + 1.0 );
}
bj[m-1] = 0.0;
for ( i = 0; i < m; i++ )
{
bj[i] = sqrt ( bj[i] );
}
}
else
{
printf ( "\n" );
printf ( "CLASS_MATRIX - Fatal error!\n" );
printf ( " Illegal value of KIND = %d.\n", kind );
exit ( 1 );
}
return zemu;
}
double circle01_monomial_integral ( int e[2] )
/******************************************************************************/
/*
Purpose:
CIRCLE01_MONOMIAL_INTEGRAL: integrals on the circumference of the unit circle in 2D.
Discussion:
The integration region is
X^2 + Y^2 = 1.
The monomial is F(X,Y) = X^E(1) * Y^E(2).
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
11 January 2014
Author:
John Burkardt
Reference:
Philip Davis, Philip Rabinowitz,
Methods of Numerical Integration,
Second Edition,
Academic Press, 1984, page 263.
Parameters:
Input, int E[2], the exponents of X and Y in the
monomial. Each exponent must be nonnegative.
Output, double CIRCLE01_MONOMIAL_INTEGRAL, the integral.
*/
{
int i;
double integral;
const double r8_pi = 3.141592653589793;
if ( e[0] < 0 || e[1] < 0 )
{
fprintf ( stderr, "\n" );
fprintf ( stderr, "CIRCLE01_MONOMIAL_INTEGRAL - Fatal error!\n" );
fprintf ( stderr, " All exponents must be nonnegative.\n" );
fprintf ( stderr, " E[0] = %d\n", e[0] );
fprintf ( stderr, " E[1] = %d\n", e[1] );
exit ( 1 );
}
if ( ( e[0] % 2 ) == 1 || ( e[1] % 2 ) == 1 )
{
integral = 0.0;
}
else
{
integral = 2.0;
for ( i = 0; i < 2; i++ )
{
integral = integral * r8_gamma ( 0.5 * ( double ) ( e[i] + 1 ) );
}
integral = integral
/ r8_gamma ( 0.5 * ( double ) ( e[0] + e[1] + 2 ) );
}
return integral;
}
double hypersphere01_monomial_integral ( int m, int e[] )
/******************************************************************************/
/*
Purpose:
HYPERSPHERE01_MONOMIAL_INTEGRAL: monomial integrals on the unit hypersphere.
Discussion:
The integration region is
sum ( 1 <= I <= M ) X(I)^2 = 1.
The monomial is F(X) = product ( 1 <= I <= M ) X(I)^E(I).
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
04 January 2014
Author:
John Burkardt
Reference:
Philip Davis, Philip Rabinowitz,
Methods of Numerical Integration,
Second Edition,
Academic Press, 1984, page 263.
Parameters:
Input, int M, the spatial dimension.
Input, int E[M], the exponents. Each exponent must be nonnegative.
Output, double HYPERSPHERE01_MONOMIAL_INTEGRAL, the integral.
*/
{
double arg;
int i;
double integral;
const double r8_pi = 3.141592653589793;
for ( i = 0; i < m; i++ )
{
if ( e[i] < 0 )
{
fprintf ( stderr, "\n" );
fprintf ( stderr, "HYPERSPHERE01_MONOMIAL_INTEGRAL - Fatal error!\n" );
fprintf ( stderr, " All exponents must be nonnegative.\n" );
fprintf ( stderr, " E[%d] = %d\n", i, e[i] );
exit ( 1 );
}
}
for ( i = 0; i < m; i++ )
{
if ( ( e[i] % 2 ) == 1 )
{
integral = 0.0;
return integral;
}
}
integral = 2.0;
for ( i = 0; i < m; i++ )
{
arg = 0.5 * ( double ) ( e[i] + 1 );
integral = integral * r8_gamma ( arg );
}
arg = 0.5 * ( double ) ( i4vec_sum ( m, e ) + m );
integral = integral / r8_gamma ( arg );
return integral;
}
double disk01_monomial_integral ( int e[2] )
/******************************************************************************/
/*
Purpose:
DISK01_MONOMIAL_INTEGRAL returns monomial integrals in the unit disk in 2D.
Discussion:
The integration region is
X^2 + Y^2 <= 1.
The monomial is F(X,Y) = X^E(1) * Y^E(2).
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
03 January 2014
Author:
John Burkardt
Reference:
Philip Davis, Philip Rabinowitz,
Methods of Numerical Integration,
Second Edition,
Academic Press, 1984, page 263.
Parameters:
Input, int E[2], the exponents of X and Y in the
monomial. Each exponent must be nonnegative.
Output, double DISK01_MONOMIAL_INTEGRAL, the integral.
*/
{
double arg;
int i;
double integral;
const double r = 1.0;
const double r8_pi = 3.141592653589793;
double s;
if ( e[0] < 0 || e[1] < 0 )
{
fprintf ( stderr, "\n" );
fprintf ( stderr, "DISK01_MONOMIAL_INTEGRAL - Fatal error!\n" );
fprintf ( stderr, " All exponents must be nonnegative.\n" );
fprintf ( stderr, " E[0] = %d\n", e[0] );
fprintf ( stderr, " E[1] = %d\n", e[1] );
exit ( 1 );
}
if ( ( e[0] % 2 ) == 1 || ( e[1] % 2 ) == 1 )
{
integral = 0.0;
}
else
{
integral = 2.0;
for ( i = 0; i < 2; i++ )
{
arg = 0.5 * ( double ) ( e[i] + 1 );
integral = integral * r8_gamma ( arg );
}
arg = 0.5 * ( double ) ( e[0] + e[1] + 2 );
integral = integral / r8_gamma ( arg );
}
/*
Adjust the surface integral to get the volume integral.
*/
s = e[0] + e[1] + 2;
integral = integral * pow ( r, s ) / ( double ) ( s );
return integral;
}
