# NAG FL Interfaced01ubf (dim1_​inf_​exp_​wt)

## ▸▿ Contents

Settings help

FL Name Style:

FL Specification Language:

## 1Purpose

d01ubf returns the Gaussian quadrature approximation for the specific problem . The degrees of precision catered for are: $1$, $3$, $5$, $7$, $9$, $19$, $29$, $39$ and $49$, corresponding to values of $n=1$, $2$, $3$, $4$, $5$, $10$, $15$, $20$ and $25$, where $n$ is the number of weights.

## 2Specification

Fortran Interface
 Subroutine d01ubf ( f, n, ans,
 Integer, Intent (In) :: n Integer, Intent (Inout) :: iuser(*), ifail Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Real (Kind=nag_wp), Intent (Out) :: ans External :: f
#include <nag.h>
 void d01ubf_ (void (NAG_CALL *f)(const double x[], double fv[], const Integer *n, Integer iuser[], double ruser[], Integer *istop),const Integer *n, double *ans, Integer iuser[], double ruser[], Integer *ifail)
The routine may be called by the names d01ubf or nagf_quad_dim1_inf_exp_wt.

## 3Description

d01ubf uses the weights ${w}_{i}$ and the abscissae ${x}_{i}$ such that $\underset{0}{\overset{\infty }{\int }}\mathrm{exp}\left({-x}^{2}\right)f\left(x\right)$ is approximated by $\sum _{\mathit{i}=1}^{n}{w}_{i}f\left({x}_{i}\right)$ to maximum precision i.e., it is exact when $f\left(x\right)$ is a polynomial of degree $2n-1$.

## 4References

Golub G H and Welsch J H (1969) Calculation of Gauss quadrature rules Math. Comput. 23 221–230

## 5Arguments

1: $\mathbf{f}$Subroutine, supplied by the user. External Procedure
f must return the integrand function values $f\left({x}_{i}\right)$ for the given ${x}_{\mathit{i}}$, for $\mathit{i}=1,2,\dots ,{\mathbf{n}}$.
The specification of f is:
Fortran Interface
 Subroutine f ( x, fv, n,
 Integer, Intent (In) :: n Integer, Intent (Inout) :: iuser(*), istop Real (Kind=nag_wp), Intent (In) :: x(n) Real (Kind=nag_wp), Intent (Inout) :: ruser(*) Real (Kind=nag_wp), Intent (Out) :: fv(n)
 void f (const double x[], double fv[], const Integer *n, Integer iuser[], double ruser[], Integer *istop)
1: $\mathbf{x}\left({\mathbf{n}}\right)$Real (Kind=nag_wp) array Input
On entry: the points at which the integrand function $f$ must be evaluated.
2: $\mathbf{fv}\left({\mathbf{n}}\right)$Real (Kind=nag_wp) array Output
On exit: ${\mathbf{fv}}\left(\mathit{i}\right)$ must contain the value of the integrand $f\left({x}_{i}\right)$ evaluated at the point ${\mathbf{x}}\left(\mathit{i}\right)$, for $\mathit{i}=1,2,\dots ,{\mathbf{n}}$.
3: $\mathbf{n}$Integer Input
On entry: n specifies the number of weights and abscissae to be used.
4: $\mathbf{iuser}\left(*\right)$Integer array User Workspace
5: $\mathbf{ruser}\left(*\right)$Real (Kind=nag_wp) array User Workspace
f is called with the arguments iuser and ruser as supplied to d01ubf. You should use the arrays iuser and ruser to supply information to f.
6: $\mathbf{istop}$Integer Input/Output
On entry: ${\mathbf{istop}}=0$.
On exit: you may set istop to a negative number if at any time it is impossible to evaluate the function $f\left(x\right)$. In this case d01ubf halts with ifail set to the value of istop and the value returned in ans will be that of a non-signalling NaN.
f must either be a module subprogram USEd by, or declared as EXTERNAL in, the (sub)program from which d01ubf is called. Arguments denoted as Input must not be changed by this procedure.
2: $\mathbf{n}$Integer Input
On entry: n specifies the number of weights and abscissae to be used.
Constraint: ${\mathbf{n}}=1$, $2$, $3$, $4$, $5$, $10$, $15$, $20$ or $25$.
3: $\mathbf{ans}$Real (Kind=nag_wp) Output
On exit: if ${\mathbf{ifail}}={\mathbf{0}}$, ans contains an approximation to the integral. Otherwise, ans will be a non-signalling NaN.
4: $\mathbf{iuser}\left(*\right)$Integer array User Workspace
5: $\mathbf{ruser}\left(*\right)$Real (Kind=nag_wp) array User Workspace
iuser and ruser are not used by d01ubf, but are passed directly to f and may be used to pass information to this routine.
6: $\mathbf{ifail}$Integer Input/Output
On entry: ifail must be set to $0$, $-1$ or $1$ to set behaviour on detection of an error; these values have no effect when no error is detected.
A value of $0$ causes the printing of an error message and program execution will be halted; otherwise program execution continues. A value of $-1$ means that an error message is printed while a value of $1$ means that it is not.
If halting is not appropriate, the value $-1$ or $1$ is recommended. If message printing is undesirable, then the value $1$ is recommended. Otherwise, the value $0$ is recommended. When the value $-\mathbf{1}$ or $\mathbf{1}$ is used it is essential to test the value of ifail on exit.
On exit: ${\mathbf{ifail}}={\mathbf{0}}$ unless the routine detects an error or a warning has been flagged (see Section 6).

## 6Error Indicators and Warnings

If on entry ${\mathbf{ifail}}=0$ or $-1$, explanatory error messages are output on the current error message unit (as defined by x04aaf).
Errors or warnings detected by the routine:
${\mathbf{ifail}}<0$
The user has halted the calculation.
${\mathbf{ifail}}=1$
On entry, ${\mathbf{n}}=⟨\mathit{\text{value}}⟩$.
Constraint: $1\le {\mathbf{n}}\le 25$.
${\mathbf{ifail}}=2$
On entry, ${\mathbf{n}}=⟨\mathit{\text{value}}⟩$.
n is not one of the allowed values.
${\mathbf{ifail}}=-99$
See Section 7 in the Introduction to the NAG Library FL Interface for further information.
${\mathbf{ifail}}=-399$
Your licence key may have expired or may not have been installed correctly.
See Section 8 in the Introduction to the NAG Library FL Interface for further information.
${\mathbf{ifail}}=-999$
Dynamic memory allocation failed.
See Section 9 in the Introduction to the NAG Library FL Interface for further information.

## 7Accuracy

The weights and abscissae have been calculated using quadruple precision arithmetic.

## 8Parallelism and Performance

d01ubf is not threaded in any implementation.

None.

## 10Example

This example computes an approximation to .

### 10.1Program Text

Program Text (d01ubfe.f90)

None.

### 10.3Program Results

Program Results (d01ubfe.r)