s22ba: FL CL CPP AD

NAG CL Interface
s22bac (hyperg_confl_real)

Keyword Search:

NAG Library Manual, Mark 28.3

Interfaces: FL CL CPP AD

NAG CL Interface Introduction

S (Specfun) Chapter Contents

S (Specfun) Chapter Introduction

s22ba: FL CL CPP AD

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Error Indicators and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

▸▿ 10 Example

10.1 Program Text

10.2 Program Data

10.3 Program Results

Settings help

CL Name Style:
Short (a00aac)
Long (impl_details)
Full (nag_info_impl_details)

1 Purpose

s22bac returns a value for the confluent hypergeometric function

{}_{1}F_{1} (a; b; x)

with real parameters

a

and

b

, and real argument

x

. This function is sometimes also known as Kummer's function

M (a, b, x)

2 Specification

#include <nag.h>

void	s22bac (double a, double b, double x, double m, NagError fail)

The function may be called by the names: s22bac, nag_specfun_hyperg_confl_real or nag_specfun_1f1_real.

3 Description

s22bac returns a value for the confluent hypergeometric function

{}_{1}F_{1} (a; b; x)

with real parameters

a

and

b

, and real argument

x

. This function is unbounded or not uniquely defined for

b

equal to zero or a negative integer.

The associated function s22bbc performs the same operations, but returns

M

in the scaled form

M = m_{f} \times 2^{m_{s}}

to allow calculations to be performed when

M

is not representable as a single working precision number. It also accepts the parameters

a

and

b

as summations of an integer and a decimal fraction, giving higher accuracy when

a

b

are close to an integer. In such cases, s22bbc should be used when high accuracy is required.

The confluent hypergeometric function is defined by the confluent series

{}_{1}F_{1} (a; b; x) = M (a, b, x) = \sum_{s = 0}^{\infty} \frac{{(a)}_{s} x^{s}}{{(b)}_{s} s!} = 1 + \frac{a}{b} x + \frac{a (a + 1)}{b (b + 1) 2!} x^{2} + \dots

where

{(a)}_{s} = 1 (a) (a + 1) (a + 2) \dots (a + s - 1)

is the rising factorial of

a

M (a, b, x)

is a solution to the second order ODE (Kummer's Equation):

x \frac{d^{2} M}{d x^{2}} + (b - x) \frac{d M}{d x} - a M = 0 .

(1)

Given the parameters and argument

(a, b, x)

, this function determines a set of safe values

{(α_{i}, β_{i}, ζ_{i}) ∣ i \leq 2}

and selects an appropriate algorithm to accurately evaluate the functions

M_{i} (α_{i}, β_{i}, ζ_{i})

. The result is then used to construct the solution to the original problem

M (a, b, x)

using, where necessary, recurrence relations and/or continuation.

Additionally, an artificial bound,

arbnd

is placed on the magnitudes of

a

b

and

x

to minimize the occurrence of overflow in internal calculations.

arbnd = 0.0001 \times I_{\max}

, where

I_{\max} = X02BBC

. It should, however, not be assumed that this function will produce an accurate result for all values of

a

b

and

x

satisfying this criterion.

Please consult the NIST Digital Library of Mathematical Functions for a detailed discussion of the confluent hypergeometric function including special cases, transformations, relations and asymptotic approximations.

4 References

NIST Digital Library of Mathematical Functions

Pearson J (2009) Computation of hypergeometric functions MSc Dissertation, Mathematical Institute, University of Oxford

5 Arguments

1: $a$ – double Input: On entry: the parameter $a$ of the function.

Constraint: $| a | \leq arbnd$ .
2: $b$ – double Input: On entry: the parameter $b$ of the function.

Constraint: $| b | \leq arbnd$ .
3: $x$ – double Input: On entry: the argument $x$ of the function.

Constraint: $| x | \leq arbnd$ .
4: $m$ – double * Output: On exit: the solution $M (a, b, x)$ .
Note: if overflow occurs upon completion, as indicated by $fail . code =$ NW_OVERFLOW_WARN, $| M (a, b, x) |$ may be assumed to be too large to be representable. m will be returned as $\pm R_{\max}$ , where $R_{\max}$ is the largest representable real number (see X02ALC). The sign of m should match the sign of $M (a, b, x)$ . If overflow occurs during a subcalculation, as indicated by $fail . code =$ NE_OVERFLOW, the sign may be incorrect, and the true value of $M (a, b, x)$ may or may not be greater than $R_{\max}$ . In either case it is advisable to subsequently use s22bbc.
5: $fail$ – NagError * Input/Output: The NAG error argument (see Section 7 in the Introduction to the NAG Library CL Interface).

6 Error Indicators and Warnings

NE_ALLOC_FAIL: Dynamic memory allocation failed.
See Section 3.1.2 in the Introduction to the NAG Library CL Interface for further information.
NE_BAD_PARAM: On entry, argument $⟨ value ⟩$ had an illegal value.
NE_INTERNAL_ERROR: An internal error has occurred in this function. Check the function call and any array sizes. If the call is correct then please contact NAG for assistance.
See Section 7.5 in the Introduction to the NAG Library CL Interface for further information.
NE_NO_LICENCE: Your licence key may have expired or may not have been installed correctly.
See Section 8 in the Introduction to the NAG Library CL Interface for further information.
NE_OVERFLOW: Overflow occurred in a subcalculation of $M (a, b, x)$ .
The answer may be completely incorrect.
NE_REAL: On entry, $b = ⟨ value ⟩$ .
$M (a, b, x)$ is undefined when $b$ is zero or a negative integer.
NE_REAL_RANGE_CONS: On entry, $a = ⟨ value ⟩$ .
Constraint: $| a | \leq arbnd = ⟨ value ⟩$ .

On entry, $b = ⟨ value ⟩$ .
Constraint: $| b | \leq arbnd = ⟨ value ⟩$ .

On entry, $x = ⟨ value ⟩$ .
Constraint: $| x | \leq arbnd = ⟨ value ⟩$ .
NE_TOTAL_PRECISION_LOSS: All approximations have completed, and the final residual estimate indicates no accuracy can be guaranteed.
Relative residual $= ⟨ value ⟩$ .
NW_OVERFLOW_WARN: On completion, overflow occurred in the evaluation of $M (a, b, x)$ .
NW_SOME_PRECISION_LOSS: All approximations have completed, and the final residual estimate indicates some precision may have been lost.
Relative residual $= ⟨ value ⟩$ .
NW_UNDERFLOW_WARN: Underflow occurred during the evaluation of $M (a, b, x)$ .
The returned value may be inaccurate.

7 Accuracy

In general, if

fail . code =

NE_NOERROR, the value of

M

may be assumed accurate, with the possible loss of one or two decimal places. Assuming the result does not under or overflow, an error estimate

res

is made internally using equation (1). If the magnitude of

res

is sufficiently large, a different fail.code will be returned. Specifically,

$fail . code =$ NE_NOERROR	$res \leq 1000 ε$
$fail . code =$ NW_SOME_PRECISION_LOSS	$1000 ε < res \leq 0.1$
$fail . code =$ NE_TOTAL_PRECISION_LOSS	$res > 0.1$

where

ε

is the machine precision as returned by X02AJC.

A further estimate of the residual can be constructed using equation (1), and the differential identity,

\begin{matrix} \frac{d M (a, b, x)}{d x} & = & \frac{a}{b} M (a + 1, b + 1, x), \\ \frac{d^{2} M (a, b, x)}{d x^{2}} & = & \frac{a (a + 1)}{b (b + 1)} M (a + 2, b + 2, x) . \end{matrix}

This estimate is however, dependent upon the error involved in approximating

M (a + 1, b + 1, x)

and

M (a + 2, b + 2, x)

Furthermore, the accuracy of the solution, and the error estimate, can be dependent upon the accuracy of the decimal fraction of the input parameters

a

and

b

. For example, if

b = b_{i} + b_{r} = 100 + 1.0e−6

, then on a machine with

16

decimal digits of precision, the internal calculation of

b_{r}

will only be accurate to

8

decimal places. This can subsequently pollute the final solution by several decimal places without affecting the residual estimate as greatly. Should you require higher accuracy in such regions, then you should use s22bbc, which requires you to supply the correct decimal fraction.

8 Parallelism and Performance

s22bac is threaded by NAG for parallel execution in multithreaded implementations of the NAG Library.

s22bac makes calls to BLAS and/or LAPACK routines, which may be threaded within the vendor library used by this implementation. Consult the documentation for the vendor library for further information.

Please consult the X06 Chapter Introduction for information on how to control and interrogate the OpenMP environment used within this function. Please also consult the Users' Note for your implementation for any additional implementation-specific information.