Integer type:  int32  int64  nag_int  show int32  show int32  show int64  show int64  show nag_int  show nag_int

Chapter Contents
Chapter Introduction
NAG Toolbox

# NAG Toolbox: nag_specfun_bessel_y0_real_vector (s17aq)

## Purpose

nag_specfun_bessel_y0_real_vector (s17aq) returns an array of values of the Bessel function Y0(x)${Y}_{0}\left(x\right)$.

## Syntax

[f, ivalid, ifail] = s17aq(x, 'n', n)
[f, ivalid, ifail] = nag_specfun_bessel_y0_real_vector(x, 'n', n)

## Description

nag_specfun_bessel_y0_real_vector (s17aq) evaluates an approximation to the Bessel function of the second kind Y0(xi)${Y}_{0}\left({x}_{i}\right)$ for an array of arguments xi${x}_{\mathit{i}}$, for i = 1,2,,n$\mathit{i}=1,2,\dots ,n$.
Note:  Y0(x)${Y}_{0}\left(x\right)$ is undefined for x0$x\le 0$ and the function will fail for such arguments.
The function is based on four Chebyshev expansions:
For 0 < x8$0,
 Y0(x) = 2/πlnx ∑′ arTr(t) + ∑′ brTr(t),   with ​t = 2(x/8)2 − 1. r = 0 r = 0
$Y0 (x) = 2π ln⁡x ∑′r=0 ar Tr (t) + ∑′r=0 br Tr (t) , with ​ t = 2 (x8) 2 - 1 .$
For x > 8$x>8$,
 Y0 (x) = sqrt(2/(πx)) {P0(x)sin(x − π/4) + Q0(x)cos(x − π/4)} $Y0 (x) = 2πx { P0 (x) sin(x-π4) + Q0 (x) cos(x-π4) }$
where P0(x) = r = 0 crTr(t)${P}_{0}\left(x\right)=\underset{r=0}{{\sum }^{\prime }}\phantom{\rule{0.25em}{0ex}}{c}_{r}{T}_{r}\left(t\right)$,
and Q0(x) = 8/xr = 0 drTr(t),with ​ t = 2 (8/x)21.${Q}_{0}\left(x\right)=\frac{8}{x}\underset{r=0}{{\sum }^{\prime }}\phantom{\rule{0.25em}{0ex}}{d}_{r}{T}_{r}\left(t\right),\text{with ​}t=2{\left(\frac{8}{x}\right)}^{2}-1\text{.}$
For x$x$ near zero, Y0(x)2/π (ln(x/2) + γ) ${Y}_{0}\left(x\right)\simeq \frac{2}{\pi }\left(\mathrm{ln}\left(\frac{x}{2}\right)+\gamma \right)$, where γ$\gamma$ denotes Euler's constant. This approximation is used when x$x$ is sufficiently small for the result to be correct to machine precision.
For very large x$x$, it becomes impossible to provide results with any reasonable accuracy (see Section [Accuracy]), hence the function fails. Such arguments contain insufficient information to determine the phase of oscillation of Y0(x)${Y}_{0}\left(x\right)$; only the amplitude, sqrt(2/(πn))$\sqrt{\frac{2}{\pi n}}$, can be determined and this is returned on soft failure. The range for which this occurs is roughly related to machine precision; the function will fail if x1 / machine precision.

## References

Abramowitz M and Stegun I A (1972) Handbook of Mathematical Functions (3rd Edition) Dover Publications
Clenshaw C W (1962) Chebyshev Series for Mathematical Functions Mathematical tables HMSO

## Parameters

### Compulsory Input Parameters

1:     x(n) – double array
n, the dimension of the array, must satisfy the constraint n0${\mathbf{n}}\ge 0$.
The argument xi${x}_{\mathit{i}}$ of the function, for i = 1,2,,n$\mathit{i}=1,2,\dots ,{\mathbf{n}}$.
Constraint: x(i) > 0.0${\mathbf{x}}\left(\mathit{i}\right)>0.0$, for i = 1,2,,n$\mathit{i}=1,2,\dots ,{\mathbf{n}}$.

### Optional Input Parameters

1:     n – int64int32nag_int scalar
Default: The dimension of the array x.
n$n$, the number of points.
Constraint: n0${\mathbf{n}}\ge 0$.

None.

### Output Parameters

1:     f(n) – double array
Y0(xi)${Y}_{0}\left({x}_{i}\right)$, the function values.
2:     ivalid(n) – int64int32nag_int array
ivalid(i)${\mathbf{ivalid}}\left(\mathit{i}\right)$ contains the error code for xi${x}_{\mathit{i}}$, for i = 1,2,,n$\mathit{i}=1,2,\dots ,{\mathbf{n}}$.
ivalid(i) = 0${\mathbf{ivalid}}\left(i\right)=0$
No error.
ivalid(i) = 1${\mathbf{ivalid}}\left(i\right)=1$
 On entry, xi${x}_{i}$ is too large. f(i)${\mathbf{f}}\left(\mathit{i}\right)$ contains the amplitude of the Y0${Y}_{0}$ oscillation, sqrt(2/(πxi))$\sqrt{\frac{2}{\pi {x}_{i}}}$.
ivalid(i) = 2${\mathbf{ivalid}}\left(i\right)=2$
 On entry, xi ≤ 0.0${x}_{i}\le 0.0$, Y0${Y}_{0}$ is undefined. f(i)${\mathbf{f}}\left(\mathit{i}\right)$ contains 0.0$0.0$.
3:     ifail – int64int32nag_int scalar
${\mathrm{ifail}}={\mathbf{0}}$ unless the function detects an error (see [Error Indicators and Warnings]).

## Error Indicators and Warnings

Errors or warnings detected by the function:

Cases prefixed with W are classified as warnings and do not generate an error of type NAG:error_n. See nag_issue_warnings.

W ifail = 1${\mathbf{ifail}}=1$
On entry, at least one value of x was invalid.
ifail = 2${\mathbf{ifail}}=2$
Constraint: n0${\mathbf{n}}\ge 0$.

## Accuracy

Let δ$\delta$ be the relative error in the argument and E$E$ be the absolute error in the result. (Since Y0(x)${Y}_{0}\left(x\right)$ oscillates about zero, absolute error and not relative error is significant, except for very small x$x$.)
If δ$\delta$ is somewhat larger than the machine representation error (e.g., if δ$\delta$ is due to data errors etc.), then E$E$ and δ$\delta$ are approximately related by
 E ≃ |xY1(x)| δ $E ≃ | x Y1 (x) | δ$
(provided E$E$ is also within machine bounds). Figure 1 displays the behaviour of the amplification factor |xY1(x)|$|x{Y}_{1}\left(x\right)|$.
However, if δ$\delta$ is of the same order as the machine representation errors, then rounding errors could make E$E$ slightly larger than the above relation predicts.
For very small x$x$, the errors are essentially independent of δ$\delta$ and the function should provide relative accuracy bounded by the machine precision.
For very large x$x$, the above relation ceases to apply. In this region, Y0(x)sqrt(2/(πx))sin(xπ/4)${Y}_{0}\left(x\right)\simeq \sqrt{\frac{2}{\pi x}}\mathrm{sin}\left(x-\frac{\pi }{4}\right)$. The amplitude sqrt(2/(πx))$\sqrt{\frac{2}{\pi x}}$ can be calculated with reasonable accuracy for all x$x$, but sin(xπ/4)$\mathrm{sin}\left(x-\frac{\pi }{4}\right)$ cannot. If xπ/4 $x-\frac{\pi }{4}$ is written as 2Nπ + θ$2N\pi +\theta$ where N$N$ is an integer and 0θ < 2π$0\le \theta <2\pi$, then sin(xπ/4)$\mathrm{sin}\left(x-\frac{\pi }{4}\right)$ is determined by θ$\theta$ only. If xδ1$x\gtrsim {\delta }^{-1}$, θ$\theta$ cannot be determined with any accuracy at all. Thus if x$x$ is greater than, or of the order of the inverse of machine precision, it is impossible to calculate the phase of Y0(x)${Y}_{0}\left(x\right)$ and the function must fail.
Figure 1

None.

## Example

```function nag_specfun_bessel_y0_real_vector_example
x = [0.5; 1; 3; 6; 8; 10; 1000];
[f, ivalid, ifail] = nag_specfun_bessel_y0_real_vector(x);
fprintf('\n    X           Y\n');
for i=1:numel(x)
fprintf('%12.3e%12.3e%5d\n', x(i), f(i), ivalid(i));
end
```
```

X           Y
5.000e-01  -4.445e-01    0
1.000e+00   8.826e-02    0
3.000e+00   3.769e-01    0
6.000e+00  -2.882e-01    0
8.000e+00   2.235e-01    0
1.000e+01   5.567e-02    0
1.000e+03   4.716e-03    0

```
```function s17aq_example
x = [0.5; 1; 3; 6; 8; 10; 1000];
[f, ivalid, ifail] = s17aq(x);
fprintf('\n    X           Y\n');
for i=1:numel(x)
fprintf('%12.3e%12.3e%5d\n', x(i), f(i), ivalid(i));
end
```
```

X           Y
5.000e-01  -4.445e-01    0
1.000e+00   8.826e-02    0
3.000e+00   3.769e-01    0
6.000e+00  -2.882e-01    0
8.000e+00   2.235e-01    0
1.000e+01   5.567e-02    0
1.000e+03   4.716e-03    0

```