Ctrl+K

stable_divide#

ivy.stable_divide(numerator, denominator, /, *, min_denominator=None)[source]#

Divide the numerator by the denominator, with min denominator added to the denominator for numerical stability.

Parameters:

  • numerator (Union[Number, Array, NativeArray]) – The numerator of the division.

  • denominator (Union[Number, Array, NativeArray]) – The denominator of the division.

  • min_denominator (Optional[Union[Number, Array, NativeArray]], default: None) – The minimum denominator to use, use global ivy._MIN_DENOMINATOR (1e-12) by default.

Return type:

Union[Number, Array]

Returns:

ret – The new item following the numerically stable division.

Examples

With int input:

>>> x = ivy.stable_divide(1, 2)
>>> print(x)
0.49999999999975

>>> x = ivy.stable_divide(1, 4, min_denominator=1)
>>> print(x)
0.2

With float input:

>>> x = ivy.stable_divide(5.0, 3.33)
>>> print(x)
1.5015015015010504

With complex input:

>>> x = ivy.stable_divide(1+1j, 1-1j)
>>> print(x)
(5.000444502911705e-13+0.9999999999995j)

With ivy.Array input:

>>> x = ivy.asarray([[10., 20., 30.],
...                  [40., 50., 60.]])
>>> y = ivy.stable_divide(x, 10.)
>>> print(y)
ivy.array([[1., 2., 3.],
          [4., 5., 6.]])

>>> x = ivy.asarray([1,2,3])
>>> y = np.array((1., 3., 5.))
>>> z = ivy.stable_divide(x, y)
>>> print(z)
ivy.array([1.   , 0.667, 0.6  ])

>>> x = ivy.asarray([1., 2., 4.])
>>> y = ivy.asarray([1., 0.5, 0.25])
>>> z = ivy.asarray([0.01, 0.02, 0.03])
>>> w = ivy.stable_divide(x, y, min_denominator=z)
>>> print(w)
ivy.array([ 0.99,  3.85, 14.3 ])

With ivy.Container input:

>>> x = ivy.Container(a=ivy.asarray([10., 15.]), b=ivy.asarray([20., 25.]))
>>> y = ivy.stable_divide(x, 0.5)
>>> print(y)
{
    a: ivy.array([20., 30.]),
    b: ivy.array([40., 50.])
}

>>> x = ivy.Container(a=ivy.asarray([1., 2.]), b=ivy.asarray([3., 4.]))
>>> y = ivy.Container(a=ivy.asarray([0.5, 2.5]), b=ivy.asarray([3.5, 0.4]))
>>> z = ivy.stable_divide(x, y)
>>> print(z)
{
    a: ivy.array([2., 0.8]),
    b: ivy.array([0.857, 10.])
}
Array.stable_divide(self, denominator, /, *, min_denominator=None)[source]#

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

Parameters:

  • self – input array, used as the numerator for division.

  • denominator (Union[Number, Array, NativeArray, Container]) – denominator for division.

  • min_denominator (Optional[Union[Number, Array, NativeArray, Container]], default: None) – the minimum denominator to use, use global ivy._MIN_DENOMINATOR by default.

Return type:

Array

Returns:

ret – a numpy array containing the elements of numerator divided by the corresponding element of denominator

Examples

With ivy.Array instance method:

>>> x = ivy.asarray([4., 5., 6.])
>>> y = x.stable_divide(2)
>>> print(y)
ivy.array([2., 2.5, 3.])

>>> x = ivy.asarray([4, 5, 6])
>>> y = x.stable_divide(4, min_denominator=1)
>>> print(y)
ivy.array([0.8, 1. , 1.2])

>>> x = ivy.asarray([[4., 5., 6.], [7., 8., 9.]])
>>> y = ivy.asarray([[1., 2., 3.], [2., 3., 4.]])
>>> z = x.stable_divide(y)
>>> print(z)
ivy.array([[4.  , 2.5 , 2.  ],
        [3.5 , 2.67, 2.25]])
Container.stable_divide(self, denominator, /, *, min_denominator=None, key_chains=None, to_apply=True, prune_unapplied=False, map_sequences=False)[source]#

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

Parameters:

  • self – input container.

  • denominator (Union[Number, Array, NativeArray, Container]) – Container of the denominators of the division.

  • min_denominator (Optional[Union[Number, Array, NativeArray, Container]], default: None) – Container of the minimum denominator to use, use global ivy.min_denominator by default.

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

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

  • prune_unapplied (Union[bool, Container], default: False) – Whether to prune key_chains for which the function was not applied. Default is False.

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

Return type:

Container

Returns:

ret – a container of numpy arrays copying all the element of the container self. A container of elements containing the new items following the numerically stable division, using self as the numerator.

Examples

>>> x = ivy.Container(a=ivy.asarray([3., 6.]), b=ivy.asarray([9., 12.]))
>>> y = x.stable_divide(5)
>>> print(y)
{
    a: ivy.array([0.6, 1.2]),
    b: ivy.array([1.8, 2.4])
}

>>> x = ivy.Container(a=ivy.asarray([[2., 4.], [6., 8.]]),
...                   b=ivy.asarray([[10., 12.], [14., 16.]]))
>>> z = x.stable_divide(2, min_denominator=2)
>>> print(z)
{
    a: ivy.array([[0.5, 1.],
          [1.5, 2.]]),
    b: ivy.array([[2.5, 3.],
          [3.5, 4.]])
}

>>> x = ivy.Container(a=ivy.asarray([3., 6.]), b=ivy.asarray([9., 12.]))
>>> y = ivy.Container(a=ivy.asarray([6., 9.]), b=ivy.asarray([12., 15.]))
>>> z = x.stable_divide(y)
>>> print(z)
{
    a: ivy.array([0.5, 0.667]),
    b: ivy.array([0.75, 0.8])
}
On this page