# sinh#

ivy.sinh(x, /, *, out=None)[source]#

Calculate an implementation-dependent approximation to the hyperbolic sine, having domain `[-infinity, +infinity]` and codomain `[-infinity, +infinity]`, for each element `x_i` of the input array `x`.

Special cases

For floating-point operands,

• If `x_i` is `NaN`, the result is `NaN`.

• If `x_i` is `+0`, the result is `+0`.

• If `x_i` is `-0`, the result is `-0`.

• If `x_i` is `+infinity`, the result is `+infinity`.

• If `x_i` is `-infinity`, the result is `-infinity`.

Parameters:
• x (`Union`[`Array`, `NativeArray`]) – input array whose elements each represent a hyperbolic angle. Should have a floating-point data type.

• out (`Optional`[`Array`]) – optional output array, for writing the result to. It must have a shape that the (default: `None`) inputs broadcast to.

Return type:

`Array`

Returns:

ret – an array containing the hyperbolic sine of each element in `x`. The returned array must have a floating-point data type determined by type-promotion.

This function conforms to the Array API Standard. This docstring is an extension of the docstring # noqa in the standard.

Both the description and the type hints above assumes an array input for simplicity, but this function is nestable, and therefore also accepts `ivy.Container` instances in place of any of the arguments

Examples

With `ivy.Array` input:

```>>> x = ivy.array([1, 2, 3])
>>> y = ivy.sinh(x)
>>> print(y)
ivy.array([1.18, 3.63, 10.])
```
```>>> x = ivy.array([0.23, 3., -1.2])
>>> ivy.sinh(x, out=x)
>>> print(x)
ivy.array([0.232, 10., -1.51])
```

With `ivy.Container` input:

```>>> x = ivy.Container(a=ivy.array([0.23, -0.25, 1]), b=ivy.array([3, -4, 1.26]))
>>> y = ivy.sinh(x)
>>> print(y)
{
a: ivy.array([0.232, -0.253, 1.18]),
b: ivy.array([10., -27.3, 1.62])
}
```
Array.sinh(self, *, out=None)#

ivy.Array instance method variant of ivy.sinh. This method simply wraps the function, and so the docstring for ivy.sinh also applies to this method with minimal changes.

Parameters:
• self (`Array`) – input array whose elements each represent a hyperbolic angle. Should have a floating-point data type.

• out (`Optional`[`Array`]) – optional output array, for writing the result to. It must have a shape that (default: `None`) the inputs broadcast to.

Return type:

`Array`

Returns:

ret – an array containing the hyperbolic sine of each element in `self`. The returned array must have a floating-point data type determined by type-promotion.

Examples

```>>> x = ivy.array([1., 2., 3.])
>>> print(x.sinh())
ivy.array([1.18, 3.63, 10.])
```
```>>> x = ivy.array([0.23, 3., -1.2])
>>> y = ivy.zeros(3)
>>> print(x.sinh(out=y))
ivy.array([0.232, 10., -1.51])
```
Container.sinh(self, *, key_chains=None, to_apply=True, prune_unapplied=False, map_sequences=False, out=None)#

ivy.Container instance method variant of ivy.sinh. This method simply wraps the function, and so the docstring for ivy.sinh also applies to this method with minimal changes.

Parameters:
• self (`Container`) – input container whose elements each represent a hyperbolic angle. Should have a floating-point data type.

• key_chains (`Optional`[`Union`[`List`[`str`], `Dict`[`str`, `str`]]]) – The key-chains to apply or not apply the method to. Default is `None`. (default: `None`)

• to_apply (`bool`) – If True, the method will be applied to key_chains, otherwise key_chains (default: `True`) will be skipped. Default is `True`.

• prune_unapplied (`bool`) – Whether to prune key_chains for which the function was not applied. (default: `False`) Default is `False`.

• map_sequences (`bool`) – Whether to also map method to sequences (lists, tuples). (default: `False`) Default is `False`.

• out (`Optional`[`Container`]) – optional output container, for writing the result to. It must have a shape (default: `None`) that the inputs broadcast to.

Return type:

`Container`

Returns:

ret – an container containing the hyperbolic sine of each element in `self`. The returned container must have a floating-point data type determined by type-promotion.

Examples

```>>> x = ivy.Container(a=ivy.array([-1, 0.23, 1.12]), b=ivy.array([1, -2, 0.76]))
>>> y = x.sinh()
>>> print(y)
{
a: ivy.array([-1.18, 0.232, 1.37]),
b: ivy.array([1.18, -3.63, 0.835])
}
```
```>>> x = ivy.Container(a=ivy.array([-3, 0.34, 2.]),
...                   b=ivy.array([0.67, -0.98, -3]))
>>> y = ivy.Container(a=ivy.zeros(3), b=ivy.zeros(3))
>>> x.sinh(out=y)
>>> print(y)
{
a: ivy.array([-10., 0.347, 3.63]),
b: ivy.array([0.721, -1.14, -10.])
}
```