s10ab returns the value of the hyperbolic sine, $\mathrm{sinh}\u200ax$.

# Syntax

C# |
---|

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

Visual Basic |
---|

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

Visual C++ |
---|

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

F# |
---|

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

#### Parameters

- x
- Type: System..::..Double
*On entry*: the argument $x$ of the function.

- 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

s10ab returns the value of the hyperbolic sine, $\mathrm{sinh}\u200ax$.

# Description

s10ab calculates an approximate value for the hyperbolic sine of its argument,
$\mathrm{sinh}\u200ax$.

For $\left|x\right|\le 1$ it uses the Chebyshev expansion

where $t=2{x}^{2}-1$.

$$\mathrm{sinh}\u200ax=x\times y\left(t\right)=x\underset{r=0}{{\sum}^{\prime}}\phantom{\rule{0.25em}{0ex}}{a}_{r}{T}_{r}\left(t\right)$$ |

For $1<\left|x\right|\le {E}_{1}\text{, \hspace{1em}}\mathrm{sinh}\u200ax=\frac{1}{2}\left({e}^{x}-{e}^{-x}\right)$

where ${E}_{1}$ is a machine-dependent constant, details of which are given in the Users' Note for your implementation.

For $\left|x\right|>{E}_{1}$, the method fails owing to the danger of setting overflow in calculating ${e}^{x}$. The result returned for such calls is $\mathrm{sinh}\left(\mathrm{sign}\u200ax{E}_{1}\right)$, i.e., it returns the result for the nearest valid argument.

# 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$
- The method has been called with an argument too large in absolute magnitude. There is a danger of setting overflow. The result is the value of $\mathrm{sinh}\u200ax$ at the closest argument for which a valid call could be made. (See [Description] and the Users' Note for your implementation.)

# Accuracy

If $\delta $ and $\epsilon $ are the relative errors in the argument and result, respectively, then in principle

$$\left|\epsilon \right|\simeq \left|x\mathrm{coth}\u200ax\times \delta \right|\text{.}$$ |

That is the relative error in the argument, $x$, is amplified by a factor, approximately $x\mathrm{coth}\u200ax$. The equality should hold if $\delta $ is greater than the machine precision ($\delta $ is a result of data errors etc.) but, if $\delta $ is simply a result of round-off in the machine representation of $x$, then it is possible that an extra figure may be lost in internal calculation round-off.

It should be noted that for $\left|x\right|\ge 2$

where $\Delta $ is the absolute error in the argument.

$$\epsilon \sim x\delta =\Delta $$ |

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