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_j1_real (s17af)

## Purpose

nag_specfun_bessel_j1_real (s17af) returns the value of the Bessel function ${J}_{1}\left(x\right)$, via the function name.

## Syntax

[result, ifail] = s17af(x)
[result, ifail] = nag_specfun_bessel_j1_real(x)

## Description

nag_specfun_bessel_j1_real (s17af) evaluates an approximation to the Bessel function of the first kind ${J}_{1}\left(x\right)$.
Note:  ${J}_{1}\left(-x\right)=-{J}_{1}\left(x\right)$, so the approximation need only consider $x\ge 0$.
The function is based on three Chebyshev expansions:
For $0,
 $J1x=x8∑′r=0arTrt, with ​t=2 x8 2-1.$
For $x>8$,
 $J1x=2πx P1xcosx-3π4-Q1xsinx-3π4$
where ${P}_{1}\left(x\right)=\underset{r=0}{{\sum }^{\prime }}\phantom{\rule{0.25em}{0ex}}{b}_{r}{T}_{r}\left(t\right)$,
and ${Q}_{1}\left(x\right)=\frac{8}{x}\underset{r=0}{{\sum }^{\prime }}\phantom{\rule{0.25em}{0ex}}{c}_{r}{T}_{r}\left(t\right)$,
with $t=2{\left(\frac{8}{x}\right)}^{2}-1$.
For $x$ near zero, ${J}_{1}\left(x\right)\simeq \frac{x}{2}$. This approximation is used when $x$ is sufficiently small for the result to be correct to machine precision.
For very large $x$, it becomes impossible to provide results with any reasonable accuracy (see Accuracy), hence the function fails. Such arguments contain insufficient information to determine the phase of oscillation of ${J}_{1}\left(x\right)$; only the amplitude, $\sqrt{\frac{2}{\pi \left|x\right|}}$, 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 .

## 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:     $\mathrm{x}$ – double scalar
The argument $x$ of the function.

None.

### Output Parameters

1:     $\mathrm{result}$ – double scalar
The result of the function.
2:     $\mathrm{ifail}$int64int32nag_int scalar
${\mathbf{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:
${\mathbf{ifail}}=1$
x is too large. On soft failure the function returns the amplitude of the ${J}_{1}$ oscillation, $\sqrt{\frac{2}{\pi \left|x\right|}}$.
${\mathbf{ifail}}=-99$
${\mathbf{ifail}}=-399$
Your licence key may have expired or may not have been installed correctly.
${\mathbf{ifail}}=-999$
Dynamic memory allocation failed.

## Accuracy

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

None.

## Example

This example reads values of the argument $x$ from a file, evaluates the function at each value of $x$ and prints the results.
```function s17af_example

fprintf('s17af example results\n\n');

x = [0     0.5     1    3    6   8    10   -1  1000];
n = size(x,2);
result = x;

for j=1:n
[result(j), ifail] = s17af(x(j));
end

disp('      x         J_1(x)');
fprintf('%12.3e%12.3e\n',[x; result]);

s17af_plot;

function s17af_plot
x = [-30:0.25:30];
for j = 1:numel(x)
[J1(j), ifail] = s17af(x(j));
end

fig1 = figure;
plot(x,J1,'-r');
xlabel('x');
ylabel('J_1(x)');
title('Bessel Function J_1(x)');
axis([-30 30 -0.6 0.6]);

```
```s17af example results

x         J_1(x)
0.000e+00   0.000e+00
5.000e-01   2.423e-01
1.000e+00   4.401e-01
3.000e+00   3.391e-01
6.000e+00  -2.767e-01
8.000e+00   2.346e-01
1.000e+01   4.347e-02
-1.000e+00  -4.401e-01
1.000e+03   4.728e-03
``` 