s18ad returns the value of the modified Bessel function ${K}_{1}\left(x\right)$.

# Syntax

C# |
---|

public static double s18ad( double x, out int ifail ) |

Visual Basic |
---|

Public Shared Function s18ad ( _ x As Double, _ <OutAttribute> ByRef ifail As Integer _ ) As Double |

Visual C++ |
---|

public: static double s18ad( double x, [OutAttribute] int% ifail ) |

F# |
---|

static member s18ad : x : float * ifail : int byref -> float |

#### Parameters

- x
- Type: System..::..Double
*On entry*: the argument $x$ of the function.*Constraint*: ${\mathbf{x}}>0.0$.

- ifail
- Type: System..::..Int32%
*On exit*: ${\mathbf{ifail}}={0}$ unless the method detects an error or a warning has been flagged (see [Error Indicators and Warnings]).

#### Return Value

s18ad returns the value of the modified Bessel function ${K}_{1}\left(x\right)$.

# Description

s18ad evaluates an approximation to the modified Bessel function of the second kind ${K}_{1}\left(x\right)$.

**Note:**${K}_{1}\left(x\right)$ is undefined for $x\le 0$ and the method will fail for such arguments.

The method is based on five Chebyshev expansions:

For $0<x\le 1$,

For $1<x\le 2$,

For $2<x\le 4$,

For $x>4$,

For $x$ near zero, ${K}_{1}\left(x\right)\simeq \frac{1}{x}$. This approximation is used when $x$ is sufficiently small for the result to be correct to machine precision. For very small $x$ on some machines, it is impossible to calculate $\frac{1}{x}$ without overflow and the method must fail.

$${K}_{1}\left(x\right)=\frac{1}{x}+x\mathrm{ln}\u200ax\underset{r=0}{{\sum}^{\prime}}\phantom{\rule{0.25em}{0ex}}{a}_{r}{T}_{r}\left(t\right)-x\underset{r=0}{{\sum}^{\prime}}\phantom{\rule{0.25em}{0ex}}{b}_{r}{T}_{r}\left(t\right)\text{, \hspace{1em} where}t=2{x}^{2}-1\text{.}$$ |

$${K}_{1}\left(x\right)={e}^{-x}\underset{r=0}{{\sum}^{\prime}}\phantom{\rule{0.25em}{0ex}}{c}_{r}{T}_{r}\left(t\right)\text{, \hspace{1em} where}t=2x-3\text{.}$$ |

$${K}_{1}\left(x\right)={e}^{-x}\underset{r=0}{{\sum}^{\prime}}\phantom{\rule{0.25em}{0ex}}{d}_{r}{T}_{r}\left(t\right)\text{, \hspace{1em} where}t=x-3\text{.}$$ |

$${K}_{1}\left(x\right)=\frac{{e}^{-x}}{\sqrt{x}}\underset{r=0}{{\sum}^{\prime}}\phantom{\rule{0.25em}{0ex}}{e}_{r}{T}_{r}\left(t\right)\text{, \hspace{1em} where}t=\frac{9-x}{1+x}\text{.}$$ |

For large $x$, where there is a danger of underflow due to the smallness of ${K}_{1}$, the result is set exactly to zero.

# References

Abramowitz M and Stegun I A (1972)

*Handbook of Mathematical Functions*(3rd Edition) Dover Publications# Error Indicators and Warnings

Errors or warnings detected by the method:

- ${\mathbf{ifail}}=1$
- ${\mathbf{x}}\le 0.0$, ${K}_{1}$ is undefined. On failure the method returns zero.

- ${\mathbf{ifail}}=2$
- x is too small, there is a danger of overflow. On failure the method returns approximately the largest representable value. (see the Users' Note for your implementation for details)

# Accuracy

Let $\delta $ and $\epsilon $ be the relative errors in the argument and result respectively.

If $\delta $ is somewhat larger than the machine precision (i.e., if $\delta $ is due to data errors etc.), then $\epsilon $ and $\delta $ are approximately related by:

Figure 1 shows the behaviour of the error amplification factor

$$\epsilon \simeq \left|\frac{x{K}_{0}\left(x\right)-{K}_{1}\left(x\right)}{{K}_{1}\left(x\right)}\right|\delta \text{.}$$ |

$$\left|\frac{x{K}_{0}\left(x\right)-{K}_{1}\left(x\right)}{{K}_{1}\left(x\right)}\right|\text{.}$$ |

However if $\delta $ is of the same order as the machine precision, then rounding errors could make $\epsilon $ slightly larger than the above relation predicts.

For small $x$, $\epsilon \simeq \delta $ and there is no amplification of errors.

For large $x$, $\epsilon \simeq x\delta $ and we have strong amplification of the relative error. Eventually ${K}_{1}$, which is asymptotically given by $\frac{{e}^{-x}}{\sqrt{x}}$, becomes so small that it cannot be calculated without underflow and hence the method will return zero. Note that for large $x$ the errors will be dominated by those of the standard function exp.

# Parallelism and Performance

None.

# Further Comments

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.

Example program (C#): s18ade.cs