dask/array/tests/test_ufunc.py::test_ufunc_meta[log]: assert 'log(x, /, ou... 2., -inf])' == 'log(x, /, ou... 2., -inf])'
log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])
Natural logarithm, element-wise.
The natural logarithm `log` is the inverse of the exponential function,
so that `log(exp(x)) = x`. The natural logarithm is logarithm in base
`e`.
Parameters
----------
- x : array_like
+ x : array_like (Not supported in Dask)
Input value.
- out : ndarray, None, or tuple of ndarray and None, optional
+ out : ndarray, None, or tuple of ndarray and None, optional (Not supported in Dask)
? +++++++++++++++++++++++++
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
+ where : array_like, optional (Not supported in Dask)
This condition is broadcast over the input. At locations where the
condition is True, the `out` array will be set to the ufunc result.
Elsewhere, the `out` array will retain its original value.
Note that if an uninitialized `out` array is created via the default
``out=None``, locations within it where the condition is False will
remain uninitialized.
**kwargs
For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.
Returns
-------
y : ndarray
The natural logarithm of `x`, element-wise.
This is a scalar if `x` is a scalar.
See Also
--------
log10, log2, log1p, emath.log
Notes
-----
Logarithm is a multivalued function: for each `x` there is an infinite
number of `z` such that `exp(z) = x`. The convention is to return the
`z` whose imaginary part lies in `(-pi, pi]`.
For real-valued input data types, `log` always returns real output. For
each value that cannot be expressed as a real number or infinity, it
yields ``nan`` and sets the `invalid` floating point error flag.
For complex-valued input, `log` is a complex analytical function that
has a branch cut `[-inf, 0]` and is continuous from above on it. `log`
handles the floating-point negative zero as an infinitesimal negative
number, conforming to the C99 standard.
In the cases where the input has a negative real part and a very small
negative complex part (approaching 0), the result is so close to `-pi`
that it evaluates to exactly `-pi`.
References
----------
.. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
10th printing, 1964, pp. 67.
https://personal.math.ubc.ca/~cbm/aands/page_67.htm
.. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm
Examples
--------
>>> import numpy as np
>>> np.log([1, np.e, np.e**2, 0])
array([ 0., 1., 2., -inf])
dask/array/tests/test_ufunc.py::test_ufunc_meta[modf]: AssertionError: assert 'modf(x[, out...)\n(-0.5, -0)' == 'modf(x[, out...)\n(-0.5, -0)'
modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])
Return the fractional and integral parts of an array, element-wise.
The fractional and integral parts are negative if the given number is
negative.
Parameters
----------
x : array_like
Input array.
- out : ndarray, None, or tuple of ndarray and None, optional
+ out : ndarray, None, or tuple of ndarray and None, optional (Not supported in Dask)
? +++++++++++++++++++++++++
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
+ where : array_like, optional (Not supported in Dask)
This condition is broadcast over the input. At locations where the
condition is True, the `out` array will be set to the ufunc result.
Elsewhere, the `out` array will retain its original value.
Note that if an uninitialized `out` array is created via the default
``out=None``, locations within it where the condition is False will
remain uninitialized.
**kwargs
For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.
Returns
-------
y1 : ndarray
Fractional part of `x`.
This is a scalar if `x` is a scalar.
y2 : ndarray
Integral part of `x`.
This is a scalar if `x` is a scalar.
Notes
-----
For integer input the return values are floats.
See Also
--------
divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values
switched, except it always has a positive remainder.
Examples
--------
>>> import numpy as np
>>> np.modf([0, 3.5])
(array([ 0. , 0.5]), array([ 0., 3.]))
>>> np.modf(-0.5)
(-0.5, -0)
dask/array/tests/test_ufunc.py::test_ufunc_meta[frexp]: AssertionError: assert 'frexp(x[, ou...., 7., 8.])' == 'frexp(x[, ou...., 7., 8.])'
frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature])
Decompose the elements of x into mantissa and twos exponent.
Returns (`mantissa`, `exponent`), where ``x = mantissa * 2**exponent``.
The mantissa 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
+ out : ndarray, None, or tuple of ndarray and None, optional (Not supported in Dask)
? +++++++++++++++++++++++++
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
+ where : array_like, optional (Not supported in Dask)
This condition is broadcast over the input. At locations where the
condition is True, the `out` array will be set to the ufunc result.
Elsewhere, the `out` array will retain its original value.
Note that if an uninitialized `out` array is created via the default
``out=None``, locations within it where the condition is False will
remain uninitialized.
**kwargs
For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.
Returns
-------
mantissa : ndarray
Floating values between -1 and 1.
This is a scalar if `x` is a scalar.
exponent : ndarray
Integer exponents of 2.
This is a scalar if `x` is a scalar.
See Also
--------
ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`.
Notes
-----
Complex dtypes are not supported, they will raise a TypeError.
Examples
--------
>>> import numpy as np
>>> 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], dtype=int32)
>>> y1 * 2**y2
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.])
dask/dataframe/io/tests/test_parquet.py::test_roundtrip_decimal_dtype: AssertionError: assert datetime64[us, UTC] != datetime64[us, UTC]
+ where datetime64[us, UTC] = Dask Series Structure:\nnpartitions=1\n datetime64[us, UTC]\n ...\nDask Name: getitem, 2 expressions\nExpr=ReadParquetFSSpec(01d0de6)['ts'].dtype
+ and datetime64[us, UTC] = Dask Series Structure:\nnpartitions=1\n0 datetime64[us, UTC]\n22 ...\nDask Name: getitem, 3 expressions\nExpr=(AsType(frame=df, dtypes={'col1': decimal128(5, 2)[pyarrow]}))['ts'].dtype
dask/dataframe/io/tests/test_parquet.py::test_roundtrip_date_dtype: AssertionError: assert datetime64[us, UTC] != datetime64[us, UTC]
+ where datetime64[us, UTC] = Dask Series Structure:\nnpartitions=1\n datetime64[us, UTC]\n ...\nDask Name: getitem, 2 expressions\nExpr=ReadParquetFSSpec(b3e588b)['ts'].dtype
+ and datetime64[us, UTC] = Dask Series Structure:\nnpartitions=1\n0 datetime64[us, UTC]\n22 ...\nDask Name: getitem, 3 expressions\nExpr=(AsType(frame=df, dtypes={'col1': date32[day][pyarrow]}))['ts'].dtype