s19ac returns a value for the Kelvin function $\mathrm{ker} x$.

# Syntax

C#
```public static double s19ac(
double x,
out int ifail
)```
Visual Basic
```Public Shared Function s19ac ( _
x As Double, _
<OutAttribute> ByRef ifail As Integer _
) As Double```
Visual C++
```public:
static double s19ac(
double x,
[OutAttribute] int% ifail
)```
F#
```static member s19ac :
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

s19ac returns a value for the Kelvin function $\mathrm{ker} x$.

# Description

s19ac evaluates an approximation to the Kelvin function $\mathrm{ker} x$.
Note:  for $x<0$ the function is undefined and at $x=0$ it is infinite so we need only consider $x>0$.
The method is based on several Chebyshev expansions:
For $0,
 $ker x=-ftlogx+π16x2gt+yt$
where $f\left(t\right)$, $g\left(t\right)$ and $y\left(t\right)$ are expansions in the variable $t=2{x}^{4}-1$.
For $1,
 $ker x=exp-1116xqt$
where $q\left(t\right)$ is an expansion in the variable $t=x-2$.
For $x>3$,
 $ker x=π2xe-x/21+1xctcos β-1xdtsin β$
where $\beta =\frac{x}{\sqrt{2}}+\frac{\pi }{8}$, and $c\left(t\right)$ and $d\left(t\right)$ are expansions in the variable $t=\frac{6}{x}-1$.
When $x$ is sufficiently close to zero, the result is computed as
 $ker x=-γ-logx2+π-38x2x216$
and when $x$ is even closer to zero, simply as $\mathrm{ker} x=-\gamma -\mathrm{log}\left(\frac{x}{2}\right)$.
For large $x$, $\mathrm{ker} x$ is asymptotically given by $\sqrt{\frac{\pi }{2x}}{e}^{-x/\sqrt{2}}$ and this becomes so small that it cannot be computed without underflow and the method fails.

# 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$
On entry, x is too large: the result underflows. On failure, the method returns zero. See also the Users' Note for your implementation.
${\mathbf{ifail}}=2$
On entry, ${\mathbf{x}}\le 0.0$: the function is undefined. On failure the method returns zero.
${\mathbf{ifail}}=-9000$
An error occured, see message report.

# Accuracy

Let $E$ be the absolute error in the result, $\epsilon$ be the relative error in the result and $\delta$ be the relative error in the argument. If $\delta$ is somewhat larger than the machine precision, then we have:
 $E≃x2ker1 x+kei1 xδ,$
 $ε≃x2ker1 x+kei1 xker xδ.$
For very small $x$, the relative error amplification factor is approximately given by $\frac{1}{\left|\mathrm{log}\left(x\right)\right|}$, which implies a strong attenuation of relative error. However, $\epsilon$ in general cannot be less than the machine precision.
For small $x$, errors are damped by the function and hence are limited by the machine precision.
For medium and large $x$, the error behaviour, like the function itself, is oscillatory, and hence only the absolute accuracy for the function can be maintained. For this range of $x$, the amplitude of the absolute error decays like $\sqrt{\frac{\pi x}{2}}{e}^{-x/\sqrt{2}}$ which implies a strong attenuation of error. Eventually, $\mathrm{ker} x$, which asymptotically behaves like $\sqrt{\frac{\pi }{2x}}{e}^{-x/\sqrt{2}}$, becomes so small that it cannot be calculated without causing underflow, and the method returns zero. Note that for large $x$ the errors are dominated by those of the standard function exp.

# Parallelism and Performance

None.

Underflow may occur for a few values of $x$ close to the zeros of $\mathrm{ker} x$, below the limit which causes a failure with ${\mathbf{ifail}}={1}$.

# 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#): s19ace.cs

Example program data: s19ace.d

Example program results: s19ace.r