exp#

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

Calculate an implementation-dependent approximation to the exponential function, having domain [-infinity, +infinity] and codomain [+0, +infinity], for each element x_i of the input array x (e raised to the power of x_i, where e is the base of the natural logarithm).

Special cases

For floating-point operands,

  • If x_i is NaN, the result is NaN.

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

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

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

  • If x_i is -infinity, the result is +0.

Parameters:
  • x (Union[Array, NativeArray, Number]) – input array. 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 evaluated exponential function result for each element in x. The returned array must have a floating-point data type determined by type-promotion.

  • This method conforms to the

  • `Array API Standard <https (//data-apis.org/array-api/latest/>`_.)

  • This docstring is an extension of the

  • `docstring <https (//data-apis.org/array-api/latest/API_specification/generated/signatures.elementwise_functions.exp.html>`_ # 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 :class:Number:

>>> x = 3
>>> y = ivy.exp(x)
>>> print(y)
ivy.array(20.08553692)

With ivy.Array input:

>>> x = ivy.array([1., 2., 3.])
>>> y = ivy.exp(x)
>>> print(y)
ivy.array([ 2.71828175,  7.38905621, 20.08553696])

With nested inputs in ivy.Array:

>>> x = ivy.array([[-5.67], [ivy.nan], [0.567]])
>>> y = ivy.exp(x)
>>> print(y)
ivy.array([[0.00344786],
       [       nan],
       [1.76297021]])

With ivy.NativeArray input:

>>> x = ivy.native_array([0., 4., 2.])
>>> y = ivy.exp(x)
>>> print(y)
ivy.array([ 1.        , 54.59814835,  7.38905621])

With ivy.Container input:

>>> x = ivy.Container(a=3.1, b=ivy.array([3.2, 1.]))
>>> y = ivy.exp(x)
>>> print(y)
{
    a: ivy.array(22.197948),
    b: ivy.array([24.53253174, 2.71828175])
}
Array.exp(self, *, out=None)#

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

Parameters:
  • self (Array) – input array. 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 evaluated exponential function result for 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.exp())
ivy.array([ 2.71828198,  7.38905573, 20.08553696])
Container.exp(self, *, key_chains=None, to_apply=True, prune_unapplied=False, map_sequences=False, out=None)#

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

Parameters:
  • self (Container) – input container. 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 – a container containing the evaluated result for each element in self. The returned array must have a real-valued floating-point data type determined by type-promotion.

Examples

>>> x = ivy.Container(a=ivy.array([1., 2., 3.]), b=ivy.array([4., 5., 6.]))
>>> y = x.exp()
>>> print(y)
{
    a: ivy.array([2.71828198, 7.38905573, 20.08553696]),
    b: ivy.array([54.59814835, 148.4131622, 403.428772])
}