# xarray.ufuncs.frexp

`xarray.ufuncs.``frexp` = <xarray.ufuncs._UFuncDispatcher object>

  xarray specific variant of numpy.frexp. Handles xarray.Dataset, xarray.DataArray, xarray.Variable, numpy.ndarray and dask.array.Array objects with automatic dispatching.

  Documentation from numpy:

  frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting=’same_kind’, order=’K’, dtype=None, subok=True[, signature, extobj])

  Decompose the elements of x into mantissa and twos exponent.

  Returns (mantissa, exponent), where x = mantissa * 2**exponent`. The mantissa is lies in the open interval(-1, 1), while the twos exponent is a signed integer.

  Parameters:

  x : array_like

  > Array of numbers to be decomposed.

  out1 : ndarray, optional

  > Output array for the mantissa. Must have the same shape as x.

  out2 : ndarray, optional

  > Output array for the exponent. Must have the same shape as x.

  out : ndarray, None, or tuple of ndarray and None, optional

  > A location into which the result is stored. If provided, it must have a shape that the inputs broadcast to. If not provided or None, a freshly-allocated array is returned. A tuple (possible only as a keyword argument) must have length equal to the number of outputs.

  where : array_like, optional

  > Values of True indicate to calculate the ufunc at that position, values of False indicate to leave the value in the output alone.

  **kwargs

  > For other keyword-only arguments, see the ufunc docs.

  Returns:

  (mantissa, exponent) : tuple of ndarrays, (float, int)

  > mantissa is a float array with values between -1 and 1. exponent is an int array which represents the exponent of 2.

  See also

  `ldexp`
    Compute `y = x1 * 2**x2`, the inverse of frexp.

  Notes

  Complex dtypes are not supported, they will raise a TypeError.

  Examples

      >>> x = np.arange(9)
      >>> y1, y2 = np.frexp(x)
      >>> y1
      array([ 0.   ,  0.5  ,  0.5  ,  0.75 ,  0.5  ,  0.625,  0.75 ,  0.875,
              0.5  ])
      >>> y2
      array([0, 1, 2, 2, 3, 3, 3, 3, 4])
      >>> y1 * 2**y2
      array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])