numpy

func Abs ¶

func Abs(__llgo_va_list ...interface{}) *py.Object

absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Calculate the absolute value element-wise.

“np.abs“ is a shorthand for this function.

Parameters ---------- x : array_like

Input array.

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

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 ------- absolute : ndarray

An ndarray containing the absolute value of
each element in `x`.  For complex input, ``a + ib``, the
absolute value is :math:`\sqrt{ a^2 + b^2 }`.
This is a scalar if `x` is a scalar.

Examples -------- >>> x = np.array([-1.2, 1.2]) >>> np.absolute(x) array([ 1.2, 1.2]) >>> np.absolute(1.2 + 1j) 1.5620499351813308

Plot the function over “[-10, 10]“:

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(start=-10, stop=10, num=101) >>> plt.plot(x, np.absolute(x)) >>> plt.show()

Plot the function over the complex plane:

>>> xx = x + 1j * x[:, np.newaxis] >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') >>> plt.show()

The `abs` function can be used as a shorthand for “np.absolute“ on ndarrays.

>>> x = np.array([-1.2, 1.2]) >>> abs(x) array([1.2, 1.2])

func Absolute ¶

func Absolute(x *py.Object, out *py.Object) *py.Object

absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Calculate the absolute value element-wise.

“np.abs“ is a shorthand for this function.

Parameters ---------- x : array_like

Input array.

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

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 ------- absolute : ndarray

An ndarray containing the absolute value of
each element in `x`.  For complex input, ``a + ib``, the
absolute value is :math:`\sqrt{ a^2 + b^2 }`.
This is a scalar if `x` is a scalar.

Examples -------- >>> x = np.array([-1.2, 1.2]) >>> np.absolute(x) array([ 1.2, 1.2]) >>> np.absolute(1.2 + 1j) 1.5620499351813308

Plot the function over “[-10, 10]“:

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(start=-10, stop=10, num=101) >>> plt.plot(x, np.absolute(x)) >>> plt.show()

Plot the function over the complex plane:

>>> xx = x + 1j * x[:, np.newaxis] >>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray') >>> plt.show()

The `abs` function can be used as a shorthand for “np.absolute“ on ndarrays.

>>> x = np.array([-1.2, 1.2]) >>> abs(x) array([1.2, 1.2])

func Add ¶

func Add(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Add arguments element-wise.

Parameters ---------- x1, x2 : array_like

The arrays to be added.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- add : ndarray or scalar

The sum of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

Notes ----- Equivalent to `x1` + `x2` in terms of array broadcasting.

Examples -------- >>> np.add(1.0, 4.0) 5.0 >>> x1 = np.arange(9.0).reshape((3, 3)) >>> x2 = np.arange(3.0) >>> np.add(x1, x2) array([[ 0., 2., 4.],

[  3.,   5.,   7.],
[  6.,   8.,  10.]])

The “+“ operator can be used as a shorthand for “np.add“ on ndarrays.

>>> x1 = np.arange(9.0).reshape((3, 3)) >>> x2 = np.arange(3.0) >>> x1 + x2 array([[ 0., 2., 4.],

[ 3.,  5.,  7.],
[ 6.,  8., 10.]])

func AddDocstring ¶

func AddDocstring(obj *py.Object, docstring *py.Object) *py.Object

add_docstring(obj, docstring)

Add a docstring to a built-in obj if possible.
If the obj already has a docstring raise a RuntimeError
If this routine does not know how to add a docstring to the object
raise a TypeError

func AddNewdoc ¶

func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *py.Object

Add documentation to an existing object, typically one defined in C

The purpose is to allow easier editing of the docstrings without requiring a re-compile. This exists primarily for internal use within numpy itself.

Parameters ---------- place : str

The absolute name of the module to import from

obj : str

The name of the object to add documentation to, typically a class or
function name

doc : {str, Tuple[str, str], List[Tuple[str, str]]}

If a string, the documentation to apply to `obj`

If a tuple, then the first element is interpreted as an attribute of
`obj` and the second as the docstring to apply - ``(method, docstring)``

If a list, then each element of the list should be a tuple of length
two - ``[(method1, docstring1), (method2, docstring2), ...]``

warn_on_python : bool

If True, the default, emit `UserWarning` if this is used to attach
documentation to a pure-python object.

Notes ----- This routine never raises an error if the docstring can't be written, but will raise an error if the object being documented does not exist.

This routine cannot modify read-only docstrings, as appear in new-style classes or built-in functions. Because this routine never raises an error the caller must check manually that the docstrings were changed.

Since this function grabs the “char *“ from a c-level str object and puts it into the “tp_doc“ slot of the type of `obj`, it violates a number of C-API best-practices, by:

• modifying a `PyTypeObject` after calling `PyType_Ready`
• calling `Py_INCREF` on the str and losing the reference, so the str will never be released

If possible it should be avoided.

func AddNewdocUfunc ¶

func AddNewdocUfunc(__llgo_va_list ...interface{}) *py.Object

add_ufunc_docstring(ufunc, new_docstring)

Replace the docstring for a ufunc with new_docstring.
This method will only work if the current docstring for
the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)

Parameters
----------
ufunc : numpy.ufunc
    A ufunc whose current doc is NULL.
new_docstring : string
    The new docstring for the ufunc.

Notes
-----
This method allocates memory for new_docstring on
the heap. Technically this creates a mempory leak, since this
memory will not be reclaimed until the end of the program
even if the ufunc itself is removed. However this will only
be a problem if the user is repeatedly creating ufuncs with
no documentation, adding documentation via add_newdoc_ufunc,
and then throwing away the ufunc.

func All ¶

func All(__llgo_va_list ...interface{}) *py.Object

Test whether all array elements along a given axis evaluate to True.

Parameters ---------- a : array_like

Input array or object that can be converted to an array.

axis : None or int or tuple of ints, optional

Axis or axes along which a logical AND reduction is performed.
The default (``axis=None``) is to perform a logical AND over all
the dimensions of the input array. `axis` may be negative, in
which case it counts from the last to the first axis.

.. versionadded:: 1.7.0

If this is a tuple of ints, a reduction is performed on multiple
axes, instead of a single axis or all the axes as before.

out : ndarray, optional

Alternate output array in which to place the result.
It must have the same shape as the expected output and its
type is preserved (e.g., if ``dtype(out)`` is float, the result
will consist of 0.0's and 1.0's). See :ref:`ufuncs-output-type` for more
details.

keepdims : bool, optional

If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

If the default value is passed, then `keepdims` will not be
passed through to the `all` method of sub-classes of
`ndarray`, however any non-default value will be.  If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.

where : array_like of bool, optional

Elements to include in checking for all `True` values.
See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.20.0

Returns ------- all : ndarray, bool

A new boolean or array is returned unless `out` is specified,
in which case a reference to `out` is returned.

See Also -------- ndarray.all : equivalent method

any : Test whether any element along a given axis evaluates to True.

Notes ----- Not a Number (NaN), positive infinity and negative infinity evaluate to `True` because these are not equal to zero.

Examples -------- >>> np.all([[True,False],[True,True]]) False

>>> np.all([[True,False],[True,True]], axis=0) array([ True, False])

>>> np.all([-1, 4, 5]) True

>>> np.all([1.0, np.nan]) True

>>> np.all([[True, True], [False, True]], where=[[True], [False]]) True

>>> o=np.array(False) >>> z=np.all([-1, 4, 5], out=o) >>> id(z), id(o), z (28293632, 28293632, array(True)) # may vary

func Allclose ¶

func Allclose(a *py.Object, b *py.Object, rtol *py.Object, atol *py.Object, equalNan *py.Object) *py.Object

Returns True if two arrays are element-wise equal within a tolerance.

The tolerance values are positive, typically very small numbers. The relative difference (`rtol` * abs(`b`)) and the absolute difference `atol` are added together to compare against the absolute difference between `a` and `b`.

NaNs are treated as equal if they are in the same place and if “equal_nan=True“. Infs are treated as equal if they are in the same place and of the same sign in both arrays.

Parameters ---------- a, b : array_like

Input arrays to compare.

rtol : float

The relative tolerance parameter (see Notes).

atol : float

The absolute tolerance parameter (see Notes).

equal_nan : bool

Whether to compare NaN's as equal.  If True, NaN's in `a` will be
considered equal to NaN's in `b` in the output array.

.. versionadded:: 1.10.0

Returns ------- allclose : bool

Returns True if the two arrays are equal within the given
tolerance; False otherwise.

See Also -------- isclose, all, any, equal

Notes ----- If the following equation is element-wise True, then allclose returns True.

absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))

The above equation is not symmetric in `a` and `b`, so that “allclose(a, b)“ might be different from “allclose(b, a)“ in some rare cases.

The comparison of `a` and `b` uses standard broadcasting, which means that `a` and `b` need not have the same shape in order for “allclose(a, b)“ to evaluate to True. The same is true for `equal` but not `array_equal`.

`allclose` is not defined for non-numeric data types. `bool` is considered a numeric data-type for this purpose.

Examples -------- >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8]) False >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9]) True >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9]) False >>> np.allclose([1.0, np.nan], [1.0, np.nan]) False >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) True

func Alltrue ¶

func Alltrue(__llgo_va_list ...interface{}) *py.Object

Check if all elements of input array are true.

.. deprecated:: 1.25.0

``alltrue`` is deprecated as of NumPy 1.25.0, and will be
removed in NumPy 2.0. Please use `all` instead.

See Also -------- numpy.all : Equivalent function; see for details.

func Amax ¶

func Amax(__llgo_va_list ...interface{}) *py.Object

Return the maximum of an array or maximum along an axis.

`amax` is an alias of `~numpy.max`.

See Also -------- max : alias of this function ndarray.max : equivalent method

func Amin ¶

func Amin(__llgo_va_list ...interface{}) *py.Object

Return the minimum of an array or minimum along an axis.

`amin` is an alias of `~numpy.min`.

See Also -------- min : alias of this function ndarray.min : equivalent method

func Angle ¶

func Angle(z *py.Object, deg *py.Object) *py.Object

Return the angle of the complex argument.

Parameters ---------- z : array_like

A complex number or sequence of complex numbers.

deg : bool, optional

Return angle in degrees if True, radians if False (default).

Returns ------- angle : ndarray or scalar

The counterclockwise angle from the positive real axis on the complex
plane in the range ``(-pi, pi]``, with dtype as numpy.float64.

.. versionchanged:: 1.16.0
    This function works on subclasses of ndarray like `ma.array`.

See Also -------- arctan2 absolute

Notes ----- Although the angle of the complex number 0 is undefined, “numpy.angle(0)“ returns the value 0.

Examples -------- >>> np.angle([1.0, 1.0j, 1+1j]) # in radians array([ 0. , 1.57079633, 0.78539816]) # may vary >>> np.angle(1+1j, deg=True) # in degrees 45.0

func Any ¶

func Any(__llgo_va_list ...interface{}) *py.Object

Test whether any array element along a given axis evaluates to True.

Returns single boolean if `axis` is “None“

Parameters ---------- a : array_like

Input array or object that can be converted to an array.

axis : None or int or tuple of ints, optional

Axis or axes along which a logical OR reduction is performed.
The default (``axis=None``) is to perform a logical OR over all
the dimensions of the input array. `axis` may be negative, in
which case it counts from the last to the first axis.

.. versionadded:: 1.7.0

If this is a tuple of ints, a reduction is performed on multiple
axes, instead of a single axis or all the axes as before.

out : ndarray, optional

Alternate output array in which to place the result.  It must have
the same shape as the expected output and its type is preserved
(e.g., if it is of type float, then it will remain so, returning
1.0 for True and 0.0 for False, regardless of the type of `a`).
See :ref:`ufuncs-output-type` for more details.

keepdims : bool, optional

If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

If the default value is passed, then `keepdims` will not be
passed through to the `any` method of sub-classes of
`ndarray`, however any non-default value will be.  If the
sub-class' method does not implement `keepdims` any
exceptions will be raised.

where : array_like of bool, optional

Elements to include in checking for any `True` values.
See `~numpy.ufunc.reduce` for details.

.. versionadded:: 1.20.0

Returns ------- any : bool or ndarray

A new boolean or `ndarray` is returned unless `out` is specified,
in which case a reference to `out` is returned.

See Also -------- ndarray.any : equivalent method

all : Test whether all elements along a given axis evaluate to True.

Notes ----- Not a Number (NaN), positive infinity and negative infinity evaluate to `True` because these are not equal to zero.

Examples -------- >>> np.any([[True, False], [True, True]]) True

>>> np.any([[True, False], [False, False]], axis=0) array([ True, False])

>>> np.any([-1, 0, 5]) True

>>> np.any(np.nan) True

>>> np.any([[True, False], [False, False]], where=[[False], [True]]) False

>>> o=np.array(False) >>> z=np.any([-1, 4, 5], out=o) >>> z, o (array(True), array(True)) >>> # Check now that z is a reference to o >>> z is o True >>> id(z), id(o) # identity of z and o # doctest: +SKIP (191614240, 191614240)

func Append ¶

func Append(arr *py.Object, values *py.Object, axis *py.Object) *py.Object

Append values to the end of an array.

Parameters ---------- arr : array_like

Values are appended to a copy of this array.

values : array_like

These values are appended to a copy of `arr`.  It must be of the
correct shape (the same shape as `arr`, excluding `axis`).  If
`axis` is not specified, `values` can be any shape and will be
flattened before use.

axis : int, optional

The axis along which `values` are appended.  If `axis` is not
given, both `arr` and `values` are flattened before use.

Returns ------- append : ndarray

A copy of `arr` with `values` appended to `axis`.  Note that
`append` does not occur in-place: a new array is allocated and
filled.  If `axis` is None, `out` is a flattened array.

See Also -------- insert : Insert elements into an array. delete : Delete elements from an array.

Examples -------- >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]]) array([1, 2, 3, ..., 7, 8, 9])

When `axis` is specified, `values` must have the correct shape.

>>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0) array([[1, 2, 3],

[4, 5, 6],
[7, 8, 9]])

>>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0) Traceback (most recent call last):

...

ValueError: all the input arrays must have same number of dimensions, but the array at index 0 has 2 dimension(s) and the array at index 1 has 1 dimension(s)

func ApplyAlongAxis ¶

func ApplyAlongAxis(func1d *py.Object, axis *py.Object, arr *py.Object, __llgo_va_list ...interface{}) *py.Object

Apply a function to 1-D slices along the given axis.

Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays and `a` is a 1-D slice of `arr` along `axis`.

This is equivalent to (but faster than) the following use of `ndindex` and `s_`, which sets each of “ii“, “jj“, and “kk“ to a tuple of indices::

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        f = func1d(arr[ii + s_[:,] + kk])
        Nj = f.shape
        for jj in ndindex(Nj):
            out[ii + jj + kk] = f[jj]

Equivalently, eliminating the inner loop, this can be expressed as::

Ni, Nk = a.shape[:axis], a.shape[axis+1:]
for ii in ndindex(Ni):
    for kk in ndindex(Nk):
        out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])

Parameters ---------- func1d : function (M,) -> (Nj...)

This function should accept 1-D arrays. It is applied to 1-D
slices of `arr` along the specified axis.

axis : integer

Axis along which `arr` is sliced.

arr : ndarray (Ni..., M, Nk...)

Input array.

args : any

Additional arguments to `func1d`.

kwargs : any

Additional named arguments to `func1d`.

.. versionadded:: 1.9.0

Returns ------- out : ndarray (Ni..., Nj..., Nk...)

The output array. The shape of `out` is identical to the shape of
`arr`, except along the `axis` dimension. This axis is removed, and
replaced with new dimensions equal to the shape of the return value
of `func1d`. So if `func1d` returns a scalar `out` will have one
fewer dimensions than `arr`.

See Also -------- apply_over_axes : Apply a function repeatedly over multiple axes.

Examples -------- >>> def my_func(a): ... """Average first and last element of a 1-D array""" ... return (a[0] + a[-1]) * 0.5 >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) >>> np.apply_along_axis(my_func, 0, b) array([4., 5., 6.]) >>> np.apply_along_axis(my_func, 1, b) array([2., 5., 8.])

For a function that returns a 1D array, the number of dimensions in `outarr` is the same as `arr`.

>>> b = np.array([[8,1,7], [4,3,9], [5,2,6]]) >>> np.apply_along_axis(sorted, 1, b) array([[1, 7, 8],

[3, 4, 9],
[2, 5, 6]])

For a function that returns a higher dimensional array, those dimensions are inserted in place of the `axis` dimension.

>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]]) >>> np.apply_along_axis(np.diag, -1, b) array([[[1, 0, 0],

 [0, 2, 0],
 [0, 0, 3]],
[[4, 0, 0],
 [0, 5, 0],
 [0, 0, 6]],
[[7, 0, 0],
 [0, 8, 0],
 [0, 0, 9]]])

func ApplyOverAxes ¶

func ApplyOverAxes(func_ *py.Object, a *py.Object, axes *py.Object) *py.Object

Apply a function repeatedly over multiple axes.

`func` is called as `res = func(a, axis)`, where `axis` is the first element of `axes`. The result `res` of the function call must have either the same dimensions as `a` or one less dimension. If `res` has one less dimension than `a`, a dimension is inserted before `axis`. The call to `func` is then repeated for each axis in `axes`, with `res` as the first argument.

Parameters ---------- func : function

This function must take two arguments, `func(a, axis)`.

a : array_like

Input array.

axes : array_like

Axes over which `func` is applied; the elements must be integers.

Returns ------- apply_over_axis : ndarray

The output array.  The number of dimensions is the same as `a`,
but the shape can be different.  This depends on whether `func`
changes the shape of its output with respect to its input.

See Also -------- apply_along_axis :

Apply a function to 1-D slices of an array along the given axis.

Notes ----- This function is equivalent to tuple axis arguments to reorderable ufuncs with keepdims=True. Tuple axis arguments to ufuncs have been available since version 1.7.0.

Examples -------- >>> a = np.arange(24).reshape(2,3,4) >>> a array([[[ 0, 1, 2, 3],

 [ 4,  5,  6,  7],
 [ 8,  9, 10, 11]],
[[12, 13, 14, 15],
 [16, 17, 18, 19],
 [20, 21, 22, 23]]])

Sum over axes 0 and 2. The result has same number of dimensions as the original array:

>>> np.apply_over_axes(np.sum, a, [0,2]) array([[[ 60],

[ 92],
[124]]])

Tuple axis arguments to ufuncs are equivalent:

>>> np.sum(a, axis=(0,2), keepdims=True) array([[[ 60],

[ 92],
[124]]])

func Arange ¶

func Arange(start *py.Object, stop *py.Object, step *py.Object, dtype *py.Object) *py.Object

arange([start,] stop[, step,], dtype=None, *, like=None)

Return evenly spaced values within a given interval.

``arange`` can be called with a varying number of positional arguments:

* ``arange(stop)``: Values are generated within the half-open interval
  ``[0, stop)`` (in other words, the interval including `start` but
  excluding `stop`).
* ``arange(start, stop)``: Values are generated within the half-open
  interval ``[start, stop)``.
* ``arange(start, stop, step)`` Values are generated within the half-open
  interval ``[start, stop)``, with spacing between values given by
  ``step``.

For integer arguments the function is roughly equivalent to the Python
built-in :py:class:`range`, but returns an ndarray rather than a ``range``
instance.

When using a non-integer step, such as 0.1, it is often better to use
`numpy.linspace`.

See the Warning sections below for more information.

Parameters
----------
start : integer or real, optional
    Start of interval.  The interval includes this value.  The default
    start value is 0.
stop : integer or real
    End of interval.  The interval does not include this value, except
    in some cases where `step` is not an integer and floating point
    round-off affects the length of `out`.
step : integer or real, optional
    Spacing between values.  For any output `out`, this is the distance
    between two adjacent values, ``out[i+1] - out[i]``.  The default
    step size is 1.  If `step` is specified as a position argument,
    `start` must also be given.
dtype : dtype, optional
    The type of the output array.  If `dtype` is not given, infer the data
    type from the other input arguments.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
arange : ndarray
    Array of evenly spaced values.

    For floating point arguments, the length of the result is
    ``ceil((stop - start)/step)``.  Because of floating point overflow,
    this rule may result in the last element of `out` being greater
    than `stop`.

Warnings
--------
The length of the output might not be numerically stable.

Another stability issue is due to the internal implementation of
`numpy.arange`.
The actual step value used to populate the array is
``dtype(start + step) - dtype(start)`` and not `step`. Precision loss
can occur here, due to casting or due to using floating points when
`start` is much larger than `step`. This can lead to unexpected
behaviour. For example::

  >>> np.arange(0, 5, 0.5, dtype=int)
  array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
  >>> np.arange(-3, 3, 0.5, dtype=int)
  array([-3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7,  8])

In such cases, the use of `numpy.linspace` should be preferred.

The built-in :py:class:`range` generates :std:doc:`Python built-in integers
that have arbitrary size <python:c-api/long>`, while `numpy.arange`
produces `numpy.int32` or `numpy.int64` numbers. This may result in
incorrect results for large integer values::

  >>> power = 40
  >>> modulo = 10000
  >>> x1 = [(n ** power) % modulo for n in range(8)]
  >>> x2 = [(n ** power) % modulo for n in np.arange(8)]
  >>> print(x1)
  [0, 1, 7776, 8801, 6176, 625, 6576, 4001]  # correct
  >>> print(x2)
  [0, 1, 7776, 7185, 0, 5969, 4816, 3361]  # incorrect

See Also
--------
numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
:ref:`how-to-partition`

Examples
--------
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0.,  1.,  2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])

func Arccos ¶

func Arccos(x *py.Object, out *py.Object) *py.Object

arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Trigonometric inverse cosine, element-wise.

The inverse of `cos` so that, if “y = cos(x)“, then “x = arccos(y)“.

Parameters ---------- x : array_like

`x`-coordinate on the unit circle.
For real arguments, the domain is [-1, 1].

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

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 ------- angle : ndarray

The angle of the ray intersecting the unit circle at the given
`x`-coordinate in radians [0, pi].
This is a scalar if `x` is a scalar.

See Also -------- cos, arctan, arcsin, emath.arccos

Notes ----- `arccos` is a multivalued function: for each `x` there are infinitely many numbers `z` such that “cos(z) = x“. The convention is to return the angle `z` whose real part lies in `[0, pi]`.

For real-valued input data types, `arccos` 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, `arccos` is a complex analytic function that has branch cuts “[-inf, -1]“ and `[1, inf]` and is continuous from above on the former and from below on the latter.

The inverse `cos` is also known as `acos` or cos^-1.

References ---------- M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions", 10th printing, 1964, pp. 79. https://personal.math.ubc.ca/~cbm/aands/page_79.htm

Examples -------- We expect the arccos of 1 to be 0, and of -1 to be pi:

>>> np.arccos([1, -1]) array([ 0. , 3.14159265])

Plot arccos:

>>> import matplotlib.pyplot as plt >>> x = np.linspace(-1, 1, num=100) >>> plt.plot(x, np.arccos(x)) >>> plt.axis('tight') >>> plt.show()

func Arccosh ¶

func Arccosh(x *py.Object, out *py.Object) *py.Object

arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Inverse hyperbolic cosine, element-wise.

Parameters ---------- x : array_like

Input array.

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

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 ------- arccosh : ndarray

Array of the same shape as `x`.
This is a scalar if `x` is a scalar.

See Also --------

cosh, arcsinh, sinh, arctanh, tanh

Notes ----- `arccosh` is a multivalued function: for each `x` there are infinitely many numbers `z` such that `cosh(z) = x`. The convention is to return the `z` whose imaginary part lies in “[-pi, pi]“ and the real part in “[0, inf]“.

For real-valued input data types, `arccosh` 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, `arccosh` is a complex analytical function that has a branch cut `[-inf, 1]` and is continuous from above on it.

References ---------- .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",

10th printing, 1964, pp. 86.
https://personal.math.ubc.ca/~cbm/aands/page_86.htm

.. [2] Wikipedia, "Inverse hyperbolic function",

https://en.wikipedia.org/wiki/Arccosh

Examples -------- >>> np.arccosh([np.e, 10.0]) array([ 1.65745445, 2.99322285]) >>> np.arccosh(1) 0.0

func Arcsin ¶

func Arcsin(x *py.Object, out *py.Object) *py.Object

arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Inverse sine, element-wise.

Parameters ---------- x : array_like

`y`-coordinate on the unit circle.

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

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 ------- angle : ndarray

The inverse sine of each element in `x`, in radians and in the
closed interval ``[-pi/2, pi/2]``.
This is a scalar if `x` is a scalar.

See Also -------- sin, cos, arccos, tan, arctan, arctan2, emath.arcsin

Notes ----- `arcsin` is a multivalued function: for each `x` there are infinitely many numbers `z` such that :math:`sin(z) = x`. The convention is to return the angle `z` whose real part lies in [-pi/2, pi/2].

For real-valued input data types, *arcsin* 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, `arcsin` is a complex analytic function that has, by convention, the branch cuts [-inf, -1] and [1, inf] and is continuous from above on the former and from below on the latter.

The inverse sine is also known as `asin` or sin^{-1}.

References ---------- Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, 10th printing, New York: Dover, 1964, pp. 79ff. https://personal.math.ubc.ca/~cbm/aands/page_79.htm

Examples -------- >>> np.arcsin(1) # pi/2 1.5707963267948966 >>> np.arcsin(-1) # -pi/2 -1.5707963267948966 >>> np.arcsin(0) 0.0

func Arcsinh ¶

func Arcsinh(x *py.Object, out *py.Object) *py.Object

arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Inverse hyperbolic sine element-wise.

Parameters ---------- x : array_like

Input array.

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

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 ------- out : ndarray or scalar

Array of the same shape as `x`.
This is a scalar if `x` is a scalar.

Notes ----- `arcsinh` is a multivalued function: for each `x` there are infinitely many numbers `z` such that `sinh(z) = x`. The convention is to return the `z` whose imaginary part lies in `[-pi/2, pi/2]`.

For real-valued input data types, `arcsinh` always returns real output. For each value that cannot be expressed as a real number or infinity, it returns “nan“ and sets the `invalid` floating point error flag.

For complex-valued input, `arccos` is a complex analytical function that has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from the right on the former and from the left on the latter.

The inverse hyperbolic sine is also known as `asinh` or “sinh^-1“.

References ---------- .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",

10th printing, 1964, pp. 86.
https://personal.math.ubc.ca/~cbm/aands/page_86.htm

.. [2] Wikipedia, "Inverse hyperbolic function",

https://en.wikipedia.org/wiki/Arcsinh

Examples -------- >>> np.arcsinh(np.array([np.e, 10.0])) array([ 1.72538256, 2.99822295])

func Arctan ¶

func Arctan(x *py.Object, out *py.Object) *py.Object

arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Trigonometric inverse tangent, element-wise.

The inverse of tan, so that if “y = tan(x)“ then “x = arctan(y)“.

Parameters ---------- x : array_like 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

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 ------- out : ndarray or scalar

Out has the same shape as `x`.  Its real part is in
``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``).
This is a scalar if `x` is a scalar.

See Also -------- arctan2 : The "four quadrant" arctan of the angle formed by (`x`, `y`)

and the positive `x`-axis.

angle : Argument of complex values.

Notes ----- `arctan` is a multi-valued function: for each `x` there are infinitely many numbers `z` such that tan(`z`) = `x`. The convention is to return the angle `z` whose real part lies in [-pi/2, pi/2].

For real-valued input data types, `arctan` 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, `arctan` is a complex analytic function that has [“1j, infj“] and [“-1j, -infj“] as branch cuts, and is continuous from the left on the former and from the right on the latter.

The inverse tangent is also known as `atan` or tan^{-1}.

References ---------- Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*, 10th printing, New York: Dover, 1964, pp. 79. https://personal.math.ubc.ca/~cbm/aands/page_79.htm

Examples -------- We expect the arctan of 0 to be 0, and of 1 to be pi/4:

>>> np.arctan([0, 1]) array([ 0. , 0.78539816])

>>> np.pi/4 0.78539816339744828

Plot arctan:

>>> import matplotlib.pyplot as plt >>> x = np.linspace(-10, 10) >>> plt.plot(x, np.arctan(x)) >>> plt.axis('tight') >>> plt.show()

func Arctan2 ¶

func Arctan2(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Element-wise arc tangent of “x1/x2“ choosing the quadrant correctly.

The quadrant (i.e., branch) is chosen so that “arctan2(x1, x2)“ is the signed angle in radians between the ray ending at the origin and passing through the point (1,0), and the ray ending at the origin and passing through the point (`x2`, `x1`). (Note the role reversal: the "`y`-coordinate" is the first function parameter, the "`x`-coordinate" is the second.) By IEEE convention, this function is defined for `x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see Notes for specific values).

This function is not defined for complex-valued arguments; for the so-called argument of complex values, use `angle`.

Parameters ---------- x1 : array_like, real-valued

`y`-coordinates.

x2 : array_like, real-valued

`x`-coordinates.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- angle : ndarray

Array of angles in radians, in the range ``[-pi, pi]``.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- arctan, tan, angle

Notes ----- *arctan2* is identical to the `atan2` function of the underlying C library. The following special values are defined in the C standard: [1]_

====== ====== ================ `x1` `x2` `arctan2(x1,x2)` ====== ====== ================ +/- 0 +0 +/- 0 +/- 0 -0 +/- pi

> 0   +/-inf +0 / +pi
< 0   +/-inf -0 / -pi

+/-inf +inf +/- (pi/4) +/-inf -inf +/- (3*pi/4) ====== ====== ================

Note that +0 and -0 are distinct floating point numbers, as are +inf and -inf.

References ---------- .. [1] ISO/IEC standard 9899:1999, "Programming language C."

Examples -------- Consider four points in different quadrants:

>>> x = np.array([-1, +1, +1, -1]) >>> y = np.array([-1, -1, +1, +1]) >>> np.arctan2(y, x) * 180 / np.pi array([-135., -45., 45., 135.])

Note the order of the parameters. `arctan2` is defined also when `x2` = 0 and at several other special points, obtaining values in the range “[-pi, pi]“:

>>> np.arctan2([1., -1.], [0., 0.]) array([ 1.57079633, -1.57079633]) >>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) array([0. , 3.14159265, 0.78539816])

func Arctanh ¶

func Arctanh(x *py.Object, out *py.Object) *py.Object

arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Inverse hyperbolic tangent element-wise.

Parameters ---------- x : array_like

Input array.

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

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 ------- out : ndarray or scalar

Array of the same shape as `x`.
This is a scalar if `x` is a scalar.

See Also -------- emath.arctanh

Notes ----- `arctanh` is a multivalued function: for each `x` there are infinitely many numbers `z` such that “tanh(z) = x“. The convention is to return the `z` whose imaginary part lies in `[-pi/2, pi/2]`.

For real-valued input data types, `arctanh` 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, `arctanh` is a complex analytical function that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from above on the former and from below on the latter.

The inverse hyperbolic tangent is also known as `atanh` or “tanh^-1“.

References ---------- .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",

10th printing, 1964, pp. 86.
https://personal.math.ubc.ca/~cbm/aands/page_86.htm

.. [2] Wikipedia, "Inverse hyperbolic function",

https://en.wikipedia.org/wiki/Arctanh

Examples -------- >>> np.arctanh([0, -0.5]) array([ 0. , -0.54930614])

func Argmax ¶

func Argmax(a *py.Object, axis *py.Object, out *py.Object) *py.Object

Returns the indices of the maximum values along an axis.

Parameters ---------- a : array_like

Input array.

axis : int, optional

By default, the index is into the flattened array, otherwise
along the specified axis.

out : array, optional

If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype.

keepdims : bool, optional

If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the array.

.. versionadded:: 1.22.0

Returns ------- index_array : ndarray of ints

Array of indices into the array. It has the same shape as `a.shape`
with the dimension along `axis` removed. If `keepdims` is set to True,
then the size of `axis` will be 1 with the resulting array having same
shape as `a.shape`.

See Also -------- ndarray.argmax, argmin amax : The maximum value along a given axis. unravel_index : Convert a flat index into an index tuple. take_along_axis : Apply “np.expand_dims(index_array, axis)“

from argmax to an array as if by calling max.

Notes ----- In case of multiple occurrences of the maximum values, the indices corresponding to the first occurrence are returned.

Examples -------- >>> a = np.arange(6).reshape(2,3) + 10 >>> a array([[10, 11, 12],

[13, 14, 15]])

>>> np.argmax(a) 5 >>> np.argmax(a, axis=0) array([1, 1, 1]) >>> np.argmax(a, axis=1) array([2, 2])

Indexes of the maximal elements of a N-dimensional array:

>>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape) >>> ind (1, 2) >>> a[ind] 15

>>> b = np.arange(6) >>> b[1] = 5 >>> b array([0, 5, 2, 3, 4, 5]) >>> np.argmax(b) # Only the first occurrence is returned. 1

>>> x = np.array([[4,2,3], [1,0,3]]) >>> index_array = np.argmax(x, axis=-1) >>> # Same as np.amax(x, axis=-1, keepdims=True) >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) array([[4],

[3]])

>>> # Same as np.amax(x, axis=-1) >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) array([4, 3])

Setting `keepdims` to `True`,

>>> x = np.arange(24).reshape((2, 3, 4)) >>> res = np.argmax(x, axis=1, keepdims=True) >>> res.shape (2, 1, 4)

func Argmin ¶

func Argmin(a *py.Object, axis *py.Object, out *py.Object) *py.Object

Returns the indices of the minimum values along an axis.

Parameters ---------- a : array_like

Input array.

axis : int, optional

By default, the index is into the flattened array, otherwise
along the specified axis.

out : array, optional

If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype.

keepdims : bool, optional

If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the array.

.. versionadded:: 1.22.0

Returns ------- index_array : ndarray of ints

Array of indices into the array. It has the same shape as `a.shape`
with the dimension along `axis` removed. If `keepdims` is set to True,
then the size of `axis` will be 1 with the resulting array having same
shape as `a.shape`.

See Also -------- ndarray.argmin, argmax amin : The minimum value along a given axis. unravel_index : Convert a flat index into an index tuple. take_along_axis : Apply “np.expand_dims(index_array, axis)“

from argmin to an array as if by calling min.

Notes ----- In case of multiple occurrences of the minimum values, the indices corresponding to the first occurrence are returned.

Examples -------- >>> a = np.arange(6).reshape(2,3) + 10 >>> a array([[10, 11, 12],

[13, 14, 15]])

>>> np.argmin(a) 0 >>> np.argmin(a, axis=0) array([0, 0, 0]) >>> np.argmin(a, axis=1) array([0, 0])

Indices of the minimum elements of a N-dimensional array:

>>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape) >>> ind (0, 0) >>> a[ind] 10

>>> b = np.arange(6) + 10 >>> b[4] = 10 >>> b array([10, 11, 12, 13, 10, 15]) >>> np.argmin(b) # Only the first occurrence is returned. 0

>>> x = np.array([[4,2,3], [1,0,3]]) >>> index_array = np.argmin(x, axis=-1) >>> # Same as np.amin(x, axis=-1, keepdims=True) >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) array([[2],

[0]])

>>> # Same as np.amax(x, axis=-1) >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) array([2, 0])

Setting `keepdims` to `True`,

>>> x = np.arange(24).reshape((2, 3, 4)) >>> res = np.argmin(x, axis=1, keepdims=True) >>> res.shape (2, 1, 4)

func Argpartition ¶

func Argpartition(a *py.Object, kth *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object

Perform an indirect partition along the given axis using the algorithm specified by the `kind` keyword. It returns an array of indices of the same shape as `a` that index data along the given axis in partitioned order.

.. versionadded:: 1.8.0

Parameters ---------- a : array_like

Array to sort.

kth : int or sequence of ints

Element index to partition by. The k-th element will be in its
final sorted position and all smaller elements will be moved
before it and all larger elements behind it. The order of all
elements in the partitions is undefined. If provided with a
sequence of k-th it will partition all of them into their sorted
position at once.

.. deprecated:: 1.22.0
    Passing booleans as index is deprecated.

axis : int or None, optional

Axis along which to sort. The default is -1 (the last axis). If
None, the flattened array is used.

kind : {'introselect'}, optional

Selection algorithm. Default is 'introselect'

order : str or list of str, optional

When `a` is an array with fields defined, this argument
specifies which fields to compare first, second, etc. A single
field can be specified as a string, and not all fields need be
specified, but unspecified fields will still be used, in the
order in which they come up in the dtype, to break ties.

Returns ------- index_array : ndarray, int

Array of indices that partition `a` along the specified axis.
If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`.
More generally, ``np.take_along_axis(a, index_array, axis=axis)``
always yields the partitioned `a`, irrespective of dimensionality.

See Also -------- partition : Describes partition algorithms used. ndarray.partition : Inplace partition. argsort : Full indirect sort. take_along_axis : Apply “index_array“ from argpartition

to an array as if by calling partition.

Notes ----- See `partition` for notes on the different selection algorithms.

Examples -------- One dimensional array:

>>> x = np.array([3, 4, 2, 1]) >>> x[np.argpartition(x, 3)] array([2, 1, 3, 4]) >>> x[np.argpartition(x, (1, 3))] array([1, 2, 3, 4])

>>> x = [3, 4, 2, 1] >>> np.array(x)[np.argpartition(x, 3)] array([2, 1, 3, 4])

Multi-dimensional array:

>>> x = np.array([[3, 4, 2], [1, 3, 1]]) >>> index_array = np.argpartition(x, kth=1, axis=-1) >>> np.take_along_axis(x, index_array, axis=-1) # same as np.partition(x, kth=1) array([[2, 3, 4],

[1, 1, 3]])

func Argsort ¶

func Argsort(a *py.Object, axis *py.Object, kind *py.Object, order *py.Object) *py.Object

Returns the indices that would sort an array.

Perform an indirect sort along the given axis using the algorithm specified by the `kind` keyword. It returns an array of indices of the same shape as `a` that index data along the given axis in sorted order.

Parameters ---------- a : array_like

Array to sort.

axis : int or None, optional

Axis along which to sort.  The default is -1 (the last axis). If None,
the flattened array is used.

kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional

Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
and 'mergesort' use timsort under the covers and, in general, the
actual implementation will vary with data type. The 'mergesort' option
is retained for backwards compatibility.

.. versionchanged:: 1.15.0.
   The 'stable' option was added.

order : str or list of str, optional

When `a` is an array with fields defined, this argument specifies
which fields to compare first, second, etc.  A single field can
be specified as a string, and not all fields need be specified,
but unspecified fields will still be used, in the order in which
they come up in the dtype, to break ties.

Returns ------- index_array : ndarray, int

Array of indices that sort `a` along the specified `axis`.
If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
More generally, ``np.take_along_axis(a, index_array, axis=axis)``
always yields the sorted `a`, irrespective of dimensionality.

See Also -------- sort : Describes sorting algorithms used. lexsort : Indirect stable sort with multiple keys. ndarray.sort : Inplace sort. argpartition : Indirect partial sort. take_along_axis : Apply “index_array“ from argsort

to an array as if by calling sort.

Notes ----- See `sort` for notes on the different sorting algorithms.

As of NumPy 1.4.0 `argsort` works with real/complex arrays containing nan values. The enhanced sort order is documented in `sort`.

Examples -------- One dimensional array:

>>> x = np.array([3, 1, 2]) >>> np.argsort(x) array([1, 2, 0])

Two-dimensional array:

>>> x = np.array([[0, 3], [2, 2]]) >>> x array([[0, 3],

[2, 2]])

>>> ind = np.argsort(x, axis=0) # sorts along first axis (down) >>> ind array([[0, 1],

[1, 0]])

>>> np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0) array([[0, 2],

[2, 3]])

>>> ind = np.argsort(x, axis=1) # sorts along last axis (across) >>> ind array([[0, 1],

[0, 1]])

>>> np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1) array([[0, 3],

[2, 2]])

Indices of the sorted elements of a N-dimensional array:

>>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape) >>> ind (array([0, 1, 1, 0]), array([0, 0, 1, 1])) >>> x[ind] # same as np.sort(x, axis=None) array([0, 2, 2, 3])

Sorting with keys:

>>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')]) >>> x array([(1, 0), (0, 1)],

dtype=[('x', '<i4'), ('y', '<i4')])

>>> np.argsort(x, order=('x','y')) array([1, 0])

>>> np.argsort(x, order=('y','x')) array([0, 1])

func Argwhere ¶

func Argwhere(a *py.Object) *py.Object

Find the indices of array elements that are non-zero, grouped by element.

Parameters ---------- a : array_like

Input data.

Returns ------- index_array : (N, a.ndim) ndarray

Indices of elements that are non-zero. Indices are grouped by element.
This array will have shape ``(N, a.ndim)`` where ``N`` is the number of
non-zero items.

See Also -------- where, nonzero

Notes ----- “np.argwhere(a)“ is almost the same as “np.transpose(np.nonzero(a))“, but produces a result of the correct shape for a 0D array.

The output of “argwhere“ is not suitable for indexing arrays. For this purpose use “nonzero(a)“ instead.

Examples -------- >>> x = np.arange(6).reshape(2,3) >>> x array([[0, 1, 2],

[3, 4, 5]])

>>> np.argwhere(x>1) array([[0, 2],

[1, 0],
[1, 1],
[1, 2]])

func Around ¶

func Around(a *py.Object, decimals *py.Object, out *py.Object) *py.Object

Round an array to the given number of decimals.

`around` is an alias of `~numpy.round`.

See Also -------- ndarray.round : equivalent method round : alias for this function ceil, fix, floor, rint, trunc

func Array ¶

func Array(object *py.Object, dtype *py.Object) *py.Object

array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,

      like=None)

Create an array.

Parameters
----------
object : array_like
    An array, any object exposing the array interface, an object whose
    ``__array__`` method returns an array, or any (nested) sequence.
    If object is a scalar, a 0-dimensional array containing object is
    returned.
dtype : data-type, optional
    The desired data-type for the array. If not given, NumPy will try to use
    a default ``dtype`` that can represent the values (by applying promotion
    rules when necessary.)
copy : bool, optional
    If true (default), then the object is copied.  Otherwise, a copy will
    only be made if ``__array__`` returns a copy, if obj is a nested
    sequence, or if a copy is needed to satisfy any of the other
    requirements (``dtype``, ``order``, etc.).
order : {'K', 'A', 'C', 'F'}, optional
    Specify the memory layout of the array. If object is not an array, the
    newly created array will be in C order (row major) unless 'F' is
    specified, in which case it will be in Fortran order (column major).
    If object is an array the following holds.

    ===== ========= ===================================================
    order  no copy                     copy=True
    ===== ========= ===================================================
    'K'   unchanged F & C order preserved, otherwise most similar order
    'A'   unchanged F order if input is F and not C, otherwise C order
    'C'   C order   C order
    'F'   F order   F order
    ===== ========= ===================================================

    When ``copy=False`` and a copy is made for other reasons, the result is
    the same as if ``copy=True``, with some exceptions for 'A', see the
    Notes section. The default order is 'K'.
subok : bool, optional
    If True, then sub-classes will be passed-through, otherwise
    the returned array will be forced to be a base-class array (default).
ndmin : int, optional
    Specifies the minimum number of dimensions that the resulting
    array should have.  Ones will be prepended to the shape as
    needed to meet this requirement.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray
    An array object satisfying the specified requirements.

See Also
--------
empty_like : Return an empty array with shape and type of input.
ones_like : Return an array of ones with shape and type of input.
zeros_like : Return an array of zeros with shape and type of input.
full_like : Return a new array with shape of input filled with value.
empty : Return a new uninitialized array.
ones : Return a new array setting values to one.
zeros : Return a new array setting values to zero.
full : Return a new array of given shape filled with value.

Notes
-----
When order is 'A' and ``object`` is an array in neither 'C' nor 'F' order,
and a copy is forced by a change in dtype, then the order of the result is
not necessarily 'C' as expected. This is likely a bug.

Examples
--------
>>> np.array([1, 2, 3])
array([1, 2, 3])

Upcasting:

>>> np.array([1, 2, 3.0])
array([ 1.,  2.,  3.])

More than one dimension:

>>> np.array([[1, 2], [3, 4]])
array([[1, 2],
       [3, 4]])

Minimum dimensions 2:

>>> np.array([1, 2, 3], ndmin=2)
array([[1, 2, 3]])

Type provided:

>>> np.array([1, 2, 3], dtype=complex)
array([ 1.+0.j,  2.+0.j,  3.+0.j])

Data-type consisting of more than one element:

>>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
>>> x['a']
array([1, 3])

Creating an array from sub-classes:

>>> np.array(np.mat('1 2; 3 4'))
array([[1, 2],
       [3, 4]])

>>> np.array(np.mat('1 2; 3 4'), subok=True)
matrix([[1, 2],
        [3, 4]])

func Array2string ¶

func Array2string(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object, separator *py.Object, prefix *py.Object, style *py.Object, formatter *py.Object, threshold *py.Object, edgeitems *py.Object, sign *py.Object, floatmode *py.Object, suffix *py.Object) *py.Object

Return a string representation of an array.

Parameters ---------- a : ndarray

Input array.

max_line_width : int, optional

Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.

precision : int or None, optional

Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.

suppress_small : bool, optional

Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
Defaults to ``numpy.get_printoptions()['suppress']``.

separator : str, optional

Inserted between elements.

prefix : str, optional suffix : str, optional

The length of the prefix and suffix strings are used to respectively
align and wrap the output. An array is typically printed as::

  prefix + array2string(a) + suffix

The output is left-padded by the length of the prefix string, and
wrapping is forced at the column ``max_line_width - len(suffix)``.
It should be noted that the content of prefix and suffix strings are
not included in the output.

style : _NoValue, optional

Has no effect, do not use.

.. deprecated:: 1.14.0

formatter : dict of callables, optional

If not None, the keys should indicate the type(s) that the respective
formatting function applies to.  Callables should return a string.
Types that are not specified (by their corresponding keys) are handled
by the default formatters.  Individual types for which a formatter
can be set are:

- 'bool'
- 'int'
- 'timedelta' : a `numpy.timedelta64`
- 'datetime' : a `numpy.datetime64`
- 'float'
- 'longfloat' : 128-bit floats
- 'complexfloat'
- 'longcomplexfloat' : composed of two 128-bit floats
- 'void' : type `numpy.void`
- 'numpystr' : types `numpy.bytes_` and `numpy.str_`

Other keys that can be used to set a group of types at once are:

- 'all' : sets all types
- 'int_kind' : sets 'int'
- 'float_kind' : sets 'float' and 'longfloat'
- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
- 'str_kind' : sets 'numpystr'

threshold : int, optional

Total number of array elements which trigger summarization
rather than full repr.
Defaults to ``numpy.get_printoptions()['threshold']``.

edgeitems : int, optional

Number of array items in summary at beginning and end of
each dimension.
Defaults to ``numpy.get_printoptions()['edgeitems']``.

sign : string, either '-', '+', or ' ', optional

Controls printing of the sign of floating-point types. If '+', always
print the sign of positive values. If ' ', always prints a space
(whitespace character) in the sign position of positive values.  If
'-', omit the sign character of positive values.
Defaults to ``numpy.get_printoptions()['sign']``.

floatmode : str, optional

Controls the interpretation of the `precision` option for
floating-point types.
Defaults to ``numpy.get_printoptions()['floatmode']``.
Can take the following values:

- 'fixed': Always print exactly `precision` fractional digits,
  even if this would print more or fewer digits than
  necessary to specify the value uniquely.
- 'unique': Print the minimum number of fractional digits necessary
  to represent each value uniquely. Different elements may
  have a different number of digits.  The value of the
  `precision` option is ignored.
- 'maxprec': Print at most `precision` fractional digits, but if
  an element can be uniquely represented with fewer digits
  only print it with that many.
- 'maxprec_equal': Print at most `precision` fractional digits,
  but if every element in the array can be uniquely
  represented with an equal number of fewer digits, use that
  many digits for all elements.

legacy : string or `False`, optional

If set to the string `'1.13'` enables 1.13 legacy printing mode. This
approximates numpy 1.13 print output by including a space in the sign
position of floats and different behavior for 0d arrays. If set to
`False`, disables legacy mode. Unrecognized strings will be ignored
with a warning for forward compatibility.

.. versionadded:: 1.14.0

Returns ------- array_str : str

String representation of the array.

Raises ------ TypeError

if a callable in `formatter` does not return a string.

See Also -------- array_str, array_repr, set_printoptions, get_printoptions

Notes ----- If a formatter is specified for a certain type, the `precision` keyword is ignored for that type.

This is a very flexible function; `array_repr` and `array_str` are using `array2string` internally so keywords with the same name should work identically in all three functions.

Examples -------- >>> x = np.array([1e-16,1,2,3]) >>> np.array2string(x, precision=2, separator=',', ... suppress_small=True) '[0.,1.,2.,3.]'

>>> x = np.arange(3.) >>> np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x}) '[0.00 1.00 2.00]'

>>> x = np.arange(3) >>> np.array2string(x, formatter={'int':lambda x: hex(x)}) '[0x0 0x1 0x2]'

func ArrayEqual ¶

func ArrayEqual(a1 *py.Object, a2 *py.Object, equalNan *py.Object) *py.Object

True if two arrays have the same shape and elements, False otherwise.

Parameters ---------- a1, a2 : array_like

Input arrays.

equal_nan : bool

Whether to compare NaN's as equal. If the dtype of a1 and a2 is
complex, values will be considered equal if either the real or the
imaginary component of a given value is ``nan``.

.. versionadded:: 1.19.0

Returns ------- b : bool

Returns True if the arrays are equal.

See Also -------- allclose: Returns True if two arrays are element-wise equal within a

tolerance.

array_equiv: Returns True if input arrays are shape consistent and all

elements equal.

Examples -------- >>> np.array_equal([1, 2], [1, 2]) True >>> np.array_equal(np.array([1, 2]), np.array([1, 2])) True >>> np.array_equal([1, 2], [1, 2, 3]) False >>> np.array_equal([1, 2], [1, 4]) False >>> a = np.array([1, np.nan]) >>> np.array_equal(a, a) False >>> np.array_equal(a, a, equal_nan=True) True

When “equal_nan“ is True, complex values with nan components are considered equal if either the real *or* the imaginary components are nan.

>>> a = np.array([1 + 1j]) >>> b = a.copy() >>> a.real = np.nan >>> b.imag = np.nan >>> np.array_equal(a, b, equal_nan=True) True

func ArrayEquiv ¶

func ArrayEquiv(a1 *py.Object, a2 *py.Object) *py.Object

Returns True if input arrays are shape consistent and all elements equal.

Shape consistent means they are either the same shape, or one input array can be broadcasted to create the same shape as the other one.

Parameters ---------- a1, a2 : array_like

Input arrays.

Returns ------- out : bool

True if equivalent, False otherwise.

Examples -------- >>> np.array_equiv([1, 2], [1, 2]) True >>> np.array_equiv([1, 2], [1, 3]) False

Showing the shape equivalence:

>>> np.array_equiv([1, 2], [[1, 2], [1, 2]]) True >>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]]) False

>>> np.array_equiv([1, 2], [[1, 2], [1, 3]]) False

func ArrayRepr ¶

func ArrayRepr(arr *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object) *py.Object

Return the string representation of an array.

Parameters ---------- arr : ndarray

Input array.

max_line_width : int, optional

Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.

precision : int, optional

Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.

suppress_small : bool, optional

Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
Defaults to ``numpy.get_printoptions()['suppress']``.

Returns ------- string : str

The string representation of an array.

See Also -------- array_str, array2string, set_printoptions

Examples -------- >>> np.array_repr(np.array([1,2])) 'array([1, 2])' >>> np.array_repr(np.ma.array([0.])) 'MaskedArray([0.])' >>> np.array_repr(np.array([], np.int32)) 'array([], dtype=int32)'

>>> x = np.array([1e-6, 4e-7, 2, 3]) >>> np.array_repr(x, precision=6, suppress_small=True) 'array([0.000001, 0. , 2. , 3. ])'

func ArraySplit ¶

func ArraySplit(ary *py.Object, indicesOrSections *py.Object, axis *py.Object) *py.Object

Split an array into multiple sub-arrays.

Please refer to the “split“ documentation. The only difference between these functions is that “array_split“ allows `indices_or_sections` to be an integer that does *not* equally divide the axis. For an array of length l that should be split into n sections, it returns l % n sub-arrays of size l//n + 1 and the rest of size l//n.

See Also -------- split : Split array into multiple sub-arrays of equal size.

Examples -------- >>> x = np.arange(8.0) >>> np.array_split(x, 3) [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])]

>>> x = np.arange(9) >>> np.array_split(x, 4) [array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]

func ArrayStr ¶

func ArrayStr(a *py.Object, maxLineWidth *py.Object, precision *py.Object, suppressSmall *py.Object) *py.Object

Return a string representation of the data in an array.

The data in the array is returned as a single string. This function is similar to `array_repr`, the difference being that `array_repr` also returns information on the kind of array and its data type.

Parameters ---------- a : ndarray

Input array.

max_line_width : int, optional

Inserts newlines if text is longer than `max_line_width`.
Defaults to ``numpy.get_printoptions()['linewidth']``.

precision : int, optional

Floating point precision.
Defaults to ``numpy.get_printoptions()['precision']``.

suppress_small : bool, optional

Represent numbers "very close" to zero as zero; default is False.
Very close is defined by precision: if the precision is 8, e.g.,
numbers smaller (in absolute value) than 5e-9 are represented as
zero.
Defaults to ``numpy.get_printoptions()['suppress']``.

See Also -------- array2string, array_repr, set_printoptions

Examples -------- >>> np.array_str(np.arange(3)) '[0 1 2]'

func Asanyarray ¶

func Asanyarray(a *py.Object, dtype *py.Object, order *py.Object) *py.Object

asanyarray(a, dtype=None, order=None, *, like=None)

Convert the input to an ndarray, but pass ndarray subclasses through.

Parameters
----------
a : array_like
    Input data, in any form that can be converted to an array.  This
    includes scalars, lists, lists of tuples, tuples, tuples of tuples,
    tuples of lists, and ndarrays.
dtype : data-type, optional
    By default, the data-type is inferred from the input data.
order : {'C', 'F', 'A', 'K'}, optional
    Memory layout.  'A' and 'K' depend on the order of input array a.
    'C' row-major (C-style),
    'F' column-major (Fortran-style) memory representation.
    'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
    'K' (keep) preserve input order
    Defaults to 'C'.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray or an ndarray subclass
    Array interpretation of `a`.  If `a` is an ndarray or a subclass
    of ndarray, it is returned as-is and no copy is performed.

See Also
--------
asarray : Similar function which always returns ndarrays.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
                 memory order.
asarray_chkfinite : Similar function which checks input for NaNs and
                    Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
               positions.

Examples
--------
Convert a list into an array:

>>> a = [1, 2]
>>> np.asanyarray(a)
array([1, 2])

Instances of `ndarray` subclasses are passed through as-is:

>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
>>> np.asanyarray(a) is a
True

func Asarray ¶

func Asarray(a *py.Object, dtype *py.Object, order *py.Object) *py.Object

asarray(a, dtype=None, order=None, *, like=None)

Convert the input to an array.

Parameters
----------
a : array_like
    Input data, in any form that can be converted to an array.  This
    includes lists, lists of tuples, tuples, tuples of tuples, tuples
    of lists and ndarrays.
dtype : data-type, optional
    By default, the data-type is inferred from the input data.
order : {'C', 'F', 'A', 'K'}, optional
    Memory layout.  'A' and 'K' depend on the order of input array a.
    'C' row-major (C-style),
    'F' column-major (Fortran-style) memory representation.
    'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
    'K' (keep) preserve input order
    Defaults to 'K'.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray
    Array interpretation of `a`.  No copy is performed if the input
    is already an ndarray with matching dtype and order.  If `a` is a
    subclass of ndarray, a base class ndarray is returned.

See Also
--------
asanyarray : Similar function which passes through subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
                 memory order.
asarray_chkfinite : Similar function which checks input for NaNs and Infs.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
               positions.

Examples
--------
Convert a list into an array:

>>> a = [1, 2]
>>> np.asarray(a)
array([1, 2])

Existing arrays are not copied:

>>> a = np.array([1, 2])
>>> np.asarray(a) is a
True

If `dtype` is set, array is copied only if dtype does not match:

>>> a = np.array([1, 2], dtype=np.float32)
>>> np.asarray(a, dtype=np.float32) is a
True
>>> np.asarray(a, dtype=np.float64) is a
False

Contrary to `asanyarray`, ndarray subclasses are not passed through:

>>> issubclass(np.recarray, np.ndarray)
True
>>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
>>> np.asarray(a) is a
False
>>> np.asanyarray(a) is a
True

func AsarrayChkfinite ¶

func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *py.Object) *py.Object

Convert the input to an array, checking for NaNs or Infs.

Parameters
----------
a : array_like
    Input data, in any form that can be converted to an array.  This
    includes lists, lists of tuples, tuples, tuples of tuples, tuples
    of lists and ndarrays.  Success requires no NaNs or Infs.
dtype : data-type, optional
    By default, the data-type is inferred from the input data.
order : {'C', 'F', 'A', 'K'}, optional
    Memory layout.  'A' and 'K' depend on the order of input array a.
    'C' row-major (C-style),
    'F' column-major (Fortran-style) memory representation.
    'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
    'K' (keep) preserve input order
    Defaults to 'C'.

Returns
-------
out : ndarray
    Array interpretation of `a`.  No copy is performed if the input
    is already an ndarray.  If `a` is a subclass of ndarray, a base
    class ndarray is returned.

Raises
------
ValueError
    Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).

See Also
--------
asarray : Create and array.
asanyarray : Similar function which passes through subclasses.
ascontiguousarray : Convert input to a contiguous array.
asfarray : Convert input to a floating point ndarray.
asfortranarray : Convert input to an ndarray with column-major
                 memory order.
fromiter : Create an array from an iterator.
fromfunction : Construct an array by executing a function on grid
               positions.

Examples
--------
Convert a list into an array.  If all elements are finite
``asarray_chkfinite`` is identical to ``asarray``.

>>> a = [1, 2]
>>> np.asarray_chkfinite(a, dtype=float)
array([1., 2.])

Raises ValueError if array_like contains Nans or Infs.

>>> a = [1, 2, np.inf]
>>> try:
...     np.asarray_chkfinite(a)
... except ValueError:
...     print('ValueError')
...
ValueError

func Ascontiguousarray ¶

func Ascontiguousarray(a *py.Object, dtype *py.Object) *py.Object

ascontiguousarray(a, dtype=None, *, like=None)

Return a contiguous array (ndim >= 1) in memory (C order).

Parameters
----------
a : array_like
    Input array.
dtype : str or dtype object, optional
    Data-type of returned array.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray
    Contiguous array of same shape and content as `a`, with type `dtype`
    if specified.

See Also
--------
asfortranarray : Convert input to an ndarray with column-major
                 memory order.
require : Return an ndarray that satisfies requirements.
ndarray.flags : Information about the memory layout of the array.

Examples
--------
Starting with a Fortran-contiguous array:

>>> x = np.ones((2, 3), order='F')
>>> x.flags['F_CONTIGUOUS']
True

Calling ``ascontiguousarray`` makes a C-contiguous copy:

>>> y = np.ascontiguousarray(x)
>>> y.flags['C_CONTIGUOUS']
True
>>> np.may_share_memory(x, y)
False

Now, starting with a C-contiguous array:

>>> x = np.ones((2, 3), order='C')
>>> x.flags['C_CONTIGUOUS']
True

Then, calling ``ascontiguousarray`` returns the same object:

>>> y = np.ascontiguousarray(x)
>>> x is y
True

Note: This function returns an array with at least one-dimension (1-d)
so it will not preserve 0-d arrays.

func Asfarray ¶

func Asfarray(a *py.Object, dtype *py.Object) *py.Object

Return an array converted to a float type.

Parameters ---------- a : array_like

The input array.

dtype : str or dtype object, optional

Float type code to coerce input array `a`.  If `dtype` is one of the
'int' dtypes, it is replaced with float64.

Returns ------- out : ndarray

The input `a` as a float ndarray.

Examples -------- >>> np.asfarray([2, 3]) array([2., 3.]) >>> np.asfarray([2, 3], dtype='float') array([2., 3.]) >>> np.asfarray([2, 3], dtype='int8') array([2., 3.])

func Asfortranarray ¶

func Asfortranarray(a *py.Object, dtype *py.Object) *py.Object

asfortranarray(a, dtype=None, *, like=None)

Return an array (ndim >= 1) laid out in Fortran order in memory.

Parameters
----------
a : array_like
    Input array.
dtype : str or dtype object, optional
    By default, the data-type is inferred from the input data.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray
    The input `a` in Fortran, or column-major, order.

See Also
--------
ascontiguousarray : Convert input to a contiguous (C order) array.
asanyarray : Convert input to an ndarray with either row or
    column-major memory order.
require : Return an ndarray that satisfies requirements.
ndarray.flags : Information about the memory layout of the array.

Examples
--------
Starting with a C-contiguous array:

>>> x = np.ones((2, 3), order='C')
>>> x.flags['C_CONTIGUOUS']
True

Calling ``asfortranarray`` makes a Fortran-contiguous copy:

>>> y = np.asfortranarray(x)
>>> y.flags['F_CONTIGUOUS']
True
>>> np.may_share_memory(x, y)
False

Now, starting with a Fortran-contiguous array:

>>> x = np.ones((2, 3), order='F')
>>> x.flags['F_CONTIGUOUS']
True

Then, calling ``asfortranarray`` returns the same object:

>>> y = np.asfortranarray(x)
>>> x is y
True

Note: This function returns an array with at least one-dimension (1-d)
so it will not preserve 0-d arrays.

func Asmatrix ¶

func Asmatrix(data *py.Object, dtype *py.Object) *py.Object

Interpret the input as a matrix.

Unlike `matrix`, `asmatrix` does not make a copy if the input is already a matrix or an ndarray. Equivalent to “matrix(data, copy=False)“.

Parameters ---------- data : array_like

Input data.

dtype : data-type

Data-type of the output matrix.

Returns ------- mat : matrix

`data` interpreted as a matrix.

Examples -------- >>> x = np.array([[1, 2], [3, 4]])

>>> m = np.asmatrix(x)

>>> x[0,0] = 5

>>> m matrix([[5, 2],

[3, 4]])

func Atleast1d ¶

func Atleast1d(__llgo_va_list ...interface{}) *py.Object

Convert inputs to arrays with at least one dimension.

Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.

Parameters ---------- arys1, arys2, ... : array_like

One or more input arrays.

Returns ------- ret : ndarray

An array, or list of arrays, each with ``a.ndim >= 1``.
Copies are made only if necessary.

See Also -------- atleast_2d, atleast_3d

Examples -------- >>> np.atleast_1d(1.0) array([1.])

>>> x = np.arange(9.0).reshape(3,3) >>> np.atleast_1d(x) array([[0., 1., 2.],

[3., 4., 5.],
[6., 7., 8.]])

>>> np.atleast_1d(x) is x True

>>> np.atleast_1d(1, [3, 4]) [array([1]), array([3, 4])]

func Atleast2d ¶

func Atleast2d(__llgo_va_list ...interface{}) *py.Object

View inputs as arrays with at least two dimensions.

Parameters ---------- arys1, arys2, ... : array_like

One or more array-like sequences.  Non-array inputs are converted
to arrays.  Arrays that already have two or more dimensions are
preserved.

Returns ------- res, res2, ... : ndarray

An array, or list of arrays, each with ``a.ndim >= 2``.
Copies are avoided where possible, and views with two or more
dimensions are returned.

See Also -------- atleast_1d, atleast_3d

Examples -------- >>> np.atleast_2d(3.0) array([[3.]])

>>> x = np.arange(3.0) >>> np.atleast_2d(x) array([[0., 1., 2.]]) >>> np.atleast_2d(x).base is x True

>>> np.atleast_2d(1, [1, 2], [[1, 2]]) [array([[1]]), array([[1, 2]]), array([[1, 2]])]

func Atleast3d ¶

func Atleast3d(__llgo_va_list ...interface{}) *py.Object

View inputs as arrays with at least three dimensions.

Parameters ---------- arys1, arys2, ... : array_like

One or more array-like sequences.  Non-array inputs are converted to
arrays.  Arrays that already have three or more dimensions are
preserved.

Returns ------- res1, res2, ... : ndarray

An array, or list of arrays, each with ``a.ndim >= 3``.  Copies are
avoided where possible, and views with three or more dimensions are
returned.  For example, a 1-D array of shape ``(N,)`` becomes a view
of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
view of shape ``(M, N, 1)``.

See Also -------- atleast_1d, atleast_2d

Examples -------- >>> np.atleast_3d(3.0) array([[[3.]]])

>>> x = np.arange(3.0) >>> np.atleast_3d(x).shape (1, 3, 1)

>>> x = np.arange(12.0).reshape(4,3) >>> np.atleast_3d(x).shape (4, 3, 1) >>> np.atleast_3d(x).base is x.base # x is a reshape, so not base itself True

>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]): ... print(arr, arr.shape) # doctest: +SKIP ... [[[1]

[2]]] (1, 2, 1)

[[[1]

[2]]] (1, 2, 1)

[[[1 2]]] (1, 1, 2)

func Average ¶

func Average(a *py.Object, axis *py.Object, weights *py.Object, returned *py.Object) *py.Object

Compute the weighted average along the specified axis.

Parameters ---------- a : array_like

Array containing data to be averaged. If `a` is not an array, a
conversion is attempted.

axis : None or int or tuple of ints, optional

Axis or axes along which to average `a`.  The default,
axis=None, will average over all of the elements of the input array.
If axis is negative it counts from the last to the first axis.

.. versionadded:: 1.7.0

If axis is a tuple of ints, averaging is performed on all of the axes
specified in the tuple instead of a single axis or all the axes as
before.

weights : array_like, optional

An array of weights associated with the values in `a`. Each value in
`a` contributes to the average according to its associated weight.
The weights array can either be 1-D (in which case its length must be
the size of `a` along the given axis) or of the same shape as `a`.
If `weights=None`, then all data in `a` are assumed to have a
weight equal to one.  The 1-D calculation is::

    avg = sum(a * weights) / sum(weights)

The only constraint on `weights` is that `sum(weights)` must not be 0.

returned : bool, optional

Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
is returned, otherwise only the average is returned.
If `weights=None`, `sum_of_weights` is equivalent to the number of
elements over which the average is taken.

keepdims : bool, optional

If this is set to True, the axes which are reduced are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the original `a`.
*Note:* `keepdims` will not work with instances of `numpy.matrix`
or other classes whose methods do not support `keepdims`.

.. versionadded:: 1.23.0

Returns ------- retval, [sum_of_weights] : array_type or double

Return the average along the specified axis. When `returned` is `True`,
return a tuple with the average as the first element and the sum
of the weights as the second element. `sum_of_weights` is of the
same type as `retval`. The result dtype follows a genereal pattern.
If `weights` is None, the result dtype will be that of `a` , or ``float64``
if `a` is integral. Otherwise, if `weights` is not None and `a` is non-
integral, the result type will be the type of lowest precision capable of
representing values of both `a` and `weights`. If `a` happens to be
integral, the previous rules still applies but the result dtype will
at least be ``float64``.

Raises ------ ZeroDivisionError

When all weights along axis are zero. See `numpy.ma.average` for a
version robust to this type of error.

TypeError

When the length of 1D `weights` is not the same as the shape of `a`
along axis.

See Also -------- mean

ma.average : average for masked arrays -- useful if your data contains

"missing" values

numpy.result_type : Returns the type that results from applying the

numpy type promotion rules to the arguments.

Examples -------- >>> data = np.arange(1, 5) >>> data array([1, 2, 3, 4]) >>> np.average(data) 2.5 >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1)) 4.0

>>> data = np.arange(6).reshape((3, 2)) >>> data array([[0, 1],

[2, 3],
[4, 5]])

>>> np.average(data, axis=1, weights=[1./4, 3./4]) array([0.75, 2.75, 4.75]) >>> np.average(data, weights=[1./4, 3./4]) Traceback (most recent call last):

...

TypeError: Axis must be specified when shapes of a and weights differ.

>>> a = np.ones(5, dtype=np.float128) >>> w = np.ones(5, dtype=np.complex64) >>> avg = np.average(a, weights=w) >>> print(avg.dtype) complex256

With “keepdims=True“, the following result has shape (3, 1).

>>> np.average(data, axis=1, keepdims=True) array([[0.5],

[2.5],
[4.5]])

func Bartlett ¶

func Bartlett(M *py.Object) *py.Object

Return the Bartlett window.

The Bartlett window is very similar to a triangular window, except that the end points are at zero. It is often used in signal processing for tapering a signal, without generating too much ripple in the frequency domain.

Parameters ---------- M : int

Number of points in the output window. If zero or less, an
empty array is returned.

Returns ------- out : array

The triangular window, with the maximum value normalized to one
(the value one appears only if the number of samples is odd), with
the first and last samples equal to zero.

See Also -------- blackman, hamming, hanning, kaiser

Notes ----- The Bartlett window is defined as

.. math:: w(n) = \frac{2}{M-1} \left(

\frac{M-1}{2} - \left|n - \frac{M-1}{2}\right|
\right)

Most references to the Bartlett window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. Note that convolution with this window produces linear interpolation. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. The Fourier transform of the Bartlett window is the product of two sinc functions. Note the excellent discussion in Kanasewich [2]_.

References ---------- .. [1] M.S. Bartlett, "Periodogram Analysis and Continuous Spectra",

Biometrika 37, 1-16, 1950.

.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",

The University of Alberta Press, 1975, pp. 109-110.

.. [3] A.V. Oppenheim and R.W. Schafer, "Discrete-Time Signal

Processing", Prentice-Hall, 1999, pp. 468-471.

.. [4] Wikipedia, "Window function",

https://en.wikipedia.org/wiki/Window_function

.. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,

"Numerical Recipes", Cambridge University Press, 1986, page 429.

Examples -------- >>> import matplotlib.pyplot as plt >>> np.bartlett(12) array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary

0.90909091,  0.90909091,  0.72727273,  0.54545455,  0.36363636,
0.18181818,  0.        ])

Plot the window and its frequency response (requires SciPy and matplotlib):

>>> from numpy.fft import fft, fftshift >>> window = np.bartlett(51) >>> plt.plot(window) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Bartlett window") Text(0.5, 1.0, 'Bartlett window') >>> plt.ylabel("Amplitude") Text(0, 0.5, 'Amplitude') >>> plt.xlabel("Sample") Text(0.5, 0, 'Sample') >>> plt.show()

>>> plt.figure() <Figure size 640x480 with 0 Axes> >>> A = fft(window, 2048) / 25.5 >>> mag = np.abs(fftshift(A)) >>> freq = np.linspace(-0.5, 0.5, len(A)) >>> with np.errstate(divide='ignore', invalid='ignore'): ... response = 20 * np.log10(mag) ... >>> response = np.clip(response, -100, 100) >>> plt.plot(freq, response) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Frequency response of Bartlett window") Text(0.5, 1.0, 'Frequency response of Bartlett window') >>> plt.ylabel("Magnitude [dB]") Text(0, 0.5, 'Magnitude [dB]') >>> plt.xlabel("Normalized frequency [cycles per sample]") Text(0.5, 0, 'Normalized frequency [cycles per sample]') >>> _ = plt.axis('tight') >>> plt.show()

func BaseRepr ¶

func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object

Return a string representation of a number in the given base system.

Parameters ---------- number : int

The value to convert. Positive and negative values are handled.

base : int, optional

Convert `number` to the `base` number system. The valid range is 2-36,
the default value is 2.

padding : int, optional

Number of zeros padded on the left. Default is 0 (no padding).

Returns ------- out : str

String representation of `number` in `base` system.

See Also -------- binary_repr : Faster version of `base_repr` for base 2.

Examples -------- >>> np.base_repr(5) '101' >>> np.base_repr(6, 5) '11' >>> np.base_repr(7, base=5, padding=3) '00012'

>>> np.base_repr(10, base=16) 'A' >>> np.base_repr(32, base=16) '20'

func BinaryRepr ¶

func BinaryRepr(num *py.Object, width *py.Object) *py.Object

Return the binary representation of the input number as a string.

For negative numbers, if width is not given, a minus sign is added to the front. If width is given, the two's complement of the number is returned, with respect to that width.

In a two's-complement system negative numbers are represented by the two's complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two's-complement system can represent every integer in the range :math:`-2^{N-1}` to :math:`+2^{N-1}-1`.

Parameters ---------- num : int

Only an integer decimal number can be used.

width : int, optional

The length of the returned string if `num` is positive, or the length
of the two's complement if `num` is negative, provided that `width` is
at least a sufficient number of bits for `num` to be represented in the
designated form.

If the `width` value is insufficient, it will be ignored, and `num` will
be returned in binary (`num` > 0) or two's complement (`num` < 0) form
with its width equal to the minimum number of bits needed to represent
the number in the designated form. This behavior is deprecated and will
later raise an error.

.. deprecated:: 1.12.0

Returns ------- bin : str

Binary representation of `num` or two's complement of `num`.

See Also -------- base_repr: Return a string representation of a number in the given base

system.

bin: Python's built-in binary representation generator of an integer.

Notes ----- `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x faster.

References ---------- .. [1] Wikipedia, "Two's complement",

https://en.wikipedia.org/wiki/Two's_complement

Examples -------- >>> np.binary_repr(3) '11' >>> np.binary_repr(-3) '-11' >>> np.binary_repr(3, width=4) '0011'

The two's complement is returned when the input number is negative and width is specified:

>>> np.binary_repr(-3, width=3) '101' >>> np.binary_repr(-3, width=5) '11101'

func Bincount ¶

func Bincount(x *py.Object, weights *py.Object, minlength *py.Object) *py.Object

bincount(x, /, weights=None, minlength=0)

Count number of occurrences of each value in array of non-negative ints.

The number of bins (of size 1) is one larger than the largest value in `x`. If `minlength` is specified, there will be at least this number of bins in the output array (though it will be longer if necessary, depending on the contents of `x`). Each bin gives the number of occurrences of its index value in `x`. If `weights` is specified the input array is weighted by it, i.e. if a value “n“ is found at position “i“, “out[n] += weight[i]“ instead of “out[n] += 1“.

Parameters ---------- x : array_like, 1 dimension, nonnegative ints

Input array.

weights : array_like, optional

Weights, array of the same shape as `x`.

minlength : int, optional

A minimum number of bins for the output array.

.. versionadded:: 1.6.0

Returns ------- out : ndarray of ints

The result of binning the input array.
The length of `out` is equal to ``np.amax(x)+1``.

Raises ------ ValueError

If the input is not 1-dimensional, or contains elements with negative
values, or if `minlength` is negative.

TypeError

If the type of the input is float or complex.

See Also -------- histogram, digitize, unique

Examples -------- >>> np.bincount(np.arange(5)) array([1, 1, 1, 1, 1]) >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7])) array([1, 3, 1, 1, 0, 0, 0, 1])

>>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23]) >>> np.bincount(x).size == np.amax(x)+1 True

The input array needs to be of integer dtype, otherwise a TypeError is raised:

>>> np.bincount(np.arange(5, dtype=float)) Traceback (most recent call last):

...

TypeError: Cannot cast array data from dtype('float64') to dtype('int64') according to the rule 'safe'

A possible use of “bincount“ is to perform sums over variable-size chunks of an array, using the “weights“ keyword.

>>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights >>> x = np.array([0, 1, 1, 2, 2, 2]) >>> np.bincount(x, weights=w) array([ 0.3, 0.7, 1.1])

func BitwiseAnd ¶

func BitwiseAnd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Compute the bit-wise AND of two arrays element-wise.

Computes the bit-wise AND of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator “&“.

Parameters ---------- x1, x2 : array_like

Only integer and boolean types are handled.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : ndarray or scalar

Result.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- logical_and bitwise_or bitwise_xor binary_repr :

Return the binary representation of the input number as a string.

Examples -------- The number 13 is represented by “00001101“. Likewise, 17 is represented by “00010001“. The bit-wise AND of 13 and 17 is therefore “000000001“, or 1:

>>> np.bitwise_and(13, 17) 1

>>> np.bitwise_and(14, 13) 12 >>> np.binary_repr(12) '1100' >>> np.bitwise_and([14,3], 13) array([12, 1])

>>> np.bitwise_and([11,7], [4,25]) array([0, 1]) >>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) array([ 2, 4, 16]) >>> np.bitwise_and([True, True], [False, True]) array([False, True])

The “&“ operator can be used as a shorthand for “np.bitwise_and“ on ndarrays.

>>> x1 = np.array([2, 5, 255]) >>> x2 = np.array([3, 14, 16]) >>> x1 & x2 array([ 2, 4, 16])

func BitwiseNot ¶

func BitwiseNot(__llgo_va_list ...interface{}) *py.Object

invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Compute bit-wise inversion, or bit-wise NOT, element-wise.

Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator “~“.

For signed integer inputs, the two's complement is returned. In a two's-complement system negative numbers are represented by the two's complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two's-complement system can represent every integer in the range :math:`-2^{N-1}` to :math:`+2^{N-1}-1`.

Parameters ---------- x : array_like

Only integer and boolean types are handled.

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

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 ------- out : ndarray or scalar

Result.
This is a scalar if `x` is a scalar.

See Also -------- bitwise_and, bitwise_or, bitwise_xor logical_not binary_repr :

Return the binary representation of the input number as a string.

Notes ----- `bitwise_not` is an alias for `invert`:

>>> np.bitwise_not is np.invert True

References ---------- .. [1] Wikipedia, "Two's complement",

https://en.wikipedia.org/wiki/Two's_complement

Examples -------- We've seen that 13 is represented by “00001101“. The invert or bit-wise NOT of 13 is then:

>>> x = np.invert(np.array(13, dtype=np.uint8)) >>> x 242 >>> np.binary_repr(x, width=8) '11110010'

The result depends on the bit-width:

>>> x = np.invert(np.array(13, dtype=np.uint16)) >>> x 65522 >>> np.binary_repr(x, width=16) '1111111111110010'

When using signed integer types the result is the two's complement of the result for the unsigned type:

>>> np.invert(np.array([13], dtype=np.int8)) array([-14], dtype=int8) >>> np.binary_repr(-14, width=8) '11110010'

Booleans are accepted as well:

>>> np.invert(np.array([True, False])) array([False, True])

The “~“ operator can be used as a shorthand for “np.invert“ on ndarrays.

>>> x1 = np.array([True, False]) >>> ~x1 array([False, True])

func BitwiseOr ¶

func BitwiseOr(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Compute the bit-wise OR of two arrays element-wise.

Computes the bit-wise OR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator “|“.

Parameters ---------- x1, x2 : array_like

Only integer and boolean types are handled.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : ndarray or scalar

Result.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- logical_or bitwise_and bitwise_xor binary_repr :

Return the binary representation of the input number as a string.

Examples -------- The number 13 has the binary representation “00001101“. Likewise, 16 is represented by “00010000“. The bit-wise OR of 13 and 16 is then “00011101“, or 29:

>>> np.bitwise_or(13, 16) 29 >>> np.binary_repr(29) '11101'

>>> np.bitwise_or(32, 2) 34 >>> np.bitwise_or([33, 4], 1) array([33, 5]) >>> np.bitwise_or([33, 4], [1, 2]) array([33, 6])

>>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) array([ 6, 5, 255]) >>> np.array([2, 5, 255]) | np.array([4, 4, 4]) array([ 6, 5, 255]) >>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), ... np.array([4, 4, 4, 2147483647], dtype=np.int32)) array([ 6, 5, 255, 2147483647]) >>> np.bitwise_or([True, True], [False, True]) array([ True, True])

The “|“ operator can be used as a shorthand for “np.bitwise_or“ on ndarrays.

>>> x1 = np.array([2, 5, 255]) >>> x2 = np.array([4, 4, 4]) >>> x1 | x2 array([ 6, 5, 255])

func BitwiseXor ¶

func BitwiseXor(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Compute the bit-wise XOR of two arrays element-wise.

Computes the bit-wise XOR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator “^“.

Parameters ---------- x1, x2 : array_like

Only integer and boolean types are handled.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : ndarray or scalar

Result.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- logical_xor bitwise_and bitwise_or binary_repr :

Return the binary representation of the input number as a string.

Examples -------- The number 13 is represented by “00001101“. Likewise, 17 is represented by “00010001“. The bit-wise XOR of 13 and 17 is therefore “00011100“, or 28:

>>> np.bitwise_xor(13, 17) 28 >>> np.binary_repr(28) '11100'

>>> np.bitwise_xor(31, 5) 26 >>> np.bitwise_xor([31,3], 5) array([26, 6])

>>> np.bitwise_xor([31,3], [5,6]) array([26, 5]) >>> np.bitwise_xor([True, True], [False, True]) array([ True, False])

The “^“ operator can be used as a shorthand for “np.bitwise_xor“ on ndarrays.

>>> x1 = np.array([True, True]) >>> x2 = np.array([False, True]) >>> x1 ^ x2 array([ True, False])

func Blackman ¶

func Blackman(M *py.Object) *py.Object

Return the Blackman window.

The Blackman window is a taper formed by using the first three terms of a summation of cosines. It was designed to have close to the minimal leakage possible. It is close to optimal, only slightly worse than a Kaiser window.

Parameters ---------- M : int

Number of points in the output window. If zero or less, an empty
array is returned.

Returns ------- out : ndarray

The window, with the maximum value normalized to one (the value one
appears only if the number of samples is odd).

See Also -------- bartlett, hamming, hanning, kaiser

Notes ----- The Blackman window is defined as

.. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M)

Most references to the Blackman window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. It is known as a "near optimal" tapering function, almost as good (by some measures) as the kaiser window.

References ---------- Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, Dover Publications, New York.

Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.

Examples -------- >>> import matplotlib.pyplot as plt >>> np.blackman(12) array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary

4.14397981e-01,   7.36045180e-01,   9.67046769e-01,
9.67046769e-01,   7.36045180e-01,   4.14397981e-01,
1.59903635e-01,   3.26064346e-02,  -1.38777878e-17])

Plot the window and the frequency response:

>>> from numpy.fft import fft, fftshift >>> window = np.blackman(51) >>> plt.plot(window) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Blackman window") Text(0.5, 1.0, 'Blackman window') >>> plt.ylabel("Amplitude") Text(0, 0.5, 'Amplitude') >>> plt.xlabel("Sample") Text(0.5, 0, 'Sample') >>> plt.show()

>>> plt.figure() <Figure size 640x480 with 0 Axes> >>> A = fft(window, 2048) / 25.5 >>> mag = np.abs(fftshift(A)) >>> freq = np.linspace(-0.5, 0.5, len(A)) >>> with np.errstate(divide='ignore', invalid='ignore'): ... response = 20 * np.log10(mag) ... >>> response = np.clip(response, -100, 100) >>> plt.plot(freq, response) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Frequency response of Blackman window") Text(0.5, 1.0, 'Frequency response of Blackman window') >>> plt.ylabel("Magnitude [dB]") Text(0, 0.5, 'Magnitude [dB]') >>> plt.xlabel("Normalized frequency [cycles per sample]") Text(0.5, 0, 'Normalized frequency [cycles per sample]') >>> _ = plt.axis('tight') >>> plt.show()

func Block ¶

func Block(arrays *py.Object) *py.Object

Assemble an nd-array from nested lists of blocks.

Blocks in the innermost lists are concatenated (see `concatenate`) along the last dimension (-1), then these are concatenated along the second-last dimension (-2), and so on until the outermost list is reached.

Blocks can be of any dimension, but will not be broadcasted using the normal rules. Instead, leading axes of size 1 are inserted, to make “block.ndim“ the same for all blocks. This is primarily useful for working with scalars, and means that code like “np.block([v, 1])“ is valid, where “v.ndim == 1“.

When the nested list is two levels deep, this allows block matrices to be constructed from their components.

.. versionadded:: 1.13.0

Parameters ---------- arrays : nested list of array_like or scalars (but not tuples)

If passed a single ndarray or scalar (a nested list of depth 0), this
is returned unmodified (and not copied).

Elements shapes must match along the appropriate axes (without
broadcasting), but leading 1s will be prepended to the shape as
necessary to make the dimensions match.

Returns ------- block_array : ndarray

The array assembled from the given blocks.

The dimensionality of the output is equal to the greatest of:
* the dimensionality of all the inputs
* the depth to which the input list is nested

Raises ------ ValueError

• If list depths are mismatched - for instance, “[[a, b], c]“ is illegal, and should be spelt “[[a, b], [c]]“
• If lists are empty - for instance, “[[a, b], []]“

See Also -------- concatenate : Join a sequence of arrays along an existing axis. stack : Join a sequence of arrays along a new axis. vstack : Stack arrays in sequence vertically (row wise). hstack : Stack arrays in sequence horizontally (column wise). dstack : Stack arrays in sequence depth wise (along third axis). column_stack : Stack 1-D arrays as columns into a 2-D array. vsplit : Split an array into multiple sub-arrays vertically (row-wise).

Notes -----

When called with only scalars, “np.block“ is equivalent to an ndarray call. So “np.block([[1, 2], [3, 4]])“ is equivalent to “np.array([[1, 2], [3, 4]])“.

This function does not enforce that the blocks lie on a fixed grid. “np.block([[a, b], [c, d]])“ is not restricted to arrays of the form::

AAAbb
AAAbb
cccDD

But is also allowed to produce, for some “a, b, c, d“::

AAAbb
AAAbb
cDDDD

Since concatenation happens along the last axis first, `block` is _not_ capable of producing the following directly::

AAAbb
cccbb
cccDD

Matlab's "square bracket stacking", “[A, B, ...; p, q, ...]“, is equivalent to “np.block([[A, B, ...], [p, q, ...]])“.

Examples -------- The most common use of this function is to build a block matrix

>>> A = np.eye(2) * 2 >>> B = np.eye(3) * 3 >>> np.block([ ... [A, np.zeros((2, 3))], ... [np.ones((3, 2)), B ] ... ]) array([[2., 0., 0., 0., 0.],

[0., 2., 0., 0., 0.],
[1., 1., 3., 0., 0.],
[1., 1., 0., 3., 0.],
[1., 1., 0., 0., 3.]])

With a list of depth 1, `block` can be used as `hstack`

>>> np.block([1, 2, 3]) # hstack([1, 2, 3]) array([1, 2, 3])

>>> a = np.array([1, 2, 3]) >>> b = np.array([4, 5, 6]) >>> np.block([a, b, 10]) # hstack([a, b, 10]) array([ 1, 2, 3, 4, 5, 6, 10])

>>> A = np.ones((2, 2), int) >>> B = 2 * A >>> np.block([A, B]) # hstack([A, B]) array([[1, 1, 2, 2],

[1, 1, 2, 2]])

With a list of depth 2, `block` can be used in place of `vstack`:

>>> a = np.array([1, 2, 3]) >>> b = np.array([4, 5, 6]) >>> np.block([[a], [b]]) # vstack([a, b]) array([[1, 2, 3],

[4, 5, 6]])

>>> A = np.ones((2, 2), int) >>> B = 2 * A >>> np.block([[A], [B]]) # vstack([A, B]) array([[1, 1],

[1, 1],
[2, 2],
[2, 2]])

It can also be used in places of `atleast_1d` and `atleast_2d`

>>> a = np.array(0) >>> b = np.array([1]) >>> np.block([a]) # atleast_1d(a) array([0]) >>> np.block([b]) # atleast_1d(b) array([1])

>>> np.block([[a]]) # atleast_2d(a) array([[0]]) >>> np.block([[b]]) # atleast_2d(b) array([[1]])

func Bmat ¶

func Bmat(obj *py.Object, ldict *py.Object, gdict *py.Object) *py.Object

Build a matrix object from a string, nested sequence, or array.

Parameters ---------- obj : str or array_like

Input data. If a string, variables in the current scope may be
referenced by name.

ldict : dict, optional

A dictionary that replaces local operands in current frame.
Ignored if `obj` is not a string or `gdict` is None.

gdict : dict, optional

A dictionary that replaces global operands in current frame.
Ignored if `obj` is not a string.

Returns ------- out : matrix

Returns a matrix object, which is a specialized 2-D array.

See Also -------- block :

A generalization of this function for N-d arrays, that returns normal
ndarrays.

Examples -------- >>> A = np.mat('1 1; 1 1') >>> B = np.mat('2 2; 2 2') >>> C = np.mat('3 4; 5 6') >>> D = np.mat('7 8; 9 0')

All the following expressions construct the same block matrix:

>>> np.bmat([[A, B], [C, D]]) matrix([[1, 1, 2, 2],

[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])

>>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) matrix([[1, 1, 2, 2],

[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])

>>> np.bmat('A,B; C,D') matrix([[1, 1, 2, 2],

[1, 1, 2, 2],
[3, 4, 7, 8],
[5, 6, 9, 0]])

func BroadcastArrays ¶

func BroadcastArrays(__llgo_va_list ...interface{}) *py.Object

Broadcast any number of arrays against each other.

Parameters ---------- `*args` : array_likes

The arrays to broadcast.

subok : bool, optional

If True, then sub-classes will be passed-through, otherwise
the returned arrays will be forced to be a base-class array (default).

Returns ------- broadcasted : list of arrays

These arrays are views on the original arrays.  They are typically
not contiguous.  Furthermore, more than one element of a
broadcasted array may refer to a single memory location. If you need
to write to the arrays, make copies first. While you can set the
``writable`` flag True, writing to a single output value may end up
changing more than one location in the output array.

.. deprecated:: 1.17
    The output is currently marked so that if written to, a deprecation
    warning will be emitted. A future version will set the
    ``writable`` flag False so writing to it will raise an error.

See Also -------- broadcast broadcast_to broadcast_shapes

Examples -------- >>> x = np.array([[1,2,3]]) >>> y = np.array([[4],[5]]) >>> np.broadcast_arrays(x, y) [array([[1, 2, 3],

[1, 2, 3]]), array([[4, 4, 4],
[5, 5, 5]])]

Here is a useful idiom for getting contiguous copies instead of non-contiguous views.

>>> [np.array(a) for a in np.broadcast_arrays(x, y)] [array([[1, 2, 3],

[1, 2, 3]]), array([[4, 4, 4],
[5, 5, 5]])]

func BroadcastShapes ¶

func BroadcastShapes(__llgo_va_list ...interface{}) *py.Object

Broadcast the input shapes into a single shape.

:ref:`Learn more about broadcasting here <basics.broadcasting>`.

.. versionadded:: 1.20.0

Parameters ---------- `*args` : tuples of ints, or ints

The shapes to be broadcast against each other.

Returns ------- tuple

Broadcasted shape.

Raises ------ ValueError

If the shapes are not compatible and cannot be broadcast according
to NumPy's broadcasting rules.

See Also -------- broadcast broadcast_arrays broadcast_to

Examples -------- >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2)) (3, 2)

>>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7)) (5, 6, 7)

func BroadcastTo ¶

func BroadcastTo(array *py.Object, shape *py.Object, subok *py.Object) *py.Object

Broadcast an array to a new shape.

Parameters
----------
array : array_like
    The array to broadcast.
shape : tuple or int
    The shape of the desired array. A single integer ``i`` is interpreted
    as ``(i,)``.
subok : bool, optional
    If True, then sub-classes will be passed-through, otherwise
    the returned array will be forced to be a base-class array (default).

Returns
-------
broadcast : array
    A readonly view on the original array with the given shape. It is
    typically not contiguous. Furthermore, more than one element of a
    broadcasted array may refer to a single memory location.

Raises
------
ValueError
    If the array is not compatible with the new shape according to NumPy's
    broadcasting rules.

See Also
--------
broadcast
broadcast_arrays
broadcast_shapes

Notes
-----
.. versionadded:: 1.10.0

Examples
--------
>>> x = np.array([1, 2, 3])
>>> np.broadcast_to(x, (3, 3))
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

func BusdayCount ¶

func BusdayCount(begindates *py.Object, enddates *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object

busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)

Counts the number of valid days between `begindates` and `enddates`, not including the day of `enddates`.

If “enddates“ specifies a date value that is earlier than the corresponding “begindates“ date value, the count will be negative.

.. versionadded:: 1.7.0

Parameters ---------- begindates : array_like of datetime64[D]

The array of the first dates for counting.

enddates : array_like of datetime64[D]

The array of the end dates for counting, which are excluded
from the count themselves.

weekmask : str or array_like of bool, optional

A seven-element array indicating which of Monday through Sunday are
valid days. May be specified as a length-seven list or array, like
[1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for
weekdays, optionally separated by white space. Valid abbreviations
are: Mon Tue Wed Thu Fri Sat Sun

holidays : array_like of datetime64[D], optional

An array of dates to consider as invalid dates.  They may be
specified in any order, and NaT (not-a-time) dates are ignored.
This list is saved in a normalized form that is suited for
fast calculations of valid days.

busdaycal : busdaycalendar, optional

A `busdaycalendar` object which specifies the valid days. If this
parameter is provided, neither weekmask nor holidays may be
provided.

out : array of int, optional

If provided, this array is filled with the result.

Returns ------- out : array of int

An array with a shape from broadcasting ``begindates`` and ``enddates``
together, containing the number of valid days between
the begin and end dates.

See Also -------- busdaycalendar : An object that specifies a custom set of valid days. is_busday : Returns a boolean array indicating valid days. busday_offset : Applies an offset counted in valid days.

Examples -------- >>> # Number of weekdays in January 2011 ... np.busday_count('2011-01', '2011-02') 21 >>> # Number of weekdays in 2011 >>> np.busday_count('2011', '2012') 260 >>> # Number of Saturdays in 2011 ... np.busday_count('2011', '2012', weekmask='Sat') 53

func BusdayOffset ¶

func BusdayOffset(dates *py.Object, offsets *py.Object, roll *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object

busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)

First adjusts the date to fall on a valid day according to the “roll“ rule, then applies offsets to the given dates counted in valid days.

.. versionadded:: 1.7.0

Parameters ---------- dates : array_like of datetime64[D]

The array of dates to process.

offsets : array_like of int

The array of offsets, which is broadcast with ``dates``.

roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional

How to treat dates that do not fall on a valid day. The default
is 'raise'.

  * 'raise' means to raise an exception for an invalid day.
  * 'nat' means to return a NaT (not-a-time) for an invalid day.
  * 'forward' and 'following' mean to take the first valid day
    later in time.
  * 'backward' and 'preceding' mean to take the first valid day
    earlier in time.
  * 'modifiedfollowing' means to take the first valid day
    later in time unless it is across a Month boundary, in which
    case to take the first valid day earlier in time.
  * 'modifiedpreceding' means to take the first valid day
    earlier in time unless it is across a Month boundary, in which
    case to take the first valid day later in time.

weekmask : str or array_like of bool, optional

A seven-element array indicating which of Monday through Sunday are
valid days. May be specified as a length-seven list or array, like
[1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for
weekdays, optionally separated by white space. Valid abbreviations
are: Mon Tue Wed Thu Fri Sat Sun

holidays : array_like of datetime64[D], optional

An array of dates to consider as invalid dates.  They may be
specified in any order, and NaT (not-a-time) dates are ignored.
This list is saved in a normalized form that is suited for
fast calculations of valid days.

busdaycal : busdaycalendar, optional

A `busdaycalendar` object which specifies the valid days. If this
parameter is provided, neither weekmask nor holidays may be
provided.

out : array of datetime64[D], optional

If provided, this array is filled with the result.

Returns ------- out : array of datetime64[D]

An array with a shape from broadcasting ``dates`` and ``offsets``
together, containing the dates with offsets applied.

See Also -------- busdaycalendar : An object that specifies a custom set of valid days. is_busday : Returns a boolean array indicating valid days. busday_count : Counts how many valid days are in a half-open date range.

Examples -------- >>> # First business day in October 2011 (not accounting for holidays) ... np.busday_offset('2011-10', 0, roll='forward') numpy.datetime64('2011-10-03') >>> # Last business day in February 2012 (not accounting for holidays) ... np.busday_offset('2012-03', -1, roll='forward') numpy.datetime64('2012-02-29') >>> # Third Wednesday in January 2011 ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed') numpy.datetime64('2011-01-19') >>> # 2012 Mother's Day in Canada and the U.S. ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun') numpy.datetime64('2012-05-13')

>>> # First business day on or after a date ... np.busday_offset('2011-03-20', 0, roll='forward') numpy.datetime64('2011-03-21') >>> np.busday_offset('2011-03-22', 0, roll='forward') numpy.datetime64('2011-03-22') >>> # First business day after a date ... np.busday_offset('2011-03-20', 1, roll='backward') numpy.datetime64('2011-03-21') >>> np.busday_offset('2011-03-22', 1, roll='backward') numpy.datetime64('2011-03-23')

func ByteBounds ¶

func ByteBounds(a *py.Object) *py.Object

Returns pointers to the end-points of an array.

Parameters ---------- a : ndarray

Input array. It must conform to the Python-side of the array
interface.

Returns ------- (low, high) : tuple of 2 integers

The first integer is the first byte of the array, the second
integer is just past the last byte of the array.  If `a` is not
contiguous it will not use every byte between the (`low`, `high`)
values.

Examples -------- >>> I = np.eye(2, dtype='f'); I.dtype dtype('float32') >>> low, high = np.byte_bounds(I) >>> high - low == I.size*I.itemsize True >>> I = np.eye(2); I.dtype dtype('float64') >>> low, high = np.byte_bounds(I) >>> high - low == I.size*I.itemsize True

func CanCast ¶

func CanCast(from_ *py.Object, to *py.Object, casting *py.Object) *py.Object

can_cast(from_, to, casting='safe')

Returns True if cast between data types can occur according to the casting rule. If from is a scalar or array scalar, also returns True if the scalar value can be cast without overflow or truncation to an integer.

Parameters ---------- from_ : dtype, dtype specifier, scalar, or array

Data type, scalar, or array to cast from.

to : dtype or dtype specifier

Data type to cast to.

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur.

  * 'no' means the data types should not be cast at all.
  * 'equiv' means only byte-order changes are allowed.
  * 'safe' means only casts which can preserve values are allowed.
  * 'same_kind' means only safe casts or casts within a kind,
    like float64 to float32, are allowed.
  * 'unsafe' means any data conversions may be done.

Returns ------- out : bool

True if cast can occur according to the casting rule.

Notes ----- .. versionchanged:: 1.17.0

Casting between a simple data type and a structured one is possible only
for "unsafe" casting.  Casting to multiple fields is allowed, but
casting from multiple fields is not.

.. versionchanged:: 1.9.0

Casting from numeric to string types in 'safe' casting mode requires
that the string dtype length is long enough to store the maximum
integer/float value converted.

See also -------- dtype, result_type

Examples -------- Basic examples

>>> np.can_cast(np.int32, np.int64) True >>> np.can_cast(np.float64, complex) True >>> np.can_cast(complex, float) False

>>> np.can_cast('i8', 'f8') True >>> np.can_cast('i8', 'f4') False >>> np.can_cast('i4', 'S4') False

Casting scalars ¶

>>> np.can_cast(100, 'i1') True >>> np.can_cast(150, 'i1') False >>> np.can_cast(150, 'u1') True

>>> np.can_cast(3.5e100, np.float32) False >>> np.can_cast(1000.0, np.float32) True

Array scalar checks the value, array does not ¶

>>> np.can_cast(np.array(1000.0), np.float32) True >>> np.can_cast(np.array([1000.0]), np.float32) False

Using the casting rules ¶

>>> np.can_cast('i8', 'i8', 'no') True >>> np.can_cast('<i8', '>i8', 'no') False

>>> np.can_cast('<i8', '>i8', 'equiv') True >>> np.can_cast('<i4', '>i8', 'equiv') False

>>> np.can_cast('<i4', '>i8', 'safe') True >>> np.can_cast('<i8', '>i4', 'safe') False

>>> np.can_cast('<i8', '>i4', 'same_kind') True >>> np.can_cast('<i8', '>u4', 'same_kind') False

>>> np.can_cast('<i8', '>u4', 'unsafe') True

func Cbrt ¶

func Cbrt(x *py.Object, out *py.Object) *py.Object

cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the cube-root of an array, element-wise.

.. versionadded:: 1.10.0

Parameters ---------- x : array_like

The values whose cube-roots are required.

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

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

An array of the same shape as `x`, containing the cube
cube-root of each element in `x`.
If `out` was provided, `y` is a reference to it.
This is a scalar if `x` is a scalar.

Examples -------- >>> np.cbrt([1,8,27]) array([ 1., 2., 3.])

func Ceil ¶

func Ceil(x *py.Object, out *py.Object) *py.Object

ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the ceiling of the input, element-wise.

The ceil of the scalar `x` is the smallest integer `i`, such that “i >= x“. It is often denoted as :math:`\lceil x \rceil`.

Parameters ---------- x : array_like

Input data.

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

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 or scalar

The ceiling of each element in `x`, with `float` dtype.
This is a scalar if `x` is a scalar.

See Also -------- floor, trunc, rint, fix

Examples -------- >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) >>> np.ceil(a) array([-1., -1., -0., 1., 2., 2., 2.])

func Choose ¶

func Choose(a *py.Object, choices *py.Object, out *py.Object, mode *py.Object) *py.Object

Construct an array from an index array and a list of arrays to choose from.

First of all, if confused or uncertain, definitely look at the Examples - in its full generality, this function is less simple than it might seem from the following code description (below ndi = `numpy.lib.index_tricks`):

“np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])“.

But this omits some subtleties. Here is a fully general summary:

Given an "index" array (`a`) of integers and a sequence of “n“ arrays (`choices`), `a` and each choice array are first broadcast, as necessary, to arrays of a common shape; calling these *Ba* and *Bchoices[i], i = 0,...,n-1* we have that, necessarily, “Ba.shape == Bchoices[i].shape“ for each “i“. Then, a new array with shape “Ba.shape“ is created as follows:

• if “mode='raise'“ (the default), then, first of all, each element of “a“ (and thus “Ba“) must be in the range “[0, n-1]“; now, suppose that “i“ (in that range) is the value at the “(j0, j1, ..., jm)“ position in “Ba“ - then the value at the same position in the new array is the value in “Bchoices[i]“ at that same position;

• if “mode='wrap'“, values in `a` (and thus `Ba`) may be any (signed) integer; modular arithmetic is used to map integers outside the range `[0, n-1]` back into that range; and then the new array is constructed as above;

• if “mode='clip'“, values in `a` (and thus “Ba“) may be any (signed) integer; negative integers are mapped to 0; values greater than “n-1“ are mapped to “n-1“; and then the new array is constructed as above.

Parameters ---------- a : int array

This array must contain integers in ``[0, n-1]``, where ``n`` is the
number of choices, unless ``mode=wrap`` or ``mode=clip``, in which
cases any integers are permissible.

choices : sequence of arrays

Choice arrays. `a` and all of the choices must be broadcastable to the
same shape.  If `choices` is itself an array (not recommended), then
its outermost dimension (i.e., the one corresponding to
``choices.shape[0]``) is taken as defining the "sequence".

out : array, optional

If provided, the result will be inserted into this array. It should
be of the appropriate shape and dtype. Note that `out` is always
buffered if ``mode='raise'``; use other modes for better performance.

mode : {'raise' (default), 'wrap', 'clip'}, optional

Specifies how indices outside ``[0, n-1]`` will be treated:

  * 'raise' : an exception is raised
  * 'wrap' : value becomes value mod ``n``
  * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1

Returns ------- merged_array : array

The merged result.

Raises ------ ValueError: shape mismatch

If `a` and each choice array are not all broadcastable to the same
shape.

See Also -------- ndarray.choose : equivalent method numpy.take_along_axis : Preferable if `choices` is an array

Notes ----- To reduce the chance of misinterpretation, even though the following "abuse" is nominally supported, `choices` should neither be, nor be thought of as, a single array, i.e., the outermost sequence-like container should be either a list or a tuple.

Examples --------

>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13], ... [20, 21, 22, 23], [30, 31, 32, 33]] >>> np.choose([2, 3, 1, 0], choices ... # the first element of the result will be the first element of the ... # third (2+1) "array" in choices, namely, 20; the second element ... # will be the second element of the fourth (3+1) choice array, i.e., ... # 31, etc. ... ) array([20, 31, 12, 3]) >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1) array([20, 31, 12, 3]) >>> # because there are 4 choice arrays >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4) array([20, 1, 12, 3]) >>> # i.e., 0

A couple examples illustrating how choose broadcasts:

>>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]] >>> choices = [-10, 10] >>> np.choose(a, choices) array([[ 10, -10, 10],

[-10,  10, -10],
[ 10, -10,  10]])

>>> # With thanks to Anne Archibald >>> a = np.array([0, 1]).reshape((2,1,1)) >>> c1 = np.array([1, 2, 3]).reshape((1,3,1)) >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5)) >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2 array([[[ 1, 1, 1, 1, 1],

 [ 2,  2,  2,  2,  2],
 [ 3,  3,  3,  3,  3]],
[[-1, -2, -3, -4, -5],
 [-1, -2, -3, -4, -5],
 [-1, -2, -3, -4, -5]]])

func Clip ¶

func Clip(a *py.Object, aMin *py.Object, aMax *py.Object, out *py.Object) *py.Object

Clip (limit) the values in an array.

Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of “[0, 1]“ is specified, values smaller than 0 become 0, and values larger than 1 become 1.

Equivalent to but faster than “np.minimum(a_max, np.maximum(a, a_min))“.

No check is performed to ensure “a_min < a_max“.

Parameters ---------- a : array_like

Array containing elements to clip.

a_min, a_max : array_like or None

Minimum and maximum value. If ``None``, clipping is not performed on
the corresponding edge. Only one of `a_min` and `a_max` may be
``None``. Both are broadcast against `a`.

out : ndarray, optional

The results will be placed in this array. It may be the input
array for in-place clipping.  `out` must be of the right shape
to hold the output.  Its type is preserved.

**kwargs

For other keyword-only arguments, see the
:ref:`ufunc docs <ufuncs.kwargs>`.

.. versionadded:: 1.17.0

Returns ------- clipped_array : ndarray

An array with the elements of `a`, but where values
< `a_min` are replaced with `a_min`, and those > `a_max`
with `a_max`.

See Also -------- :ref:`ufuncs-output-type`

Notes ----- When `a_min` is greater than `a_max`, `clip` returns an array in which all values are equal to `a_max`, as shown in the second example.

Examples -------- >>> a = np.arange(10) >>> a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.clip(a, 1, 8) array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8]) >>> np.clip(a, 8, 1) array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1]) >>> np.clip(a, 3, 6, out=a) array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) >>> a array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) >>> a = np.arange(10) >>> a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8) array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])

func ColumnStack ¶

func ColumnStack(__llgo_va_list ...interface{}) *py.Object

Stack 1-D arrays as columns into a 2-D array.

Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with `hstack`. 1-D arrays are turned into 2-D columns first.

Parameters ---------- tup : sequence of 1-D or 2-D arrays.

Arrays to stack. All of them must have the same first dimension.

Returns ------- stacked : 2-D array

The array formed by stacking the given arrays.

See Also -------- stack, hstack, vstack, concatenate

Examples -------- >>> a = np.array((1,2,3)) >>> b = np.array((2,3,4)) >>> np.column_stack((a,b)) array([[1, 2],

[2, 3],
[3, 4]])

func CommonType ¶

func CommonType(__llgo_va_list ...interface{}) *py.Object

Return a scalar type which is common to the input arrays.

The return type will always be an inexact (i.e. floating point) scalar type, even if all the arrays are integer arrays. If one of the inputs is an integer array, the minimum precision type that is returned is a 64-bit floating point dtype.

All input arrays except int64 and uint64 can be safely cast to the returned dtype without loss of information.

Parameters ---------- array1, array2, ... : ndarrays

Input arrays.

Returns ------- out : data type code

Data type code.

See Also -------- dtype, mintypecode

Examples -------- >>> np.common_type(np.arange(2, dtype=np.float32)) <class 'numpy.float32'> >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2)) <class 'numpy.float64'> >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0])) <class 'numpy.complex128'>

func CompareChararrays ¶

func CompareChararrays(a1 *py.Object, a2 *py.Object, cmp *py.Object, rstrip *py.Object) *py.Object

compare_chararrays(a1, a2, cmp, rstrip)

Performs element-wise comparison of two string arrays using the
comparison operator specified by `cmp_op`.

Parameters
----------
a1, a2 : array_like
    Arrays to be compared.
cmp : {"<", "<=", "==", ">=", ">", "!="}
    Type of comparison.
rstrip : Boolean
    If True, the spaces at the end of Strings are removed before the comparison.

Returns
-------
out : ndarray
    The output array of type Boolean with the same shape as a and b.

Raises
------
ValueError
    If `cmp_op` is not valid.
TypeError
    If at least one of `a` or `b` is a non-string array

Examples
--------
>>> a = np.array(["a", "b", "cde"])
>>> b = np.array(["a", "a", "dec"])
>>> np.compare_chararrays(a, b, ">", True)
array([False,  True, False])

func Compress ¶

func Compress(condition *py.Object, a *py.Object, axis *py.Object, out *py.Object) *py.Object

Return selected slices of an array along given axis.

When working along a given axis, a slice along that axis is returned in `output` for each index where `condition` evaluates to True. When working on a 1-D array, `compress` is equivalent to `extract`.

Parameters ---------- condition : 1-D array of bools

Array that selects which entries to return. If len(condition)
is less than the size of `a` along the given axis, then output is
truncated to the length of the condition array.

a : array_like

Array from which to extract a part.

axis : int, optional

Axis along which to take slices. If None (default), work on the
flattened array.

out : ndarray, optional

Output array.  Its type is preserved and it must be of the right
shape to hold the output.

Returns ------- compressed_array : ndarray

A copy of `a` without the slices along axis for which `condition`
is false.

See Also -------- take, choose, diag, diagonal, select ndarray.compress : Equivalent method in ndarray extract : Equivalent method when working on 1-D arrays :ref:`ufuncs-output-type`

Examples -------- >>> a = np.array([[1, 2], [3, 4], [5, 6]]) >>> a array([[1, 2],

[3, 4],
[5, 6]])

>>> np.compress([0, 1], a, axis=0) array([[3, 4]]) >>> np.compress([False, True, True], a, axis=0) array([[3, 4],

[5, 6]])

>>> np.compress([False, True], a, axis=1) array([[2],

[4],
[6]])

Working on the flattened array does not return slices along an axis but selects elements.

>>> np.compress([False, True], a) array([2])

func Concatenate ¶

func Concatenate(list0 *py.Object, axis *py.Object, out *py.Object, dtype *py.Object, casting *py.Object) *py.Object

concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind")

Join a sequence of arrays along an existing axis.

Parameters ---------- a1, a2, ... : sequence of array_like

The arrays must have the same shape, except in the dimension
corresponding to `axis` (the first, by default).

axis : int, optional

The axis along which the arrays will be joined.  If axis is None,
arrays are flattened before use.  Default is 0.

out : ndarray, optional

If provided, the destination to place the result. The shape must be
correct, matching that of what concatenate would have returned if no
out argument were specified.

dtype : str or dtype

If provided, the destination array will have this dtype. Cannot be
provided together with `out`.

.. versionadded:: 1.20.0

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur. Defaults to 'same_kind'.

.. versionadded:: 1.20.0

Returns ------- res : ndarray

The concatenated array.

See Also -------- ma.concatenate : Concatenate function that preserves input masks. array_split : Split an array into multiple sub-arrays of equal or

near-equal size.

split : Split array into a list of multiple sub-arrays of equal size. hsplit : Split array into multiple sub-arrays horizontally (column wise). vsplit : Split array into multiple sub-arrays vertically (row wise). dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). stack : Stack a sequence of arrays along a new axis. block : Assemble arrays from blocks. hstack : Stack arrays in sequence horizontally (column wise). vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third dimension). column_stack : Stack 1-D arrays as columns into a 2-D array.

Notes ----- When one or more of the arrays to be concatenated is a MaskedArray, this function will return a MaskedArray object instead of an ndarray, but the input masks are *not* preserved. In cases where a MaskedArray is expected as input, use the ma.concatenate function from the masked array module instead.

Examples -------- >>> a = np.array([[1, 2], [3, 4]]) >>> b = np.array([[5, 6]]) >>> np.concatenate((a, b), axis=0) array([[1, 2],

[3, 4],
[5, 6]])

>>> np.concatenate((a, b.T), axis=1) array([[1, 2, 5],

[3, 4, 6]])

>>> np.concatenate((a, b), axis=None) array([1, 2, 3, 4, 5, 6])

This function will not preserve masking of MaskedArray inputs.

>>> a = np.ma.arange(3) >>> a[1] = np.ma.masked >>> b = np.arange(2, 5) >>> a masked_array(data=[0, --, 2],

      mask=[False,  True, False],
fill_value=999999)

>>> b array([2, 3, 4]) >>> np.concatenate([a, b]) masked_array(data=[0, 1, 2, 2, 3, 4],

      mask=False,
fill_value=999999)

>>> np.ma.concatenate([a, b]) masked_array(data=[0, --, 2, 2, 3, 4],

      mask=[False,  True, False, False, False, False],
fill_value=999999)

func Conj ¶

func Conj(__llgo_va_list ...interface{}) *py.Object

conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the complex conjugate, element-wise.

The complex conjugate of a complex number is obtained by changing the sign of its imaginary part.

Parameters ---------- x : array_like

Input value.

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

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 complex conjugate of `x`, with same dtype as `y`.
This is a scalar if `x` is a scalar.

Notes ----- `conj` is an alias for `conjugate`:

>>> np.conj is np.conjugate True

Examples -------- >>> np.conjugate(1+2j) (1-2j)

>>> x = np.eye(2) + 1j * np.eye(2) >>> np.conjugate(x) array([[ 1.-1.j, 0.-0.j],

[ 0.-0.j,  1.-1.j]])

func Conjugate ¶

func Conjugate(x *py.Object, out *py.Object) *py.Object

conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the complex conjugate, element-wise.

The complex conjugate of a complex number is obtained by changing the sign of its imaginary part.

Parameters ---------- x : array_like

Input value.

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

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 complex conjugate of `x`, with same dtype as `y`.
This is a scalar if `x` is a scalar.

Notes ----- `conj` is an alias for `conjugate`:

>>> np.conj is np.conjugate True

Examples -------- >>> np.conjugate(1+2j) (1-2j)

>>> x = np.eye(2) + 1j * np.eye(2) >>> np.conjugate(x) array([[ 1.-1.j, 0.-0.j],

[ 0.-0.j,  1.-1.j]])

func Convolve ¶

func Convolve(a *py.Object, v *py.Object, mode *py.Object) *py.Object

Returns the discrete, linear convolution of two one-dimensional sequences.

The convolution operator is often seen in signal processing, where it models the effect of a linear time-invariant system on a signal [1]_. In probability theory, the sum of two independent random variables is distributed according to the convolution of their individual distributions.

If `v` is longer than `a`, the arrays are swapped before computation.

Parameters ---------- a : (N,) array_like

First one-dimensional input array.

v : (M,) array_like

Second one-dimensional input array.

mode : {'full', 'valid', 'same'}, optional

'full':
  By default, mode is 'full'.  This returns the convolution
  at each point of overlap, with an output shape of (N+M-1,). At
  the end-points of the convolution, the signals do not overlap
  completely, and boundary effects may be seen.

'same':
  Mode 'same' returns output of length ``max(M, N)``.  Boundary
  effects are still visible.

'valid':
  Mode 'valid' returns output of length
  ``max(M, N) - min(M, N) + 1``.  The convolution product is only given
  for points where the signals overlap completely.  Values outside
  the signal boundary have no effect.

Returns ------- out : ndarray

Discrete, linear convolution of `a` and `v`.

See Also -------- scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier

Transform.

scipy.linalg.toeplitz : Used to construct the convolution operator. polymul : Polynomial multiplication. Same output as convolve, but also

accepts poly1d objects as input.

Notes ----- The discrete convolution operation is defined as

.. math:: (a * v)_n = \sum_{m = -\infty}^{\infty} a_m v_{n - m}

It can be shown that a convolution :math:`x(t) * y(t)` in time/space is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier domain, after appropriate padding (padding is necessary to prevent circular convolution). Since multiplication is more efficient (faster) than convolution, the function `scipy.signal.fftconvolve` exploits the FFT to calculate the convolution of large data-sets.

References ---------- .. [1] Wikipedia, "Convolution",

https://en.wikipedia.org/wiki/Convolution

Examples -------- Note how the convolution operator flips the second array before "sliding" the two across one another:

>>> np.convolve([1, 2, 3], [0, 1, 0.5]) array([0. , 1. , 2.5, 4. , 1.5])

Only return the middle values of the convolution. Contains boundary effects, where zeros are taken into account:

>>> np.convolve([1,2,3],[0,1,0.5], 'same') array([1. , 2.5, 4. ])

The two arrays are of the same length, so there is only one position where they completely overlap:

>>> np.convolve([1,2,3],[0,1,0.5], 'valid') array([2.5])

func Copy ¶

func Copy(a *py.Object, order *py.Object, subok *py.Object) *py.Object

Return an array copy of the given object.

Parameters ---------- a : array_like

Input data.

order : {'C', 'F', 'A', 'K'}, optional

Controls the memory layout of the copy. 'C' means C-order,
'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
'C' otherwise. 'K' means match the layout of `a` as closely
as possible. (Note that this function and :meth:`ndarray.copy` are very
similar, but have different default values for their order=
arguments.)

subok : bool, optional

If True, then sub-classes will be passed-through, otherwise the
returned array will be forced to be a base-class array (defaults to False).

.. versionadded:: 1.19.0

Returns ------- arr : ndarray

Array interpretation of `a`.

See Also -------- ndarray.copy : Preferred method for creating an array copy

Notes ----- This is equivalent to:

>>> np.array(a, copy=True) #doctest: +SKIP

Examples -------- Create an array x, with a reference y and a copy z:

>>> x = np.array([1, 2, 3]) >>> y = x >>> z = np.copy(x)

Note that, when we modify x, y changes, but not z:

>>> x[0] = 10 >>> x[0] == y[0] True >>> x[0] == z[0] False

Note that, np.copy clears previously set WRITEABLE=False flag.

>>> a = np.array([1, 2, 3]) >>> a.flags["WRITEABLE"] = False >>> b = np.copy(a) >>> b.flags["WRITEABLE"] True >>> b[0] = 3 >>> b array([3, 2, 3])

Note that np.copy is a shallow copy and will not copy object elements within arrays. This is mainly important for arrays containing Python objects. The new array will contain the same object which may lead to surprises if that object can be modified (is mutable):

>>> a = np.array([1, 'm', [2, 3, 4]], dtype=object) >>> b = np.copy(a) >>> b[2][0] = 10 >>> a array([1, 'm', list([10, 3, 4])], dtype=object)

To ensure all elements within an “object“ array are copied, use `copy.deepcopy`:

>>> import copy >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object) >>> c = copy.deepcopy(a) >>> c[2][0] = 10 >>> c array([1, 'm', list([10, 3, 4])], dtype=object) >>> a array([1, 'm', list([2, 3, 4])], dtype=object)

func Copysign ¶

func Copysign(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Change the sign of x1 to that of x2, element-wise.

If `x2` is a scalar, its sign will be copied to all elements of `x1`.

Parameters ---------- x1 : array_like

Values to change the sign of.

x2 : array_like

The sign of `x2` is copied to `x1`.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : ndarray or scalar

The values of `x1` with the sign of `x2`.
This is a scalar if both `x1` and `x2` are scalars.

Examples -------- >>> np.copysign(1.3, -1) -1.3 >>> 1/np.copysign(0, 1) inf >>> 1/np.copysign(0, -1) -inf

>>> np.copysign([-1, 0, 1], -1.1) array([-1., -0., -1.]) >>> np.copysign([-1, 0, 1], np.arange(3)-1) array([-1., 0., 1.])

func Copyto ¶

func Copyto(dst *py.Object, src *py.Object, casting *py.Object, where *py.Object) *py.Object

copyto(dst, src, casting='same_kind', where=True)

Copies values from one array to another, broadcasting as necessary.

Raises a TypeError if the `casting` rule is violated, and if `where` is provided, it selects which elements to copy.

.. versionadded:: 1.7.0

Parameters ---------- dst : ndarray

The array into which values are copied.

src : array_like

The array from which values are copied.

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur when copying.

  * 'no' means the data types should not be cast at all.
  * 'equiv' means only byte-order changes are allowed.
  * 'safe' means only casts which can preserve values are allowed.
  * 'same_kind' means only safe casts or casts within a kind,
    like float64 to float32, are allowed.
  * 'unsafe' means any data conversions may be done.

where : array_like of bool, optional

A boolean array which is broadcasted to match the dimensions
of `dst`, and selects elements to copy from `src` to `dst`
wherever it contains the value True.

Examples -------- >>> A = np.array([4, 5, 6]) >>> B = [1, 2, 3] >>> np.copyto(A, B) >>> A array([1, 2, 3])

>>> A = np.array([[1, 2, 3], [4, 5, 6]]) >>> B = [[4, 5, 6], [7, 8, 9]] >>> np.copyto(A, B) >>> A array([[4, 5, 6],

[7, 8, 9]])

func Corrcoef ¶

func Corrcoef(x *py.Object, y *py.Object, rowvar *py.Object, bias *py.Object, ddof *py.Object) *py.Object

Return Pearson product-moment correlation coefficients.

Please refer to the documentation for `cov` for more detail. The relationship between the correlation coefficient matrix, `R`, and the covariance matrix, `C`, is

.. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} C_{jj} } }

The values of `R` are between -1 and 1, inclusive.

Parameters ---------- x : array_like

A 1-D or 2-D array containing multiple variables and observations.
Each row of `x` represents a variable, and each column a single
observation of all those variables. Also see `rowvar` below.

y : array_like, optional

An additional set of variables and observations. `y` has the same
shape as `x`.

rowvar : bool, optional

If `rowvar` is True (default), then each row represents a
variable, with observations in the columns. Otherwise, the relationship
is transposed: each column represents a variable, while the rows
contain observations.

bias : _NoValue, optional

Has no effect, do not use.

.. deprecated:: 1.10.0

ddof : _NoValue, optional

Has no effect, do not use.

.. deprecated:: 1.10.0

dtype : data-type, optional

Data-type of the result. By default, the return data-type will have
at least `numpy.float64` precision.

.. versionadded:: 1.20

Returns ------- R : ndarray

The correlation coefficient matrix of the variables.

See Also -------- cov : Covariance matrix

Notes ----- Due to floating point rounding the resulting array may not be Hermitian, the diagonal elements may not be 1, and the elements may not satisfy the inequality abs(a) <= 1. The real and imaginary parts are clipped to the interval [-1, 1] in an attempt to improve on that situation but is not much help in the complex case.

This function accepts but discards arguments `bias` and `ddof`. This is for backwards compatibility with previous versions of this function. These arguments had no effect on the return values of the function and can be safely ignored in this and previous versions of numpy.

Examples -------- In this example we generate two random arrays, “xarr“ and “yarr“, and compute the row-wise and column-wise Pearson correlation coefficients, “R“. Since “rowvar“ is true by default, we first find the row-wise Pearson correlation coefficients between the variables of “xarr“.

>>> import numpy as np >>> rng = np.random.default_rng(seed=42) >>> xarr = rng.random((3, 3)) >>> xarr array([[0.77395605, 0.43887844, 0.85859792],

[0.69736803, 0.09417735, 0.97562235],
[0.7611397 , 0.78606431, 0.12811363]])

>>> R1 = np.corrcoef(xarr) >>> R1 array([[ 1. , 0.99256089, -0.68080986],

[ 0.99256089,  1.        , -0.76492172],
[-0.68080986, -0.76492172,  1.        ]])

If we add another set of variables and observations “yarr“, we can compute the row-wise Pearson correlation coefficients between the variables in “xarr“ and “yarr“.

>>> yarr = rng.random((3, 3)) >>> yarr array([[0.45038594, 0.37079802, 0.92676499],

[0.64386512, 0.82276161, 0.4434142 ],
[0.22723872, 0.55458479, 0.06381726]])

>>> R2 = np.corrcoef(xarr, yarr) >>> R2 array([[ 1. , 0.99256089, -0.68080986, 0.75008178, -0.934284 ,

 -0.99004057],
[ 0.99256089,  1.        , -0.76492172,  0.82502011, -0.97074098,
 -0.99981569],
[-0.68080986, -0.76492172,  1.        , -0.99507202,  0.89721355,
  0.77714685],
[ 0.75008178,  0.82502011, -0.99507202,  1.        , -0.93657855,
 -0.83571711],
[-0.934284  , -0.97074098,  0.89721355, -0.93657855,  1.        ,
  0.97517215],
[-0.99004057, -0.99981569,  0.77714685, -0.83571711,  0.97517215,
  1.        ]])

Finally if we use the option “rowvar=False“, the columns are now being treated as the variables and we will find the column-wise Pearson correlation coefficients between variables in “xarr“ and “yarr“.

>>> R3 = np.corrcoef(xarr, yarr, rowvar=False) >>> R3 array([[ 1. , 0.77598074, -0.47458546, -0.75078643, -0.9665554 ,

  0.22423734],
[ 0.77598074,  1.        , -0.92346708, -0.99923895, -0.58826587,
 -0.44069024],
[-0.47458546, -0.92346708,  1.        ,  0.93773029,  0.23297648,
  0.75137473],
[-0.75078643, -0.99923895,  0.93773029,  1.        ,  0.55627469,
  0.47536961],
[-0.9665554 , -0.58826587,  0.23297648,  0.55627469,  1.        ,
 -0.46666491],
[ 0.22423734, -0.44069024,  0.75137473,  0.47536961, -0.46666491,
  1.        ]])

func Correlate ¶

func Correlate(a *py.Object, v *py.Object, mode *py.Object) *py.Object

Cross-correlation of two 1-dimensional sequences.

This function computes the correlation as generally defined in signal processing texts:

.. math:: c_k = \sum_n a_{n+k} \cdot \overline{v}_n

with a and v sequences being zero-padded where necessary and :math:`\overline x` denoting complex conjugation.

Parameters ---------- a, v : array_like

Input sequences.

mode : {'valid', 'same', 'full'}, optional

Refer to the `convolve` docstring.  Note that the default
is 'valid', unlike `convolve`, which uses 'full'.

old_behavior : bool

`old_behavior` was removed in NumPy 1.10. If you need the old
behavior, use `multiarray.correlate`.

Returns ------- out : ndarray

Discrete cross-correlation of `a` and `v`.

See Also -------- convolve : Discrete, linear convolution of two one-dimensional sequences. multiarray.correlate : Old, no conjugate, version of correlate. scipy.signal.correlate : uses FFT which has superior performance on large arrays.

Notes ----- The definition of correlation above is not unique and sometimes correlation may be defined differently. Another common definition is:

.. math:: c'_k = \sum_n a_{n} \cdot \overline{v_{n+k}}

which is related to :math:`c_k` by :math:`c'_k = c_{-k}`.

`numpy.correlate` may perform slowly in large arrays (i.e. n = 1e5) because it does not use the FFT to compute the convolution; in that case, `scipy.signal.correlate` might be preferable.

Examples -------- >>> np.correlate([1, 2, 3], [0, 1, 0.5]) array([3.5]) >>> np.correlate([1, 2, 3], [0, 1, 0.5], "same") array([2. , 3.5, 3. ]) >>> np.correlate([1, 2, 3], [0, 1, 0.5], "full") array([0.5, 2. , 3.5, 3. , 0. ])

Using complex sequences:

>>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full') array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ])

Note that you get the time reversed, complex conjugated result (:math:`\overline{c_{-k}}`) when the two input sequences a and v change places:

>>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full') array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j])

func Cos ¶

func Cos(x *py.Object, out *py.Object) *py.Object

cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Cosine element-wise.

Parameters ---------- x : array_like

Input array in radians.

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

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 corresponding cosine values.
This is a scalar if `x` is a scalar.

Notes ----- If `out` is provided, the function writes the result into it, and returns a reference to `out`. (See Examples)

References ---------- M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972.

Examples -------- >>> np.cos(np.array([0, np.pi/2, np.pi])) array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00]) >>> >>> # Example of providing the optional output parameter >>> out1 = np.array([0], dtype='d') >>> out2 = np.cos([0.1], out1) >>> out2 is out1 True >>> >>> # Example of ValueError due to provision of shape mis-matched `out` >>> np.cos(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: operands could not be broadcast together with shapes (3,3) (2,2)

func Cosh ¶

func Cosh(x *py.Object, out *py.Object) *py.Object

cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Hyperbolic cosine, element-wise.

Equivalent to “1/2 * (np.exp(x) + np.exp(-x))“ and “np.cos(1j*x)“.

Parameters ---------- x : array_like

Input array.

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

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 ------- out : ndarray or scalar

Output array of same shape as `x`.
This is a scalar if `x` is a scalar.

Examples -------- >>> np.cosh(0) 1.0

The hyperbolic cosine describes the shape of a hanging cable:

>>> import matplotlib.pyplot as plt >>> x = np.linspace(-4, 4, 1000) >>> plt.plot(x, np.cosh(x)) >>> plt.show()

func CountNonzero ¶

func CountNonzero(a *py.Object, axis *py.Object) *py.Object

Counts the number of non-zero values in the array “a“.

The word "non-zero" is in reference to the Python 2.x built-in method “__nonzero__()“ (renamed “__bool__()“ in Python 3.x) of Python objects that tests an object's "truthfulness". For example, any number is considered truthful if it is nonzero, whereas any string is considered truthful if it is not the empty string. Thus, this function (recursively) counts how many elements in “a“ (and in sub-arrays thereof) have their “__nonzero__()“ or “__bool__()“ method evaluated to “True“.

Parameters ---------- a : array_like

The array for which to count non-zeros.

axis : int or tuple, optional

Axis or tuple of axes along which to count non-zeros.
Default is None, meaning that non-zeros will be counted
along a flattened version of ``a``.

.. versionadded:: 1.12.0

keepdims : bool, optional

If this is set to True, the axes that are counted are left
in the result as dimensions with size one. With this option,
the result will broadcast correctly against the input array.

.. versionadded:: 1.19.0

Returns ------- count : int or array of int

Number of non-zero values in the array along a given axis.
Otherwise, the total number of non-zero values in the array
is returned.

See Also -------- nonzero : Return the coordinates of all the non-zero values.

Examples -------- >>> np.count_nonzero(np.eye(4)) 4 >>> a = np.array([[0, 1, 7, 0], ... [3, 0, 2, 19]]) >>> np.count_nonzero(a) 5 >>> np.count_nonzero(a, axis=0) array([1, 1, 2, 1]) >>> np.count_nonzero(a, axis=1) array([2, 3]) >>> np.count_nonzero(a, axis=1, keepdims=True) array([[2],

[3]])

func Cov ¶

func Cov(m *py.Object, y *py.Object, rowvar *py.Object, bias *py.Object, ddof *py.Object, fweights *py.Object, aweights *py.Object) *py.Object

Estimate a covariance matrix, given data and weights.

Covariance indicates the level to which two variables vary together. If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`, then the covariance matrix element :math:`C_{ij}` is the covariance of :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance of :math:`x_i`.

See the notes for an outline of the algorithm.

Parameters ---------- m : array_like

A 1-D or 2-D array containing multiple variables and observations.
Each row of `m` represents a variable, and each column a single
observation of all those variables. Also see `rowvar` below.

y : array_like, optional

An additional set of variables and observations. `y` has the same form
as that of `m`.

rowvar : bool, optional

If `rowvar` is True (default), then each row represents a
variable, with observations in the columns. Otherwise, the relationship
is transposed: each column represents a variable, while the rows
contain observations.

bias : bool, optional

Default normalization (False) is by ``(N - 1)``, where ``N`` is the
number of observations given (unbiased estimate). If `bias` is True,
then normalization is by ``N``. These values can be overridden by using
the keyword ``ddof`` in numpy versions >= 1.5.

ddof : int, optional

If not ``None`` the default value implied by `bias` is overridden.
Note that ``ddof=1`` will return the unbiased estimate, even if both
`fweights` and `aweights` are specified, and ``ddof=0`` will return
the simple average. See the notes for the details. The default value
is ``None``.

.. versionadded:: 1.5

fweights : array_like, int, optional

1-D array of integer frequency weights; the number of times each
observation vector should be repeated.

.. versionadded:: 1.10

aweights : array_like, optional

1-D array of observation vector weights. These relative weights are
typically large for observations considered "important" and smaller for
observations considered less "important". If ``ddof=0`` the array of
weights can be used to assign probabilities to observation vectors.

.. versionadded:: 1.10

dtype : data-type, optional

Data-type of the result. By default, the return data-type will have
at least `numpy.float64` precision.

.. versionadded:: 1.20

Returns ------- out : ndarray

The covariance matrix of the variables.

See Also -------- corrcoef : Normalized covariance matrix

Notes ----- Assume that the observations are in the columns of the observation array `m` and let “f = fweights“ and “a = aweights“ for brevity. The steps to compute the weighted covariance are as follows::

>>> m = np.arange(10, dtype=np.float64)
>>> f = np.arange(10) * 2
>>> a = np.arange(10) ** 2.
>>> ddof = 1
>>> w = f * a
>>> v1 = np.sum(w)
>>> v2 = np.sum(w * a)
>>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
>>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)

Note that when “a == 1“, the normalization factor “v1 / (v1**2 - ddof * v2)“ goes over to “1 / (np.sum(f) - ddof)“ as it should.

Examples -------- Consider two variables, :math:`x_0` and :math:`x_1`, which correlate perfectly, but in opposite directions:

>>> x = np.array([[0, 2], [1, 1], [2, 0]]).T >>> x array([[0, 1, 2],

[2, 1, 0]])

Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance matrix shows this clearly:

>>> np.cov(x) array([[ 1., -1.],

[-1.,  1.]])

Note that element :math:`C_{0,1}`, which shows the correlation between :math:`x_0` and :math:`x_1`, is negative.

Further, note how `x` and `y` are combined:

>>> x = [-2.1, -1, 4.3] >>> y = [3, 1.1, 0.12] >>> X = np.stack((x, y), axis=0) >>> np.cov(X) array([[11.71 , -4.286 ], # may vary

[-4.286     ,  2.144133]])

>>> np.cov(x, y) array([[11.71 , -4.286 ], # may vary

[-4.286     ,  2.144133]])

>>> np.cov(x) array(11.71)

func Cross ¶

func Cross(a *py.Object, b *py.Object, axisa *py.Object, axisb *py.Object, axisc *py.Object, axis *py.Object) *py.Object

Return the cross product of two (arrays of) vectors.

The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular to both `a` and `b`. If `a` and `b` are arrays of vectors, the vectors are defined by the last axis of `a` and `b` by default, and these axes can have dimensions 2 or 3. Where the dimension of either `a` or `b` is 2, the third component of the input vector is assumed to be zero and the cross product calculated accordingly. In cases where both input vectors have dimension 2, the z-component of the cross product is returned.

Parameters ---------- a : array_like

Components of the first vector(s).

b : array_like

Components of the second vector(s).

axisa : int, optional

Axis of `a` that defines the vector(s).  By default, the last axis.

axisb : int, optional

Axis of `b` that defines the vector(s).  By default, the last axis.

axisc : int, optional

Axis of `c` containing the cross product vector(s).  Ignored if
both input vectors have dimension 2, as the return is scalar.
By default, the last axis.

axis : int, optional

If defined, the axis of `a`, `b` and `c` that defines the vector(s)
and cross product(s).  Overrides `axisa`, `axisb` and `axisc`.

Returns ------- c : ndarray

Vector cross product(s).

Raises ------ ValueError

When the dimension of the vector(s) in `a` and/or `b` does not
equal 2 or 3.

See Also -------- inner : Inner product outer : Outer product. ix_ : Construct index arrays.

Notes ----- .. versionadded:: 1.9.0

Supports full broadcasting of the inputs.

Examples -------- Vector cross-product.

>>> x = [1, 2, 3] >>> y = [4, 5, 6] >>> np.cross(x, y) array([-3, 6, -3])

One vector with dimension 2.

>>> x = [1, 2] >>> y = [4, 5, 6] >>> np.cross(x, y) array([12, -6, -3])

Equivalently:

>>> x = [1, 2, 0] >>> y = [4, 5, 6] >>> np.cross(x, y) array([12, -6, -3])

Both vectors with dimension 2.

>>> x = [1,2] >>> y = [4,5] >>> np.cross(x, y) array(-3)

Multiple vector cross-products. Note that the direction of the cross product vector is defined by the *right-hand rule*.

>>> x = np.array([[1,2,3], [4,5,6]]) >>> y = np.array([[4,5,6], [1,2,3]]) >>> np.cross(x, y) array([[-3, 6, -3],

[ 3, -6,  3]])

The orientation of `c` can be changed using the `axisc` keyword.

>>> np.cross(x, y, axisc=0) array([[-3, 3],

[ 6, -6],
[-3,  3]])

Change the vector definition of `x` and `y` using `axisa` and `axisb`.

>>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]]) >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]]) >>> np.cross(x, y) array([[ -6, 12, -6],

[  0,   0,   0],
[  6, -12,   6]])

>>> np.cross(x, y, axisa=0, axisb=0) array([[-24, 48, -24],

[-30,  60, -30],
[-36,  72, -36]])

func Cumprod ¶

func Cumprod(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object

Return the cumulative product of elements along a given axis.

Parameters ---------- a : array_like

Input array.

axis : int, optional

Axis along which the cumulative product is computed.  By default
the input is flattened.

dtype : dtype, optional

Type of the returned array, as well as of the accumulator in which
the elements are multiplied.  If *dtype* is not specified, it
defaults to the dtype of `a`, unless `a` has an integer dtype with
a precision less than that of the default platform integer.  In
that case, the default platform integer is used instead.

out : ndarray, optional

Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output
but the type of the resulting values will be cast if necessary.

Returns ------- cumprod : ndarray

A new array holding the result is returned unless `out` is
specified, in which case a reference to out is returned.

See Also -------- :ref:`ufuncs-output-type`

Notes ----- Arithmetic is modular when using integer types, and no error is raised on overflow.

Examples -------- >>> a = np.array([1,2,3]) >>> np.cumprod(a) # intermediate results 1, 1*2 ... # total product 1*2*3 = 6 array([1, 2, 6]) >>> a = np.array([[1, 2, 3], [4, 5, 6]]) >>> np.cumprod(a, dtype=float) # specify type of output array([ 1., 2., 6., 24., 120., 720.])

The cumulative product for each column (i.e., over the rows) of `a`:

>>> np.cumprod(a, axis=0) array([[ 1, 2, 3],

[ 4, 10, 18]])

The cumulative product for each row (i.e. over the columns) of `a`:

>>> np.cumprod(a,axis=1) array([[ 1, 2, 6],

[  4,  20, 120]])

func Cumproduct ¶

func Cumproduct(__llgo_va_list ...interface{}) *py.Object

Return the cumulative product over the given axis.

.. deprecated:: 1.25.0

``cumproduct`` is deprecated as of NumPy 1.25.0, and will be
removed in NumPy 2.0. Please use `cumprod` instead.

See Also -------- cumprod : equivalent function; see for details.

func Cumsum ¶

func Cumsum(a *py.Object, axis *py.Object, dtype *py.Object, out *py.Object) *py.Object

Return the cumulative sum of the elements along a given axis.

Parameters ---------- a : array_like

Input array.

axis : int, optional

Axis along which the cumulative sum is computed. The default
(None) is to compute the cumsum over the flattened array.

dtype : dtype, optional

Type of the returned array and of the accumulator in which the
elements are summed.  If `dtype` is not specified, it defaults
to the dtype of `a`, unless `a` has an integer dtype with a
precision less than that of the default platform integer.  In
that case, the default platform integer is used.

out : ndarray, optional

Alternative output array in which to place the result. It must
have the same shape and buffer length as the expected output
but the type will be cast if necessary. See :ref:`ufuncs-output-type` for
more details.

Returns ------- cumsum_along_axis : ndarray.

A new array holding the result is returned unless `out` is
specified, in which case a reference to `out` is returned. The
result has the same size as `a`, and the same shape as `a` if
`axis` is not None or `a` is a 1-d array.

See Also -------- sum : Sum array elements. trapz : Integration of array values using the composite trapezoidal rule. diff : Calculate the n-th discrete difference along given axis.

Notes ----- Arithmetic is modular when using integer types, and no error is raised on overflow.

“cumsum(a)[-1]“ may not be equal to “sum(a)“ for floating-point values since “sum“ may use a pairwise summation routine, reducing the roundoff-error. See `sum` for more information.

Examples -------- >>> a = np.array([[1,2,3], [4,5,6]]) >>> a array([[1, 2, 3],

[4, 5, 6]])

>>> np.cumsum(a) array([ 1, 3, 6, 10, 15, 21]) >>> np.cumsum(a, dtype=float) # specifies type of output value(s) array([ 1., 3., 6., 10., 15., 21.])

>>> np.cumsum(a,axis=0) # sum over rows for each of the 3 columns array([[1, 2, 3],

[5, 7, 9]])

>>> np.cumsum(a,axis=1) # sum over columns for each of the 2 rows array([[ 1, 3, 6],

[ 4,  9, 15]])

“cumsum(b)[-1]“ may not be equal to “sum(b)“

>>> b = np.array([1, 2e-9, 3e-9] * 1000000) >>> b.cumsum()[-1] 1000000.0050045159 >>> b.sum() 1000000.0050000029

func DatetimeAsString ¶

func DatetimeAsString(arr *py.Object, unit *py.Object, timezone *py.Object, casting *py.Object) *py.Object

datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind')

Convert an array of datetimes into an array of strings.

Parameters ---------- arr : array_like of datetime64

The array of UTC timestamps to format.

unit : str

One of None, 'auto', or a :ref:`datetime unit <arrays.dtypes.dateunits>`.

timezone : {'naive', 'UTC', 'local'} or tzinfo

Timezone information to use when displaying the datetime. If 'UTC', end
with a Z to indicate UTC time. If 'local', convert to the local timezone
first, and suffix with a +-#### timezone offset. If a tzinfo object,
then do as with 'local', but use the specified timezone.

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}

Casting to allow when changing between datetime units.

Returns ------- str_arr : ndarray

An array of strings the same shape as `arr`.

Examples -------- >>> import pytz >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]') >>> d array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',

'2002-10-27T07:30'], dtype='datetime64[m]')

Setting the timezone to UTC shows the same information, but with a Z suffix ¶

>>> np.datetime_as_string(d, timezone='UTC') array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',

'2002-10-27T07:30Z'], dtype='<U35')

Note that we picked datetimes that cross a DST boundary. Passing in a “pytz“ timezone object will print the appropriate offset

>>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern')) array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',

'2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39')

Passing in a unit will change the precision ¶

>>> np.datetime_as_string(d, unit='h') array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],

dtype='<U32')

>>> np.datetime_as_string(d, unit='s') array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',

'2002-10-27T07:30:00'], dtype='<U38')

'casting' can be used to specify whether precision can be changed

>>> np.datetime_as_string(d, unit='h', casting='safe') Traceback (most recent call last):

...

TypeError: Cannot create a datetime string as units 'h' from a NumPy datetime with units 'm' according to the rule 'safe'

func DatetimeData ¶

func DatetimeData(dtype *py.Object) *py.Object

datetime_data(dtype, /)

Get information about the step size of a date or time type.

The returned tuple can be passed as the second argument of `numpy.datetime64` and
`numpy.timedelta64`.

Parameters
----------
dtype : dtype
    The dtype object, which must be a `datetime64` or `timedelta64` type.

Returns
-------
unit : str
    The :ref:`datetime unit <arrays.dtypes.dateunits>` on which this dtype
    is based.
count : int
    The number of base units in a step.

Examples
--------
>>> dt_25s = np.dtype('timedelta64[25s]')
>>> np.datetime_data(dt_25s)
('s', 25)
>>> np.array(10, dt_25s).astype('timedelta64[s]')
array(250, dtype='timedelta64[s]')

The result can be used to construct a datetime that uses the same units
as a timedelta

>>> np.datetime64('2010', np.datetime_data(dt_25s))
numpy.datetime64('2010-01-01T00:00:00','25s')

func Deg2rad ¶

func Deg2rad(x *py.Object, out *py.Object) *py.Object

deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Convert angles from degrees to radians.

Parameters ---------- x : array_like

Angles in degrees.

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

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 corresponding angle in radians.
This is a scalar if `x` is a scalar.

See Also -------- rad2deg : Convert angles from radians to degrees. unwrap : Remove large jumps in angle by wrapping.

Notes ----- .. versionadded:: 1.3.0

“deg2rad(x)“ is “x * pi / 180“.

Examples -------- >>> np.deg2rad(180) 3.1415926535897931

func Degrees ¶

func Degrees(x *py.Object, out *py.Object) *py.Object

degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Convert angles from radians to degrees.

Parameters ---------- x : array_like

Input array in radians.

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

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 of floats

The corresponding degree values; if `out` was supplied this is a
reference to it.
This is a scalar if `x` is a scalar.

See Also -------- rad2deg : equivalent function

Examples -------- Convert a radian array to degrees

>>> rad = np.arange(12.)*np.pi/6 >>> np.degrees(rad) array([ 0., 30., 60., 90., 120., 150., 180., 210., 240.,

270.,  300.,  330.])

>>> out = np.zeros((rad.shape)) >>> r = np.degrees(rad, out) >>> np.all(r == out) True

func Delete ¶

func Delete(arr *py.Object, obj *py.Object, axis *py.Object) *py.Object

Return a new array with sub-arrays along an axis deleted. For a one dimensional array, this returns those entries not returned by `arr[obj]`.

Parameters ---------- arr : array_like

Input array.

obj : slice, int or array of ints

Indicate indices of sub-arrays to remove along the specified axis.

.. versionchanged:: 1.19.0
    Boolean indices are now treated as a mask of elements to remove,
    rather than being cast to the integers 0 and 1.

axis : int, optional

The axis along which to delete the subarray defined by `obj`.
If `axis` is None, `obj` is applied to the flattened array.

Returns ------- out : ndarray

A copy of `arr` with the elements specified by `obj` removed. Note
that `delete` does not occur in-place. If `axis` is None, `out` is
a flattened array.

See Also -------- insert : Insert elements into an array. append : Append elements at the end of an array.

Notes ----- Often it is preferable to use a boolean mask. For example:

>>> arr = np.arange(12) + 1 >>> mask = np.ones(len(arr), dtype=bool) >>> mask[[0,2,4]] = False >>> result = arr[mask,...]

Is equivalent to “np.delete(arr, [0,2,4], axis=0)“, but allows further use of `mask`.

Examples -------- >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) >>> arr array([[ 1, 2, 3, 4],

[ 5,  6,  7,  8],
[ 9, 10, 11, 12]])

>>> np.delete(arr, 1, 0) array([[ 1, 2, 3, 4],

[ 9, 10, 11, 12]])

>>> np.delete(arr, np.s_[::2], 1) array([[ 2, 4],

[ 6,  8],
[10, 12]])

>>> np.delete(arr, [1,3,5], None) array([ 1, 3, 5, 7, 8, 9, 10, 11, 12])

func Deprecate ¶

func Deprecate(__llgo_va_list ...interface{}) *py.Object

Issues a DeprecationWarning, adds warning to `old_name`'s docstring, rebinds “old_name.__name__“ and returns the new function object.

This function may also be used as a decorator.

Parameters ---------- func : function

The function to be deprecated.

old_name : str, optional

The name of the function to be deprecated. Default is None, in
which case the name of `func` is used.

new_name : str, optional

The new name for the function. Default is None, in which case the
deprecation message is that `old_name` is deprecated. If given, the
deprecation message is that `old_name` is deprecated and `new_name`
should be used instead.

message : str, optional

Additional explanation of the deprecation.  Displayed in the
docstring after the warning.

Returns ------- old_func : function

The deprecated function.

Examples -------- Note that “olduint“ returns a value after printing Deprecation Warning:

>>> olduint = np.deprecate(np.uint) DeprecationWarning: `uint64` is deprecated! # may vary >>> olduint(6) 6

func DeprecateWithDoc ¶

func DeprecateWithDoc(msg *py.Object) *py.Object

Deprecates a function and includes the deprecation in its docstring.

This function is used as a decorator. It returns an object that can be used to issue a DeprecationWarning, by passing the to-be decorated function as argument, this adds warning to the to-be decorated function's docstring and returns the new function object.

See Also -------- deprecate : Decorate a function such that it issues a `DeprecationWarning`

Parameters ---------- msg : str

Additional explanation of the deprecation. Displayed in the
docstring after the warning.

Returns ------- obj : object

func Diag ¶

func Diag(v *py.Object, k *py.Object) *py.Object

Extract a diagonal or construct a diagonal array.

See the more detailed documentation for “numpy.diagonal“ if you use this function to extract a diagonal and wish to write to the resulting array; whether it returns a copy or a view depends on what version of numpy you are using.

Parameters ---------- v : array_like

If `v` is a 2-D array, return a copy of its `k`-th diagonal.
If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
diagonal.

k : int, optional

Diagonal in question. The default is 0. Use `k>0` for diagonals
above the main diagonal, and `k<0` for diagonals below the main
diagonal.

Returns ------- out : ndarray

The extracted diagonal or constructed diagonal array.

See Also -------- diagonal : Return specified diagonals. diagflat : Create a 2-D array with the flattened input as a diagonal. trace : Sum along diagonals. triu : Upper triangle of an array. tril : Lower triangle of an array.

Examples -------- >>> x = np.arange(9).reshape((3,3)) >>> x array([[0, 1, 2],

[3, 4, 5],
[6, 7, 8]])

>>> np.diag(x) array([0, 4, 8]) >>> np.diag(x, k=1) array([1, 5]) >>> np.diag(x, k=-1) array([3, 7])

>>> np.diag(np.diag(x)) array([[0, 0, 0],

[0, 4, 0],
[0, 0, 8]])

func DiagIndices ¶

func DiagIndices(n *py.Object, ndim *py.Object) *py.Object

Return the indices to access the main diagonal of an array.

This returns a tuple of indices that can be used to access the main diagonal of an array `a` with “a.ndim >= 2“ dimensions and shape (n, n, ..., n). For “a.ndim = 2“ this is the usual diagonal, for “a.ndim > 2“ this is the set of indices to access “a[i, i, ..., i]“ for “i = [0..n-1]“.

Parameters ---------- n : int

The size, along each dimension, of the arrays for which the returned
indices can be used.

ndim : int, optional

The number of dimensions.

See Also -------- diag_indices_from

Notes ----- .. versionadded:: 1.4.0

Examples -------- Create a set of indices to access the diagonal of a (4, 4) array:

>>> di = np.diag_indices(4) >>> di (array([0, 1, 2, 3]), array([0, 1, 2, 3])) >>> a = np.arange(16).reshape(4, 4) >>> a array([[ 0, 1, 2, 3],

[ 4,  5,  6,  7],
[ 8,  9, 10, 11],
[12, 13, 14, 15]])

>>> a[di] = 100 >>> a array([[100, 1, 2, 3],

[  4, 100,   6,   7],
[  8,   9, 100,  11],
[ 12,  13,  14, 100]])

Now, we create indices to manipulate a 3-D array:

>>> d3 = np.diag_indices(2, 3) >>> d3 (array([0, 1]), array([0, 1]), array([0, 1]))

And use it to set the diagonal of an array of zeros to 1:

>>> a = np.zeros((2, 2, 2), dtype=int) >>> a[d3] = 1 >>> a array([[[1, 0],

 [0, 0]],
[[0, 0],
 [0, 1]]])

func DiagIndicesFrom ¶

func DiagIndicesFrom(arr *py.Object) *py.Object

Return the indices to access the main diagonal of an n-dimensional array.

See `diag_indices` for full details.

Parameters ---------- arr : array, at least 2-D

See Also -------- diag_indices

Notes ----- .. versionadded:: 1.4.0

Examples --------

Create a 4 by 4 array.

>>> a = np.arange(16).reshape(4, 4) >>> a array([[ 0, 1, 2, 3],

[ 4,  5,  6,  7],
[ 8,  9, 10, 11],
[12, 13, 14, 15]])

Get the indices of the diagonal elements.

>>> di = np.diag_indices_from(a) >>> di (array([0, 1, 2, 3]), array([0, 1, 2, 3]))

>>> a[di] array([ 0, 5, 10, 15])

This is simply syntactic sugar for diag_indices.

>>> np.diag_indices(a.shape[0]) (array([0, 1, 2, 3]), array([0, 1, 2, 3]))

func Diagflat ¶

func Diagflat(v *py.Object, k *py.Object) *py.Object

Create a two-dimensional array with the flattened input as a diagonal.

Parameters ---------- v : array_like

Input data, which is flattened and set as the `k`-th
diagonal of the output.

k : int, optional

Diagonal to set; 0, the default, corresponds to the "main" diagonal,
a positive (negative) `k` giving the number of the diagonal above
(below) the main.

Returns ------- out : ndarray

The 2-D output array.

See Also -------- diag : MATLAB work-alike for 1-D and 2-D arrays. diagonal : Return specified diagonals. trace : Sum along diagonals.

Examples -------- >>> np.diagflat([[1,2], [3,4]]) array([[1, 0, 0, 0],

[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])

>>> np.diagflat([1,2], 1) array([[0, 1, 0],

[0, 0, 2],
[0, 0, 0]])

func Diagonal ¶

func Diagonal(a *py.Object, offset *py.Object, axis1 *py.Object, axis2 *py.Object) *py.Object

Return specified diagonals.

If `a` is 2-D, returns the diagonal of `a` with the given offset, i.e., the collection of elements of the form “a[i, i+offset]“. If `a` has more than two dimensions, then the axes specified by `axis1` and `axis2` are used to determine the 2-D sub-array whose diagonal is returned. The shape of the resulting array can be determined by removing `axis1` and `axis2` and appending an index to the right equal to the size of the resulting diagonals.

In versions of NumPy prior to 1.7, this function always returned a new, independent array containing a copy of the values in the diagonal.

In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal, but depending on this fact is deprecated. Writing to the resulting array continues to work as it used to, but a FutureWarning is issued.

Starting in NumPy 1.9 it returns a read-only view on the original array. Attempting to write to the resulting array will produce an error.

In some future release, it will return a read/write view and writing to the returned array will alter your original array. The returned array will have the same type as the input array.

If you don't write to the array returned by this function, then you can just ignore all of the above.

If you depend on the current behavior, then we suggest copying the returned array explicitly, i.e., use “np.diagonal(a).copy()“ instead of just “np.diagonal(a)“. This will work with both past and future versions of NumPy.

Parameters ---------- a : array_like

Array from which the diagonals are taken.

offset : int, optional

Offset of the diagonal from the main diagonal.  Can be positive or
negative.  Defaults to main diagonal (0).

axis1 : int, optional

Axis to be used as the first axis of the 2-D sub-arrays from which
the diagonals should be taken.  Defaults to first axis (0).

axis2 : int, optional

Axis to be used as the second axis of the 2-D sub-arrays from
which the diagonals should be taken. Defaults to second axis (1).

Returns ------- array_of_diagonals : ndarray

If `a` is 2-D, then a 1-D array containing the diagonal and of the
same type as `a` is returned unless `a` is a `matrix`, in which case
a 1-D array rather than a (2-D) `matrix` is returned in order to
maintain backward compatibility.

If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2`
are removed, and a new axis inserted at the end corresponding to the
diagonal.

Raises ------ ValueError

If the dimension of `a` is less than 2.

See Also -------- diag : MATLAB work-a-like for 1-D and 2-D arrays. diagflat : Create diagonal arrays. trace : Sum along diagonals.

Examples -------- >>> a = np.arange(4).reshape(2,2) >>> a array([[0, 1],

[2, 3]])

>>> a.diagonal() array([0, 3]) >>> a.diagonal(1) array([1])

A 3-D example:

>>> a = np.arange(8).reshape(2,2,2); a array([[[0, 1],

 [2, 3]],
[[4, 5],
 [6, 7]]])

>>> a.diagonal(0, # Main diagonals of two arrays created by skipping ... 0, # across the outer(left)-most axis last and ... 1) # the "middle" (row) axis first. array([[0, 6],

[1, 7]])

The sub-arrays whose main diagonals we just obtained; note that each corresponds to fixing the right-most (column) axis, and that the diagonals are "packed" in rows.

>>> a[:,:,0] # main diagonal is [0 6] array([[0, 2],

[4, 6]])

>>> a[:,:,1] # main diagonal is [1 7] array([[1, 3],

[5, 7]])

The anti-diagonal can be obtained by reversing the order of elements using either `numpy.flipud` or `numpy.fliplr`.

>>> a = np.arange(9).reshape(3, 3) >>> a array([[0, 1, 2],

[3, 4, 5],
[6, 7, 8]])

>>> np.fliplr(a).diagonal() # Horizontal flip array([2, 4, 6]) >>> np.flipud(a).diagonal() # Vertical flip array([6, 4, 2])

Note that the order in which the diagonal is retrieved varies depending on the flip function.

func Diff ¶

func Diff(a *py.Object, n *py.Object, axis *py.Object, prepend *py.Object, append *py.Object) *py.Object

Calculate the n-th discrete difference along the given axis.

The first difference is given by “out[i] = a[i+1] - a[i]“ along the given axis, higher differences are calculated by using `diff` recursively.

Parameters ---------- a : array_like

Input array

n : int, optional

The number of times values are differenced. If zero, the input
is returned as-is.

axis : int, optional

The axis along which the difference is taken, default is the
last axis.

prepend, append : array_like, optional

Values to prepend or append to `a` along axis prior to
performing the difference.  Scalar values are expanded to
arrays with length 1 in the direction of axis and the shape
of the input array in along all other axes.  Otherwise the
dimension and shape must match `a` except along axis.

.. versionadded:: 1.16.0

Returns ------- diff : ndarray

The n-th differences. The shape of the output is the same as `a`
except along `axis` where the dimension is smaller by `n`. The
type of the output is the same as the type of the difference
between any two elements of `a`. This is the same as the type of
`a` in most cases. A notable exception is `datetime64`, which
results in a `timedelta64` output array.

See Also -------- gradient, ediff1d, cumsum

Notes ----- Type is preserved for boolean arrays, so the result will contain `False` when consecutive elements are the same and `True` when they differ.

For unsigned integer arrays, the results will also be unsigned. This should not be surprising, as the result is consistent with calculating the difference directly:

>>> u8_arr = np.array([1, 0], dtype=np.uint8) >>> np.diff(u8_arr) array([255], dtype=uint8) >>> u8_arr[1,...] - u8_arr[0,...] 255

If this is not desirable, then the array should be cast to a larger integer type first:

>>> i16_arr = u8_arr.astype(np.int16) >>> np.diff(i16_arr) array([-1], dtype=int16)

Examples -------- >>> x = np.array([1, 2, 4, 7, 0]) >>> np.diff(x) array([ 1, 2, 3, -7]) >>> np.diff(x, n=2) array([ 1, 1, -10])

>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]]) >>> np.diff(x) array([[2, 3, 4],

[5, 1, 2]])

>>> np.diff(x, axis=0) array([[-1, 2, 0, -2]])

>>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64) >>> np.diff(x) array([1, 1], dtype='timedelta64[D]')

func Digitize ¶

func Digitize(x *py.Object, bins *py.Object, right *py.Object) *py.Object

Return the indices of the bins to which each value in input array belongs.

========= ============= ============================ `right` order of bins returned index `i` satisfies ========= ============= ============================ “False“ increasing “bins[i-1] <= x < bins[i]“ “True“ increasing “bins[i-1] < x <= bins[i]“ “False“ decreasing “bins[i-1] > x >= bins[i]“ “True“ decreasing “bins[i-1] >= x > bins[i]“ ========= ============= ============================

If values in `x` are beyond the bounds of `bins`, 0 or “len(bins)“ is returned as appropriate.

Parameters ---------- x : array_like

Input array to be binned. Prior to NumPy 1.10.0, this array had to
be 1-dimensional, but can now have any shape.

bins : array_like

Array of bins. It has to be 1-dimensional and monotonic.

right : bool, optional

Indicating whether the intervals include the right or the left bin
edge. Default behavior is (right==False) indicating that the interval
does not include the right edge. The left bin end is open in this
case, i.e., bins[i-1] <= x < bins[i] is the default behavior for
monotonically increasing bins.

Returns ------- indices : ndarray of ints

Output array of indices, of same shape as `x`.

Raises ------ ValueError

If `bins` is not monotonic.

TypeError

If the type of the input is complex.

See Also -------- bincount, histogram, unique, searchsorted

Notes ----- If values in `x` are such that they fall outside the bin range, attempting to index `bins` with the indices that `digitize` returns will result in an IndexError.

.. versionadded:: 1.10.0

`np.digitize` is implemented in terms of `np.searchsorted`. This means that a binary search is used to bin the values, which scales much better for larger number of bins than the previous linear search. It also removes the requirement for the input array to be 1-dimensional.

For monotonically _increasing_ `bins`, the following are equivalent::

np.digitize(x, bins, right=True)
np.searchsorted(bins, x, side='left')

Note that as the order of the arguments are reversed, the side must be too. The `searchsorted` call is marginally faster, as it does not do any monotonicity checks. Perhaps more importantly, it supports all dtypes.

Examples -------- >>> x = np.array([0.2, 6.4, 3.0, 1.6]) >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0]) >>> inds = np.digitize(x, bins) >>> inds array([1, 4, 3, 2]) >>> for n in range(x.size): ... print(bins[inds[n]-1], "<=", x[n], "<", bins[inds[n]]) ... 0.0 <= 0.2 < 1.0 4.0 <= 6.4 < 10.0 2.5 <= 3.0 < 4.0 1.0 <= 1.6 < 2.5

>>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.]) >>> bins = np.array([0, 5, 10, 15, 20]) >>> np.digitize(x,bins,right=True) array([1, 2, 3, 4, 4]) >>> np.digitize(x,bins,right=False) array([1, 3, 3, 4, 5])

func Disp ¶

func Disp(mesg *py.Object, device *py.Object, linefeed *py.Object) *py.Object

Display a message on a device.

Parameters ---------- mesg : str

Message to display.

device : object

Device to write message. If None, defaults to ``sys.stdout`` which is
very similar to ``print``. `device` needs to have ``write()`` and
``flush()`` methods.

linefeed : bool, optional

Option whether to print a line feed or not. Defaults to True.

Raises ------ AttributeError

If `device` does not have a ``write()`` or ``flush()`` method.

Examples -------- Besides “sys.stdout“, a file-like object can also be used as it has both required methods:

>>> from io import StringIO >>> buf = StringIO() >>> np.disp(u'"Display" in a file', device=buf) >>> buf.getvalue() '"Display" in a file\n'

func Divide ¶

func Divide(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Divide arguments element-wise.

Parameters ---------- x1 : array_like

Dividend array.

x2 : array_like

Divisor array.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 or scalar

The quotient ``x1/x2``, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- seterr : Set whether to raise or warn on overflow, underflow and

division by zero.

Notes ----- Equivalent to “x1“ / “x2“ in terms of array-broadcasting.

The “true_divide(x1, x2)“ function is an alias for “divide(x1, x2)“.

Examples -------- >>> np.divide(2.0, 4.0) 0.5 >>> x1 = np.arange(9.0).reshape((3, 3)) >>> x2 = np.arange(3.0) >>> np.divide(x1, x2) array([[nan, 1. , 1. ],

[inf, 4. , 2.5],
[inf, 7. , 4. ]])

The “/“ operator can be used as a shorthand for “np.divide“ on ndarrays.

>>> x1 = np.arange(9.0).reshape((3, 3)) >>> x2 = 2 * np.ones(3) >>> x1 / x2 array([[0. , 0.5, 1. ],

[1.5, 2. , 2.5],
[3. , 3.5, 4. ]])

func Divmod ¶

func Divmod(x1 *py.Object, x2 *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object

divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return element-wise quotient and remainder simultaneously.

.. versionadded:: 1.13.0

“np.divmod(x, y)“ is equivalent to “(x // y, x % y)“, but faster because it avoids redundant work. It is used to implement the Python built-in function “divmod“ on NumPy arrays.

Parameters ---------- x1 : array_like

Dividend array.

x2 : array_like

Divisor array.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out1 : ndarray

Element-wise quotient resulting from floor division.
This is a scalar if both `x1` and `x2` are scalars.

out2 : ndarray

Element-wise remainder from floor division.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- floor_divide : Equivalent to Python's “//“ operator. remainder : Equivalent to Python's “%“ operator. modf : Equivalent to “divmod(x, 1)“ for positive “x“ with the return

values switched.

Examples -------- >>> np.divmod(np.arange(5), 3) (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

The `divmod` function can be used as a shorthand for “np.divmod“ on ndarrays.

>>> x = np.arange(5) >>> divmod(x, 3) (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))

func Dot ¶

func Dot(a *py.Object, b *py.Object, out *py.Object) *py.Object

dot(a, b, out=None)

Dot product of two arrays. Specifically,

• If both `a` and `b` are 1-D arrays, it is inner product of vectors (without complex conjugation).

• If both `a` and `b` are 2-D arrays, it is matrix multiplication, but using :func:`matmul` or “a @ b“ is preferred.

• If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply` and using “numpy.multiply(a, b)“ or “a * b“ is preferred.

• If `a` is an N-D array and `b` is a 1-D array, it is a sum product over the last axis of `a` and `b`.

• If `a` is an N-D array and `b` is an M-D array (where “M>=2“), it is a sum product over the last axis of `a` and the second-to-last axis of `b`::

  dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

It uses an optimized BLAS library when possible (see `numpy.linalg`).

Parameters ---------- a : array_like

First argument.

b : array_like

Second argument.

out : ndarray, optional

Output argument. This must have the exact kind that would be returned
if it was not used. In particular, it must have the right type, must be
C-contiguous, and its dtype must be the dtype that would be returned
for `dot(a,b)`. This is a performance feature. Therefore, if these
conditions are not met, an exception is raised, instead of attempting
to be flexible.

Returns ------- output : ndarray

Returns the dot product of `a` and `b`.  If `a` and `b` are both
scalars or both 1-D arrays then a scalar is returned; otherwise
an array is returned.
If `out` is given, then it is returned.

Raises ------ ValueError

If the last dimension of `a` is not the same size as
the second-to-last dimension of `b`.

See Also -------- vdot : Complex-conjugating dot product. tensordot : Sum products over arbitrary axes. einsum : Einstein summation convention. matmul : '@' operator as method with out parameter. linalg.multi_dot : Chained dot product.

Examples -------- >>> np.dot(3, 4) 12

Neither argument is complex-conjugated:

>>> np.dot([2j, 3j], [2j, 3j]) (-13+0j)

For 2-D arrays it is the matrix product:

>>> a = [[1, 0], [0, 1]] >>> b = [[4, 1], [2, 2]] >>> np.dot(a, b) array([[4, 1],

[2, 2]])

>>> a = np.arange(3*4*5*6).reshape((3,4,5,6)) >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) >>> np.dot(a, b)[2,3,2,1,2,2] 499128 >>> sum(a[2,3,2,:] * b[1,2,:,2]) 499128

func Dsplit ¶

func Dsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object

Split array into multiple sub-arrays along the 3rd axis (depth).

Please refer to the `split` documentation. `dsplit` is equivalent to `split` with “axis=2“, the array is always split along the third axis provided the array dimension is greater than or equal to 3.

See Also -------- split : Split an array into multiple sub-arrays of equal size.

Examples -------- >>> x = np.arange(16.0).reshape(2, 2, 4) >>> x array([[[ 0., 1., 2., 3.],

 [ 4.,   5.,   6.,   7.]],
[[ 8.,   9.,  10.,  11.],
 [12.,  13.,  14.,  15.]]])

>>> np.dsplit(x, 2) [array([[[ 0., 1.],

 [ 4.,  5.]],
[[ 8.,  9.],
 [12., 13.]]]), array([[[ 2.,  3.],
 [ 6.,  7.]],
[[10., 11.],
 [14., 15.]]])]

>>> np.dsplit(x, np.array([3, 6])) [array([[[ 0., 1., 2.],

       [ 4.,   5.,   6.]],
      [[ 8.,   9.,  10.],
       [12.,  13.,  14.]]]),
array([[[ 3.],
       [ 7.]],
      [[11.],
       [15.]]]),

array([], shape=(2, 2, 0), dtype=float64)]

func Dstack ¶

func Dstack(tup *py.Object) *py.Object

Stack arrays in sequence depth wise (along third axis).

This is equivalent to concatenation along the third axis after 2-D arrays of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by `dsplit`.

This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions `concatenate`, `stack` and `block` provide more general stacking and concatenation operations.

Parameters ---------- tup : sequence of arrays

The arrays must have the same shape along all but the third axis.
1-D or 2-D arrays must have the same shape.

Returns ------- stacked : ndarray

The array formed by stacking the given arrays, will be at least 3-D.

See Also -------- concatenate : Join a sequence of arrays along an existing axis. stack : Join a sequence of arrays along a new axis. block : Assemble an nd-array from nested lists of blocks. vstack : Stack arrays in sequence vertically (row wise). hstack : Stack arrays in sequence horizontally (column wise). column_stack : Stack 1-D arrays as columns into a 2-D array. dsplit : Split array along third axis.

Examples -------- >>> a = np.array((1,2,3)) >>> b = np.array((2,3,4)) >>> np.dstack((a,b)) array([[[1, 2],

[2, 3],
[3, 4]]])

>>> a = np.array([[1],[2],[3]]) >>> b = np.array([[2],[3],[4]]) >>> np.dstack((a,b)) array([[[1, 2]],

[[2, 3]],
[[3, 4]]])

func Ediff1d ¶

func Ediff1d(ary *py.Object, toEnd *py.Object, toBegin *py.Object) *py.Object

The differences between consecutive elements of an array.

Parameters ---------- ary : array_like

If necessary, will be flattened before the differences are taken.

to_end : array_like, optional

Number(s) to append at the end of the returned differences.

to_begin : array_like, optional

Number(s) to prepend at the beginning of the returned differences.

Returns ------- ediff1d : ndarray

The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.

See Also -------- diff, gradient

Notes ----- When applied to masked arrays, this function drops the mask information if the `to_begin` and/or `to_end` parameters are used.

Examples -------- >>> x = np.array([1, 2, 4, 7, 0]) >>> np.ediff1d(x) array([ 1, 2, 3, -7])

>>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99])) array([-99, 1, 2, ..., -7, 88, 99])

The returned array is always 1D.

>>> y = [[1, 2, 4], [1, 6, 24]] >>> np.ediff1d(y) array([ 1, 2, -3, 5, 18])

func Einsum ¶

func Einsum(__llgo_va_list ...interface{}) *py.Object

einsum(subscripts, *operands, out=None, dtype=None, order='K',

casting='safe', optimize=False)

Evaluates the Einstein summation convention on the operands.

Using the Einstein summation convention, many common multi-dimensional, linear algebraic array operations can be represented in a simple fashion. In *implicit* mode `einsum` computes these values.

In *explicit* mode, `einsum` provides further flexibility to compute other array operations that might not be considered classical Einstein summation operations, by disabling, or forcing summation over specified subscript labels.

See the notes and examples for clarification.

Parameters ---------- subscripts : str

Specifies the subscripts for summation as comma separated list of
subscript labels. An implicit (classical Einstein summation)
calculation is performed unless the explicit indicator '->' is
included as well as subscript labels of the precise output form.

operands : list of array_like

These are the arrays for the operation.

out : ndarray, optional

If provided, the calculation is done into this array.

dtype : {data-type, None}, optional

If provided, forces the calculation to use the data type specified.
Note that you may have to also give a more liberal `casting`
parameter to allow the conversions. Default is None.

order : {'C', 'F', 'A', 'K'}, optional

Controls the memory layout of the output. 'C' means it should
be C contiguous. 'F' means it should be Fortran contiguous,
'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
'K' means it should be as close to the layout as the inputs as
is possible, including arbitrarily permuted axes.
Default is 'K'.

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur.  Setting this to
'unsafe' is not recommended, as it can adversely affect accumulations.

  * 'no' means the data types should not be cast at all.
  * 'equiv' means only byte-order changes are allowed.
  * 'safe' means only casts which can preserve values are allowed.
  * 'same_kind' means only safe casts or casts within a kind,
    like float64 to float32, are allowed.
  * 'unsafe' means any data conversions may be done.

Default is 'safe'.

optimize : {False, True, 'greedy', 'optimal'}, optional

Controls if intermediate optimization should occur. No optimization
will occur if False and True will default to the 'greedy' algorithm.
Also accepts an explicit contraction list from the ``np.einsum_path``
function. See ``np.einsum_path`` for more details. Defaults to False.

Returns ------- output : ndarray

The calculation based on the Einstein summation convention.

See Also -------- einsum_path, dot, inner, outer, tensordot, linalg.multi_dot einops :

similar verbose interface is provided by
`einops <https://github.com/arogozhnikov/einops>`_ package to cover
additional operations: transpose, reshape/flatten, repeat/tile,
squeeze/unsqueeze and reductions.

opt_einsum :

`opt_einsum <https://optimized-einsum.readthedocs.io/en/stable/>`_
optimizes contraction order for einsum-like expressions
in backend-agnostic manner.

Notes ----- .. versionadded:: 1.6.0

The Einstein summation convention can be used to compute many multi-dimensional, linear algebraic array operations. `einsum` provides a succinct way of representing these.

A non-exhaustive list of these operations, which can be computed by `einsum`, is shown below along with examples:

* Trace of an array, :py:func:`numpy.trace`. * Return a diagonal, :py:func:`numpy.diag`. * Array axis summations, :py:func:`numpy.sum`. * Transpositions and permutations, :py:func:`numpy.transpose`. * Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`. * Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`. * Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`. * Tensor contractions, :py:func:`numpy.tensordot`. * Chained array operations, in efficient calculation order, :py:func:`numpy.einsum_path`.

The subscripts string is a comma-separated list of subscript labels, where each label refers to a dimension of the corresponding operand. Whenever a label is repeated it is summed, so “np.einsum('i,i', a, b)“ is equivalent to :py:func:`np.inner(a,b) <numpy.inner>`. If a label appears only once, it is not summed, so “np.einsum('i', a)“ produces a view of “a“ with no changes. A further example “np.einsum('ij,jk', a, b)“ describes traditional matrix multiplication and is equivalent to :py:func:`np.matmul(a,b) <numpy.matmul>`. Repeated subscript labels in one operand take the diagonal. For example, “np.einsum('ii', a)“ is equivalent to :py:func:`np.trace(a) <numpy.trace>`.

In *implicit mode*, the chosen subscripts are important since the axes of the output are reordered alphabetically. This means that “np.einsum('ij', a)“ doesn't affect a 2D array, while “np.einsum('ji', a)“ takes its transpose. Additionally, “np.einsum('ij,jk', a, b)“ returns a matrix multiplication, while, “np.einsum('ij,jh', a, b)“ returns the transpose of the multiplication since subscript 'h' precedes subscript 'i'.

In *explicit mode* the output can be directly controlled by specifying output subscript labels. This requires the identifier '->' as well as the list of output subscript labels. This feature increases the flexibility of the function since summing can be disabled or forced when required. The call “np.einsum('i->', a)“ is like :py:func:`np.sum(a, axis=-1) <numpy.sum>`, and “np.einsum('ii->i', a)“ is like :py:func:`np.diag(a) <numpy.diag>`. The difference is that `einsum` does not allow broadcasting by default. Additionally “np.einsum('ij,jh->ih', a, b)“ directly specifies the order of the output subscript labels and therefore returns matrix multiplication, unlike the example above in implicit mode.

To enable and control broadcasting, use an ellipsis. Default NumPy-style broadcasting is done by adding an ellipsis to the left of each term, like “np.einsum('...ii->...i', a)“. To take the trace along the first and last axes, you can do “np.einsum('i...i', a)“, or to do a matrix-matrix product with the left-most indices instead of rightmost, one can do “np.einsum('ij...,jk...->ik...', a, b)“.

When there is only one operand, no axes are summed, and no output parameter is provided, a view into the operand is returned instead of a new array. Thus, taking the diagonal as “np.einsum('ii->i', a)“ produces a view (changed in version 1.10.0).

`einsum` also provides an alternative way to provide the subscripts and operands as “einsum(op0, sublist0, op1, sublist1, ..., [sublistout])“. If the output shape is not provided in this format `einsum` will be calculated in implicit mode, otherwise it will be performed explicitly. The examples below have corresponding `einsum` calls with the two parameter methods.

.. versionadded:: 1.10.0

Views returned from einsum are now writeable whenever the input array is writeable. For example, “np.einsum('ijk...->kji...', a)“ will now have the same effect as :py:func:`np.swapaxes(a, 0, 2) <numpy.swapaxes>` and “np.einsum('ii->i', a)“ will return a writeable view of the diagonal of a 2D array.

.. versionadded:: 1.12.0

Added the “optimize“ argument which will optimize the contraction order of an einsum expression. For a contraction with three or more operands this can greatly increase the computational efficiency at the cost of a larger memory footprint during computation.

Typically a 'greedy' algorithm is applied which empirical tests have shown returns the optimal path in the majority of cases. In some cases 'optimal' will return the superlative path through a more expensive, exhaustive search. For iterative calculations it may be advisable to calculate the optimal path once and reuse that path by supplying it as an argument. An example is given below.

See :py:func:`numpy.einsum_path` for more details.

Examples -------- >>> a = np.arange(25).reshape(5,5) >>> b = np.arange(5) >>> c = np.arange(6).reshape(2,3)

Trace of a matrix:

>>> np.einsum('ii', a) 60 >>> np.einsum(a, [0,0]) 60 >>> np.trace(a) 60

Extract the diagonal (requires explicit form):

>>> np.einsum('ii->i', a) array([ 0, 6, 12, 18, 24]) >>> np.einsum(a, [0,0], [0]) array([ 0, 6, 12, 18, 24]) >>> np.diag(a) array([ 0, 6, 12, 18, 24])

Sum over an axis (requires explicit form):

>>> np.einsum('ij->i', a) array([ 10, 35, 60, 85, 110]) >>> np.einsum(a, [0,1], [0]) array([ 10, 35, 60, 85, 110]) >>> np.sum(a, axis=1) array([ 10, 35, 60, 85, 110])

For higher dimensional arrays summing a single axis can be done with ellipsis:

>>> np.einsum('...j->...', a) array([ 10, 35, 60, 85, 110]) >>> np.einsum(a, [Ellipsis,1], [Ellipsis]) array([ 10, 35, 60, 85, 110])

Compute a matrix transpose, or reorder any number of axes:

>>> np.einsum('ji', c) array([[0, 3],

[1, 4],
[2, 5]])

>>> np.einsum('ij->ji', c) array([[0, 3],

[1, 4],
[2, 5]])

>>> np.einsum(c, [1,0]) array([[0, 3],

[1, 4],
[2, 5]])

>>> np.transpose(c) array([[0, 3],

[1, 4],
[2, 5]])

Vector inner products:

>>> np.einsum('i,i', b, b) 30 >>> np.einsum(b, [0], b, [0]) 30 >>> np.inner(b,b) 30

Matrix vector multiplication:

>>> np.einsum('ij,j', a, b) array([ 30, 80, 130, 180, 230]) >>> np.einsum(a, [0,1], b, [1]) array([ 30, 80, 130, 180, 230]) >>> np.dot(a, b) array([ 30, 80, 130, 180, 230]) >>> np.einsum('...j,j', a, b) array([ 30, 80, 130, 180, 230])

Broadcasting and scalar multiplication:

>>> np.einsum('..., ...', 3, c) array([[ 0, 3, 6],

[ 9, 12, 15]])

>>> np.einsum(',ij', 3, c) array([[ 0, 3, 6],

[ 9, 12, 15]])

>>> np.einsum(3, [Ellipsis], c, [Ellipsis]) array([[ 0, 3, 6],

[ 9, 12, 15]])

>>> np.multiply(3, c) array([[ 0, 3, 6],

[ 9, 12, 15]])

Vector outer product:

>>> np.einsum('i,j', np.arange(2)+1, b) array([[0, 1, 2, 3, 4],

[0, 2, 4, 6, 8]])

>>> np.einsum(np.arange(2)+1, [0], b, [1]) array([[0, 1, 2, 3, 4],

[0, 2, 4, 6, 8]])

>>> np.outer(np.arange(2)+1, b) array([[0, 1, 2, 3, 4],

[0, 2, 4, 6, 8]])

Tensor contraction:

>>> a = np.arange(60.).reshape(3,4,5) >>> b = np.arange(24.).reshape(4,3,2) >>> np.einsum('ijk,jil->kl', a, b) array([[4400., 4730.],

[4532., 4874.],
[4664., 5018.],
[4796., 5162.],
[4928., 5306.]])

>>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3]) array([[4400., 4730.],

[4532., 4874.],
[4664., 5018.],
[4796., 5162.],
[4928., 5306.]])

>>> np.tensordot(a,b, axes=([1,0],[0,1])) array([[4400., 4730.],

[4532., 4874.],
[4664., 5018.],
[4796., 5162.],
[4928., 5306.]])

Writeable returned arrays (since version 1.10.0):

>>> a = np.zeros((3, 3)) >>> np.einsum('ii->i', a)[:] = 1 >>> a array([[1., 0., 0.],

[0., 1., 0.],
[0., 0., 1.]])

Example of ellipsis use:

>>> a = np.arange(6).reshape((3,2)) >>> b = np.arange(12).reshape((4,3)) >>> np.einsum('ki,jk->ij', a, b) array([[10, 28, 46, 64],

[13, 40, 67, 94]])

>>> np.einsum('ki,...k->i...', a, b) array([[10, 28, 46, 64],

[13, 40, 67, 94]])

>>> np.einsum('k...,jk', a, b) array([[10, 28, 46, 64],

[13, 40, 67, 94]])

Chained array operations. For more complicated contractions, speed ups might be achieved by repeatedly computing a 'greedy' path or pre-computing the 'optimal' path and repeatedly applying it, using an `einsum_path` insertion (since version 1.12.0). Performance improvements can be particularly significant with larger arrays:

>>> a = np.ones(64).reshape(2,4,8)

Basic `einsum`: ~1520ms (benchmarked on 3.1GHz Intel i5.)

>>> for iteration in range(500): ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a)

Sub-optimal `einsum` (due to repeated path calculation time): ~330ms

>>> for iteration in range(500): ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')

Greedy `einsum` (faster optimal path approximation): ~160ms

>>> for iteration in range(500): ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy')

Optimal `einsum` (best usage pattern in some use cases): ~110ms

>>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0] >>> for iteration in range(500): ... _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)

func EinsumPath ¶

func EinsumPath(__llgo_va_list ...interface{}) *py.Object

einsum_path(subscripts, *operands, optimize='greedy')

Evaluates the lowest cost contraction order for an einsum expression by considering the creation of intermediate arrays.

Parameters ---------- subscripts : str

Specifies the subscripts for summation.

*operands : list of array_like

These are the arrays for the operation.

optimize : {bool, list, tuple, 'greedy', 'optimal'}

Choose the type of path. If a tuple is provided, the second argument is
assumed to be the maximum intermediate size created. If only a single
argument is provided the largest input or output array size is used
as a maximum intermediate size.

* if a list is given that starts with ``einsum_path``, uses this as the
  contraction path
* if False no optimization is taken
* if True defaults to the 'greedy' algorithm
* 'optimal' An algorithm that combinatorially explores all possible
  ways of contracting the listed tensors and chooses the least costly
  path. Scales exponentially with the number of terms in the
  contraction.
* 'greedy' An algorithm that chooses the best pair contraction
  at each step. Effectively, this algorithm searches the largest inner,
  Hadamard, and then outer products at each step. Scales cubically with
  the number of terms in the contraction. Equivalent to the 'optimal'
  path for most contractions.

Default is 'greedy'.

Returns ------- path : list of tuples

A list representation of the einsum path.

string_repr : str

A printable representation of the einsum path.

Notes ----- The resulting path indicates which terms of the input contraction should be contracted first, the result of this contraction is then appended to the end of the contraction list. This list can then be iterated over until all intermediate contractions are complete.

See Also -------- einsum, linalg.multi_dot

Examples --------

We can begin with a chain dot example. In this case, it is optimal to contract the “b“ and “c“ tensors first as represented by the first element of the path “(1, 2)“. The resulting tensor is added to the end of the contraction and the remaining contraction “(0, 1)“ is then completed.

>>> np.random.seed(123) >>> a = np.random.rand(2, 2) >>> b = np.random.rand(2, 5) >>> c = np.random.rand(5, 2) >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy') >>> print(path_info[0]) ['einsum_path', (1, 2), (0, 1)] >>> print(path_info[1])

Complete contraction:  ij,jk,kl->il # may vary
       Naive scaling:  4
   Optimized scaling:  3
    Naive FLOP count:  1.600e+02
Optimized FLOP count:  5.600e+01
 Theoretical speedup:  2.857
Largest intermediate:  4.000e+00 elements

------------------------------------------------------------------------- scaling current remaining -------------------------------------------------------------------------

3                   kl,jk->jl                                ij,jl->il
3                   jl,ij->il                                   il->il

A more complex index transformation example.

>>> I = np.random.rand(10, 10, 10, 10) >>> C = np.random.rand(10, 10) >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C, ... optimize='greedy')

>>> print(path_info[0]) ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)] >>> print(path_info[1])

Complete contraction:  ea,fb,abcd,gc,hd->efgh # may vary
       Naive scaling:  8
   Optimized scaling:  5
    Naive FLOP count:  8.000e+08
Optimized FLOP count:  8.000e+05
 Theoretical speedup:  1000.000
Largest intermediate:  1.000e+04 elements

-------------------------------------------------------------------------- scaling current remaining --------------------------------------------------------------------------

5               abcd,ea->bcde                      fb,gc,hd,bcde->efgh
5               bcde,fb->cdef                         gc,hd,cdef->efgh
5               cdef,gc->defg                            hd,defg->efgh
5               defg,hd->efgh                               efgh->efgh

func Empty ¶

func Empty(shape *py.Object, dtype *py.Object, order *py.Object) *py.Object

empty(shape, dtype=float, order='C', *, like=None)

Return a new array of given shape and type, without initializing entries.

Parameters
----------
shape : int or tuple of int
    Shape of the empty array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
    Desired output data-type for the array, e.g, `numpy.int8`. Default is
    `numpy.float64`.
order : {'C', 'F'}, optional, default: 'C'
    Whether to store multi-dimensional data in row-major
    (C-style) or column-major (Fortran-style) order in
    memory.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray
    Array of uninitialized (arbitrary) data of the given shape, dtype, and
    order.  Object arrays will be initialized to None.

See Also
--------
empty_like : Return an empty array with shape and type of input.
ones : Return a new array setting values to one.
zeros : Return a new array setting values to zero.
full : Return a new array of given shape filled with value.

Notes
-----
`empty`, unlike `zeros`, does not set the array values to zero,
and may therefore be marginally faster.  On the other hand, it requires
the user to manually set all the values in the array, and should be
used with caution.

Examples
--------
>>> np.empty([2, 2])
array([[ -9.74499359e+001,   6.69583040e-309],
       [  2.13182611e-314,   3.06959433e-309]])         #uninitialized

>>> np.empty([2, 2], dtype=int)
array([[-1073741821, -1067949133],
       [  496041986,    19249760]])                     #uninitialized

func EmptyLike ¶

func EmptyLike(prototype *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object

empty_like(prototype, dtype=None, order='K', subok=True, shape=None)

Return a new array with the same shape and type as a given array.

Parameters ---------- prototype : array_like

The shape and data-type of `prototype` define these same attributes
of the returned array.

dtype : data-type, optional

Overrides the data type of the result.

.. versionadded:: 1.6.0

order : {'C', 'F', 'A', or 'K'}, optional

Overrides the memory layout of the result. 'C' means C-order,
'F' means F-order, 'A' means 'F' if `prototype` is Fortran
contiguous, 'C' otherwise. 'K' means match the layout of `prototype`
as closely as possible.

.. versionadded:: 1.6.0

subok : bool, optional.

If True, then the newly created array will use the sub-class
type of `prototype`, otherwise it will be a base-class array. Defaults
to True.

shape : int or sequence of ints, optional.

Overrides the shape of the result. If order='K' and the number of
dimensions is unchanged, will try to keep order, otherwise,
order='C' is implied.

.. versionadded:: 1.17.0

Returns ------- out : ndarray

Array of uninitialized (arbitrary) data with the same
shape and type as `prototype`.

See Also -------- ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array.

Notes ----- This function does *not* initialize the returned array; to do that use `zeros_like` or `ones_like` instead. It may be marginally faster than the functions that do set the array values.

Examples -------- >>> a = ([1,2,3], [4,5,6]) # a is array-like >>> np.empty_like(a) array([[-1073741821, -1073741821, 3], # uninitialized

[          0,           0, -1073741821]])

>>> a = np.array([[1., 2., 3.],[4.,5.,6.]]) >>> np.empty_like(a) array([[ -2.00000715e+000, 1.48219694e-323, -2.00000572e+000], # uninitialized

[  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])

func Equal ¶

func Equal(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return (x1 == x2) element-wise.

Parameters ---------- x1, x2 : array_like

Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : ndarray or scalar

Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- not_equal, greater_equal, less_equal, greater, less

Examples -------- >>> np.equal([0, 1, 3], np.arange(3)) array([ True, True, False])

What is compared are values, not types. So an int (1) and an array of length one can evaluate as True:

>>> np.equal(1, np.ones(1)) array([ True])

The “==“ operator can be used as a shorthand for “np.equal“ on ndarrays.

>>> a = np.array([2, 4, 6]) >>> b = np.array([2, 4, 2]) >>> a == b array([ True, True, False])

func Exp ¶

func Exp(x *py.Object, out *py.Object) *py.Object

exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Calculate the exponential of all elements in the input array.

Parameters ---------- x : array_like

Input values.

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

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 ------- out : ndarray or scalar

Output array, element-wise exponential of `x`.
This is a scalar if `x` is a scalar.

See Also -------- expm1 : Calculate “exp(x) - 1“ for all elements in the array. exp2 : Calculate “2**x“ for all elements in the array.

Notes ----- The irrational number “e“ is also known as Euler's number. It is approximately 2.718281, and is the base of the natural logarithm, “ln“ (this means that, if :math:`x = \ln y = \log_e y`, then :math:`e^x = y`. For real input, “exp(x)“ is always positive.

For complex arguments, “x = a + ib“, we can write :math:`e^x = e^a e^{ib}`. The first term, :math:`e^a`, is already known (it is the real argument, described above). The second term, :math:`e^{ib}`, is :math:`\cos b + i \sin b`, a function with magnitude 1 and a periodic phase.

References ---------- .. [1] Wikipedia, "Exponential function",

https://en.wikipedia.org/wiki/Exponential_function

.. [2] M. Abramovitz and I. A. Stegun, "Handbook of Mathematical Functions

with Formulas, Graphs, and Mathematical Tables," Dover, 1964, p. 69,
https://personal.math.ubc.ca/~cbm/aands/page_69.htm

Examples -------- Plot the magnitude and phase of “exp(x)“ in the complex plane:

>>> import matplotlib.pyplot as plt

>>> x = np.linspace(-2*np.pi, 2*np.pi, 100) >>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane >>> out = np.exp(xx)

>>> plt.subplot(121) >>> plt.imshow(np.abs(out), ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray') >>> plt.title('Magnitude of exp(x)')

>>> plt.subplot(122) >>> plt.imshow(np.angle(out), ... extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv') >>> plt.title('Phase (angle) of exp(x)') >>> plt.show()

func Exp2 ¶

func Exp2(x *py.Object, out *py.Object) *py.Object

exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Calculate `2**p` for all `p` in the input array.

Parameters ---------- x : array_like

Input values.

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

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 ------- out : ndarray or scalar

Element-wise 2 to the power `x`.
This is a scalar if `x` is a scalar.

See Also -------- power

Notes ----- .. versionadded:: 1.3.0

Examples -------- >>> np.exp2([2, 3]) array([ 4., 8.])

func ExpandDims ¶

func ExpandDims(a *py.Object, axis *py.Object) *py.Object

Expand the shape of an array.

Insert a new axis that will appear at the `axis` position in the expanded array shape.

Parameters ---------- a : array_like

Input array.

axis : int or tuple of ints

Position in the expanded axes where the new axis (or axes) is placed.

.. deprecated:: 1.13.0
    Passing an axis where ``axis > a.ndim`` will be treated as
    ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will
    be treated as ``axis == 0``. This behavior is deprecated.

.. versionchanged:: 1.18.0
    A tuple of axes is now supported.  Out of range axes as
    described above are now forbidden and raise an `AxisError`.

Returns ------- result : ndarray

View of `a` with the number of dimensions increased.

See Also -------- squeeze : The inverse operation, removing singleton dimensions reshape : Insert, remove, and combine dimensions, and resize existing ones doc.indexing, atleast_1d, atleast_2d, atleast_3d

Examples -------- >>> x = np.array([1, 2]) >>> x.shape (2,)

The following is equivalent to “x[np.newaxis, :]“ or “x[np.newaxis]“:

>>> y = np.expand_dims(x, axis=0) >>> y array([[1, 2]]) >>> y.shape (1, 2)

The following is equivalent to “x[:, np.newaxis]“:

>>> y = np.expand_dims(x, axis=1) >>> y array([[1],

[2]])

>>> y.shape (2, 1)

“axis“ may also be a tuple:

>>> y = np.expand_dims(x, axis=(0, 1)) >>> y array([[[1, 2]]])

>>> y = np.expand_dims(x, axis=(2, 0)) >>> y array([[[1],

[2]]])

Note that some examples may use “None“ instead of “np.newaxis“. These are the same objects:

>>> np.newaxis is None True

func Expm1 ¶

func Expm1(x *py.Object, out *py.Object) *py.Object

expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Calculate “exp(x) - 1“ for all elements in the array.

Parameters ---------- x : array_like

Input values.

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

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 ------- out : ndarray or scalar

Element-wise exponential minus one: ``out = exp(x) - 1``.
This is a scalar if `x` is a scalar.

See Also -------- log1p : “log(1 + x)“, the inverse of expm1.

Notes ----- This function provides greater precision than “exp(x) - 1“ for small values of “x“.

Examples -------- The true value of “exp(1e-10) - 1“ is “1.00000000005e-10“ to about 32 significant digits. This example shows the superiority of expm1 in this case.

>>> np.expm1(1e-10) 1.00000000005e-10 >>> np.exp(1e-10) - 1 1.000000082740371e-10

func Extract ¶

func Extract(condition *py.Object, arr *py.Object) *py.Object

Return the elements of an array that satisfy some condition.

This is equivalent to “np.compress(ravel(condition), ravel(arr))“. If `condition` is boolean “np.extract“ is equivalent to “arr[condition]“.

Note that `place` does the exact opposite of `extract`.

Parameters ---------- condition : array_like

An array whose nonzero or True entries indicate the elements of `arr`
to extract.

arr : array_like

Input array of the same size as `condition`.

Returns ------- extract : ndarray

Rank 1 array of values from `arr` where `condition` is True.

See Also -------- take, put, copyto, compress, place

Examples -------- >>> arr = np.arange(12).reshape((3, 4)) >>> arr array([[ 0, 1, 2, 3],

[ 4,  5,  6,  7],
[ 8,  9, 10, 11]])

>>> condition = np.mod(arr, 3)==0 >>> condition array([[ True, False, False, True],

[False, False,  True, False],
[False,  True, False, False]])

>>> np.extract(condition, arr) array([0, 3, 6, 9])

If `condition` is boolean:

>>> arr[condition] array([0, 3, 6, 9])

func Eye ¶

func Eye(N *py.Object, M *py.Object, k *py.Object, dtype *py.Object, order *py.Object) *py.Object

Return a 2-D array with ones on the diagonal and zeros elsewhere.

Parameters ---------- N : int

Number of rows in the output.

M : int, optional

Number of columns in the output. If None, defaults to `N`.

k : int, optional

Index of the diagonal: 0 (the default) refers to the main diagonal,
a positive value refers to an upper diagonal, and a negative value
to a lower diagonal.

dtype : data-type, optional

Data-type of the returned array.

order : {'C', 'F'}, optional

Whether the output should be stored in row-major (C-style) or
column-major (Fortran-style) order in memory.

.. versionadded:: 1.14.0

like : array_like, optional

Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns ------- I : ndarray of shape (N,M)

An array where all elements are equal to zero, except for the `k`-th
diagonal, whose values are equal to one.

See Also -------- identity : (almost) equivalent function diag : diagonal 2-D array from a 1-D array specified by the user.

Examples -------- >>> np.eye(2, dtype=int) array([[1, 0],

[0, 1]])

>>> np.eye(3, k=1) array([[0., 1., 0.],

[0.,  0.,  1.],
[0.,  0.,  0.]])

func Fabs ¶

func Fabs(x *py.Object, out *py.Object) *py.Object

fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Compute the absolute values element-wise.

This function returns the absolute values (positive magnitude) of the data in `x`. Complex values are not handled, use `absolute` to find the absolute values of complex data.

Parameters ---------- x : array_like

The array of numbers for which the absolute values are required. If
`x` is a scalar, the result `y` will also be a scalar.

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

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 or scalar

The absolute values of `x`, the returned values are always floats.
This is a scalar if `x` is a scalar.

See Also -------- absolute : Absolute values including `complex` types.

Examples -------- >>> np.fabs(-1) 1.0 >>> np.fabs([-1.2, 1.2]) array([ 1.2, 1.2])

func FastCopyAndTranspose ¶

func FastCopyAndTranspose(a *py.Object) *py.Object

fastCopyAndTranspose(a)

.. deprecated:: 1.24

   fastCopyAndTranspose is deprecated and will be removed. Use the copy and
   transpose methods instead, e.g. ``arr.T.copy()``

func FillDiagonal ¶

func FillDiagonal(a *py.Object, val *py.Object, wrap *py.Object) *py.Object

Fill the main diagonal of the given array of any dimensionality.

For an array `a` with ``a.ndim >= 2``, the diagonal is the list of
locations with indices ``a[i, ..., i]`` all identical. This function
modifies the input array in-place, it does not return a value.

Parameters
----------
a : array, at least 2-D.
  Array whose diagonal is to be filled, it gets modified in-place.

val : scalar or array_like
  Value(s) to write on the diagonal. If `val` is scalar, the value is
  written along the diagonal. If array-like, the flattened `val` is
  written along the diagonal, repeating if necessary to fill all
  diagonal entries.

wrap : bool
  For tall matrices in NumPy version up to 1.6.2, the
  diagonal "wrapped" after N columns. You can have this behavior
  with this option. This affects only tall matrices.

See also
--------
diag_indices, diag_indices_from

Notes
-----
.. versionadded:: 1.4.0

This functionality can be obtained via `diag_indices`, but internally
this version uses a much faster implementation that never constructs the
indices and uses simple slicing.

Examples
--------
>>> a = np.zeros((3, 3), int)
>>> np.fill_diagonal(a, 5)
>>> a
array([[5, 0, 0],
       [0, 5, 0],
       [0, 0, 5]])

The same function can operate on a 4-D array:

>>> a = np.zeros((3, 3, 3, 3), int)
>>> np.fill_diagonal(a, 4)

We only show a few blocks for clarity:

>>> a[0, 0]
array([[4, 0, 0],
       [0, 0, 0],
       [0, 0, 0]])
>>> a[1, 1]
array([[0, 0, 0],
       [0, 4, 0],
       [0, 0, 0]])
>>> a[2, 2]
array([[0, 0, 0],
       [0, 0, 0],
       [0, 0, 4]])

The wrap option affects only tall matrices:

>>> # tall matrices no wrap
>>> a = np.zeros((5, 3), int)
>>> np.fill_diagonal(a, 4)
>>> a
array([[4, 0, 0],
       [0, 4, 0],
       [0, 0, 4],
       [0, 0, 0],
       [0, 0, 0]])

>>> # tall matrices wrap
>>> a = np.zeros((5, 3), int)
>>> np.fill_diagonal(a, 4, wrap=True)
>>> a
array([[4, 0, 0],
       [0, 4, 0],
       [0, 0, 4],
       [0, 0, 0],
       [4, 0, 0]])

>>> # wide matrices
>>> a = np.zeros((3, 5), int)
>>> np.fill_diagonal(a, 4, wrap=True)
>>> a
array([[4, 0, 0, 0, 0],
       [0, 4, 0, 0, 0],
       [0, 0, 4, 0, 0]])

The anti-diagonal can be filled by reversing the order of elements
using either `numpy.flipud` or `numpy.fliplr`.

>>> a = np.zeros((3, 3), int);
>>> np.fill_diagonal(np.fliplr(a), [1,2,3])  # Horizontal flip
>>> a
array([[0, 0, 1],
       [0, 2, 0],
       [3, 0, 0]])
>>> np.fill_diagonal(np.flipud(a), [1,2,3])  # Vertical flip
>>> a
array([[0, 0, 3],
       [0, 2, 0],
       [1, 0, 0]])

Note that the order in which the diagonal is filled varies depending
on the flip function.

func FindCommonType ¶

func FindCommonType(arrayTypes *py.Object, scalarTypes *py.Object) *py.Object

Determine common type following standard coercion rules.

.. deprecated:: NumPy 1.25

This function is deprecated, use `numpy.promote_types` or
`numpy.result_type` instead.  To achieve semantics for the
`scalar_types` argument, use `numpy.result_type` and pass the Python
values `0`, `0.0`, or `0j`.
This will give the same results in almost all cases.
More information and rare exception can be found in the
`NumPy 1.25 release notes <https://numpy.org/devdocs/release/1.25.0-notes.html>`_.

Parameters ---------- array_types : sequence

A list of dtypes or dtype convertible objects representing arrays.

scalar_types : sequence

A list of dtypes or dtype convertible objects representing scalars.

Returns ------- datatype : dtype

The common data type, which is the maximum of `array_types` ignoring
`scalar_types`, unless the maximum of `scalar_types` is of a
different kind (`dtype.kind`). If the kind is not understood, then
None is returned.

See Also -------- dtype, common_type, can_cast, mintypecode

Examples -------- >>> np.find_common_type([], [np.int64, np.float32, complex]) dtype('complex128') >>> np.find_common_type([np.int64, np.float32], []) dtype('float64')

The standard casting rules ensure that a scalar cannot up-cast an array unless the scalar is of a fundamentally different kind of data (i.e. under a different hierarchy in the data type hierarchy) then the array:

>>> np.find_common_type([np.float32], [np.int64, np.float64]) dtype('float32')

Complex is of a different type, so it up-casts the float in the `array_types` argument:

>>> np.find_common_type([np.float32], [complex]) dtype('complex128')

Type specifier strings are convertible to dtypes and can therefore be used instead of dtypes:

>>> np.find_common_type(['f4', 'f4', 'i4'], ['c8']) dtype('complex128')

func Fix ¶

func Fix(x *py.Object, out *py.Object) *py.Object

Round to nearest integer towards zero.

Round an array of floats element-wise to nearest integer towards zero. The rounded values are returned as floats.

Parameters ---------- x : array_like

An array of floats to be rounded

out : ndarray, optional

A location into which the result is stored. If provided, it must have
a shape that the input broadcasts to. If not provided or None, a
freshly-allocated array is returned.

Returns ------- out : ndarray of floats

A float array with the same dimensions as the input.
If second argument is not supplied then a float array is returned
with the rounded values.

If a second argument is supplied the result is stored there.
The return value `out` is then a reference to that array.

See Also -------- rint, trunc, floor, ceil around : Round to given number of decimals

Examples -------- >>> np.fix(3.14) 3.0 >>> np.fix(3) 3.0 >>> np.fix([2.1, 2.9, -2.1, -2.9]) array([ 2., 2., -2., -2.])

func Flatnonzero ¶

func Flatnonzero(a *py.Object) *py.Object

Return indices that are non-zero in the flattened version of a.

This is equivalent to “np.nonzero(np.ravel(a))[0]“.

Parameters ---------- a : array_like

Input data.

Returns ------- res : ndarray

Output array, containing the indices of the elements of ``a.ravel()``
that are non-zero.

See Also -------- nonzero : Return the indices of the non-zero elements of the input array. ravel : Return a 1-D array containing the elements of the input array.

Examples -------- >>> x = np.arange(-2, 3) >>> x array([-2, -1, 0, 1, 2]) >>> np.flatnonzero(x) array([0, 1, 3, 4])

Use the indices of the non-zero elements as an index array to extract these elements:

>>> x.ravel()[np.flatnonzero(x)] array([-2, -1, 1, 2])

func Flip ¶

func Flip(m *py.Object, axis *py.Object) *py.Object

Reverse the order of elements in an array along the given axis.

The shape of the array is preserved, but the elements are reordered.

.. versionadded:: 1.12.0

Parameters ---------- m : array_like

Input array.

axis : None or int or tuple of ints, optional

Axis or axes along which to flip over. The default,
axis=None, will flip over all of the axes of the input array.
If axis is negative it counts from the last to the first axis.

If axis is a tuple of ints, flipping is performed on all of the axes
specified in the tuple.

.. versionchanged:: 1.15.0
   None and tuples of axes are supported

Returns ------- out : array_like

A view of `m` with the entries of axis reversed.  Since a view is
returned, this operation is done in constant time.

See Also -------- flipud : Flip an array vertically (axis=0). fliplr : Flip an array horizontally (axis=1).

Notes ----- flip(m, 0) is equivalent to flipud(m).

flip(m, 1) is equivalent to fliplr(m).

flip(m, n) corresponds to “m[...,::-1,...]“ with “::-1“ at position n.

flip(m) corresponds to “m[::-1,::-1,...,::-1]“ with “::-1“ at all positions.

flip(m, (0, 1)) corresponds to “m[::-1,::-1,...]“ with “::-1“ at position 0 and position 1.

Examples -------- >>> A = np.arange(8).reshape((2,2,2)) >>> A array([[[0, 1],

 [2, 3]],
[[4, 5],
 [6, 7]]])

>>> np.flip(A, 0) array([[[4, 5],

 [6, 7]],
[[0, 1],
 [2, 3]]])

>>> np.flip(A, 1) array([[[2, 3],

 [0, 1]],
[[6, 7],
 [4, 5]]])

>>> np.flip(A) array([[[7, 6],

 [5, 4]],
[[3, 2],
 [1, 0]]])

>>> np.flip(A, (0, 2)) array([[[5, 4],

 [7, 6]],
[[1, 0],
 [3, 2]]])

>>> A = np.random.randn(3,4,5) >>> np.all(np.flip(A,2) == A[:,:,::-1,...]) True

func Fliplr ¶

func Fliplr(m *py.Object) *py.Object

Reverse the order of elements along axis 1 (left/right).

For a 2-D array, this flips the entries in each row in the left/right direction. Columns are preserved, but appear in a different order than before.

Parameters ---------- m : array_like

Input array, must be at least 2-D.

Returns ------- f : ndarray

A view of `m` with the columns reversed.  Since a view
is returned, this operation is :math:`\mathcal O(1)`.

See Also -------- flipud : Flip array in the up/down direction. flip : Flip array in one or more dimensions. rot90 : Rotate array counterclockwise.

Notes ----- Equivalent to “m[:,::-1]“ or “np.flip(m, axis=1)“. Requires the array to be at least 2-D.

Examples -------- >>> A = np.diag([1.,2.,3.]) >>> A array([[1., 0., 0.],

[0.,  2.,  0.],
[0.,  0.,  3.]])

>>> np.fliplr(A) array([[0., 0., 1.],

[0.,  2.,  0.],
[3.,  0.,  0.]])

>>> A = np.random.randn(2,3,5) >>> np.all(np.fliplr(A) == A[:,::-1,...]) True

func Flipud ¶

func Flipud(m *py.Object) *py.Object

Reverse the order of elements along axis 0 (up/down).

For a 2-D array, this flips the entries in each column in the up/down direction. Rows are preserved, but appear in a different order than before.

Parameters ---------- m : array_like

Input array.

Returns ------- out : array_like

A view of `m` with the rows reversed.  Since a view is
returned, this operation is :math:`\mathcal O(1)`.

See Also -------- fliplr : Flip array in the left/right direction. flip : Flip array in one or more dimensions. rot90 : Rotate array counterclockwise.

Notes ----- Equivalent to “m[::-1, ...]“ or “np.flip(m, axis=0)“. Requires the array to be at least 1-D.

Examples -------- >>> A = np.diag([1.0, 2, 3]) >>> A array([[1., 0., 0.],

[0.,  2.,  0.],
[0.,  0.,  3.]])

>>> np.flipud(A) array([[0., 0., 3.],

[0.,  2.,  0.],
[1.,  0.,  0.]])

>>> A = np.random.randn(2,3,5) >>> np.all(np.flipud(A) == A[::-1,...]) True

>>> np.flipud([1,2]) array([2, 1])

func FloatPower ¶

func FloatPower(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

First array elements raised to powers from second array, element-wise.

Raise each base in `x1` to the positionally-corresponding power in `x2`. `x1` and `x2` must be broadcastable to the same shape. This differs from the power function in that integers, float16, and float32 are promoted to floats with a minimum precision of float64 so that the result is always inexact. The intent is that the function will return a usable result for negative powers and seldom overflow for positive powers.

Negative values raised to a non-integral value will return “nan“. To get complex results, cast the input to complex, or specify the “dtype“ to be “complex“ (see the example below).

.. versionadded:: 1.12.0

Parameters ---------- x1 : array_like

The bases.

x2 : array_like

The exponents.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 bases in `x1` raised to the exponents in `x2`.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- power : power function that preserves type

Examples -------- Cube each element in a list.

>>> x1 = range(6) >>> x1 [0, 1, 2, 3, 4, 5] >>> np.float_power(x1, 3) array([ 0., 1., 8., 27., 64., 125.])

Raise the bases to different exponents.

>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] >>> np.float_power(x1, x2) array([ 0., 1., 8., 27., 16., 5.])

The effect of broadcasting.

>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]]) >>> x2 array([[1, 2, 3, 3, 2, 1],

[1, 2, 3, 3, 2, 1]])

>>> np.float_power(x1, x2) array([[ 0., 1., 8., 27., 16., 5.],

[  0.,   1.,   8.,  27.,  16.,   5.]])

Negative values raised to a non-integral value will result in “nan“ (and a warning will be generated).

>>> x3 = np.array([-1, -4]) >>> with np.errstate(invalid='ignore'): ... p = np.float_power(x3, 1.5) ... >>> p array([nan, nan])

To get complex results, give the argument “dtype=complex“.

>>> np.float_power(x3, 1.5, dtype=complex) array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])

func Floor ¶

func Floor(x *py.Object, out *py.Object) *py.Object

floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the floor of the input, element-wise.

The floor of the scalar `x` is the largest integer `i`, such that `i <= x`. It is often denoted as :math:`\lfloor x \rfloor`.

Parameters ---------- x : array_like

Input data.

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

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 or scalar

The floor of each element in `x`.
This is a scalar if `x` is a scalar.

See Also -------- ceil, trunc, rint, fix

Notes ----- Some spreadsheet programs calculate the "floor-towards-zero", where “floor(-2.5) == -2“. NumPy instead uses the definition of `floor` where `floor(-2.5) == -3`. The "floor-towards-zero" function is called “fix“ in NumPy.

Examples -------- >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) >>> np.floor(a) array([-2., -2., -1., 0., 1., 1., 2.])

func FloorDivide ¶

func FloorDivide(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the largest integer smaller or equal to the division of the inputs. It is equivalent to the Python “//“ operator and pairs with the Python “%“ (`remainder`), function so that “a = a % b + b * (a // b)“ up to roundoff.

Parameters ---------- x1 : array_like

Numerator.

x2 : array_like

Denominator.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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

y = floor(`x1`/`x2`)
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- remainder : Remainder complementary to floor_divide. divmod : Simultaneous floor division and remainder. divide : Standard division. floor : Round a number to the nearest integer toward minus infinity. ceil : Round a number to the nearest integer toward infinity.

Examples -------- >>> np.floor_divide(7,3) 2 >>> np.floor_divide([1., 2., 3., 4.], 2.5) array([ 0., 0., 1., 1.])

The “//“ operator can be used as a shorthand for “np.floor_divide“ on ndarrays.

>>> x1 = np.array([1., 2., 3., 4.]) >>> x1 // 2.5 array([0., 0., 1., 1.])

func Fmax ¶

func Fmax(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Element-wise maximum of array elements.

Compare two arrays and return a new array containing the element-wise maxima. If one of the elements being compared is a NaN, then the non-nan element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are ignored when possible.

Parameters ---------- x1, x2 : array_like

The arrays holding the elements to be compared.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 or scalar

The maximum of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- fmin :

Element-wise minimum of two arrays, ignores NaNs.

maximum :

Element-wise maximum of two arrays, propagates NaNs.

amax :

The maximum value of an array along a given axis, propagates NaNs.

nanmax :

The maximum value of an array along a given axis, ignores NaNs.

minimum, amin, nanmin

Notes ----- .. versionadded:: 1.3.0

The fmax is equivalent to “np.where(x1 >= x2, x1, x2)“ when neither x1 nor x2 are NaNs, but it is faster and does proper broadcasting.

Examples -------- >>> np.fmax([2, 3, 4], [1, 5, 2]) array([ 2., 5., 4.])

>>> np.fmax(np.eye(2), [0.5, 2]) array([[ 1. , 2. ],

[ 0.5,  2. ]])

>>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) array([ 0., 0., nan])

func Fmin ¶

func Fmin(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Element-wise minimum of array elements.

Compare two arrays and return a new array containing the element-wise minima. If one of the elements being compared is a NaN, then the non-nan element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are ignored when possible.

Parameters ---------- x1, x2 : array_like

The arrays holding the elements to be compared.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 or scalar

The minimum of `x1` and `x2`, element-wise.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- fmax :

Element-wise maximum of two arrays, ignores NaNs.

minimum :

Element-wise minimum of two arrays, propagates NaNs.

amin :

The minimum value of an array along a given axis, propagates NaNs.

nanmin :

The minimum value of an array along a given axis, ignores NaNs.

maximum, amax, nanmax

Notes ----- .. versionadded:: 1.3.0

The fmin is equivalent to “np.where(x1 <= x2, x1, x2)“ when neither x1 nor x2 are NaNs, but it is faster and does proper broadcasting.

Examples -------- >>> np.fmin([2, 3, 4], [1, 5, 2]) array([1, 3, 2])

>>> np.fmin(np.eye(2), [0.5, 2]) array([[ 0.5, 0. ],

[ 0. ,  1. ]])

>>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) array([ 0., 0., nan])

func Fmod ¶

func Fmod(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Returns the element-wise remainder of division.

This is the NumPy implementation of the C library function fmod, the remainder has the same sign as the dividend `x1`. It is equivalent to the Matlab(TM) “rem“ function and should not be confused with the Python modulus operator “x1 % x2“.

Parameters ---------- x1 : array_like

Dividend.

x2 : array_like

Divisor.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 : array_like

The remainder of the division of `x1` by `x2`.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- remainder : Equivalent to the Python “%“ operator. divide

Notes ----- The result of the modulo operation for negative dividend and divisors is bound by conventions. For `fmod`, the sign of result is the sign of the dividend, while for `remainder` the sign of the result is the sign of the divisor. The `fmod` function is equivalent to the Matlab(TM) “rem“ function.

Examples -------- >>> np.fmod([-3, -2, -1, 1, 2, 3], 2) array([-1, 0, -1, 1, 0, 1]) >>> np.remainder([-3, -2, -1, 1, 2, 3], 2) array([1, 0, 1, 1, 0, 1])

>>> np.fmod([5, 3], [2, 2.]) array([ 1., 1.]) >>> a = np.arange(-3, 3).reshape(3, 2) >>> a array([[-3, -2],

[-1,  0],
[ 1,  2]])

>>> np.fmod(a, [2,2]) array([[-1, 0],

[-1,  0],
[ 1,  0]])

func FormatFloatPositional ¶

func FormatFloatPositional(x *py.Object, precision *py.Object, unique *py.Object, fractional *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, padRight *py.Object, minDigits *py.Object) *py.Object

Format a floating-point scalar as a decimal string in positional notation.

Provides control over rounding, trimming and padding. Uses and assumes IEEE unbiased rounding. Uses the "Dragon4" algorithm.

Parameters ---------- x : python float or numpy floating scalar

Value to format.

precision : non-negative integer or None, optional

Maximum number of digits to print. May be None if `unique` is
`True`, but must be an integer if unique is `False`.

unique : boolean, optional

If `True`, use a digit-generation strategy which gives the shortest
representation which uniquely identifies the floating-point number from
other values of the same type, by judicious rounding. If `precision`
is given fewer digits than necessary can be printed, or if `min_digits`
is given more can be printed, in which cases the last digit is rounded
with unbiased rounding.
If `False`, digits are generated as if printing an infinite-precision
value and stopping after `precision` digits, rounding the remaining
value with unbiased rounding

fractional : boolean, optional

If `True`, the cutoffs of `precision` and `min_digits` refer to the
total number of digits after the decimal point, including leading
zeros.
If `False`, `precision` and `min_digits` refer to the total number of
significant digits, before or after the decimal point, ignoring leading
zeros.

trim : one of 'k', '.', '0', '-', optional

Controls post-processing trimming of trailing digits, as follows:

* 'k' : keep trailing zeros, keep decimal point (no trimming)
* '.' : trim all trailing zeros, leave decimal point
* '0' : trim all but the zero before the decimal point. Insert the
  zero if it is missing.
* '-' : trim trailing zeros and any trailing decimal point

sign : boolean, optional

Whether to show the sign for positive values.

pad_left : non-negative integer, optional

Pad the left side of the string with whitespace until at least that
many characters are to the left of the decimal point.

pad_right : non-negative integer, optional

Pad the right side of the string with whitespace until at least that
many characters are to the right of the decimal point.

min_digits : non-negative integer or None, optional

Minimum number of digits to print. Only has an effect if `unique=True`
in which case additional digits past those necessary to uniquely
identify the value may be printed, rounding the last additional digit.

-- versionadded:: 1.21.0

Returns ------- rep : string

The string representation of the floating point value

See Also -------- format_float_scientific

Examples -------- >>> np.format_float_positional(np.float32(np.pi)) '3.1415927' >>> np.format_float_positional(np.float16(np.pi)) '3.14' >>> np.format_float_positional(np.float16(0.3)) '0.3' >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10) '0.3000488281'

func FormatFloatScientific ¶

func FormatFloatScientific(x *py.Object, precision *py.Object, unique *py.Object, trim *py.Object, sign *py.Object, padLeft *py.Object, expDigits *py.Object, minDigits *py.Object) *py.Object

Format a floating-point scalar as a decimal string in scientific notation.

Provides control over rounding, trimming and padding. Uses and assumes IEEE unbiased rounding. Uses the "Dragon4" algorithm.

Parameters ---------- x : python float or numpy floating scalar

Value to format.

precision : non-negative integer or None, optional

Maximum number of digits to print. May be None if `unique` is
`True`, but must be an integer if unique is `False`.

unique : boolean, optional

If `True`, use a digit-generation strategy which gives the shortest
representation which uniquely identifies the floating-point number from
other values of the same type, by judicious rounding. If `precision`
is given fewer digits than necessary can be printed. If `min_digits`
is given more can be printed, in which cases the last digit is rounded
with unbiased rounding.
If `False`, digits are generated as if printing an infinite-precision
value and stopping after `precision` digits, rounding the remaining
value with unbiased rounding

trim : one of 'k', '.', '0', '-', optional

Controls post-processing trimming of trailing digits, as follows:

* 'k' : keep trailing zeros, keep decimal point (no trimming)
* '.' : trim all trailing zeros, leave decimal point
* '0' : trim all but the zero before the decimal point. Insert the
  zero if it is missing.
* '-' : trim trailing zeros and any trailing decimal point

sign : boolean, optional

Whether to show the sign for positive values.

pad_left : non-negative integer, optional

Pad the left side of the string with whitespace until at least that
many characters are to the left of the decimal point.

exp_digits : non-negative integer, optional

Pad the exponent with zeros until it contains at least this many digits.
If omitted, the exponent will be at least 2 digits.

min_digits : non-negative integer or None, optional

Minimum number of digits to print. This only has an effect for
`unique=True`. In that case more digits than necessary to uniquely
identify the value may be printed and rounded unbiased.

-- versionadded:: 1.21.0

Returns ------- rep : string

The string representation of the floating point value

See Also -------- format_float_positional

Examples -------- >>> np.format_float_scientific(np.float32(np.pi)) '3.1415927e+00' >>> s = np.float32(1.23e24) >>> np.format_float_scientific(s, unique=False, precision=15) '1.230000071797338e+24' >>> np.format_float_scientific(s, exp_digits=4) '1.23e+0024'

func Frexp ¶

func Frexp(x *py.Object, out1 *py.Object, out2 *py.Object, out *py.Object) *py.Object

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 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

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 -------- >>> 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.])

func FromDlpack ¶

func FromDlpack(x *py.Object) *py.Object

from_dlpack(x, /)

Create a NumPy array from an object implementing the ``__dlpack__``
protocol. Generally, the returned NumPy array is a read-only view
of the input object. See [1]_ and [2]_ for more details.

Parameters
----------
x : object
    A Python object that implements the ``__dlpack__`` and
    ``__dlpack_device__`` methods.

Returns
-------
out : ndarray

References
----------
.. [1] Array API documentation,
   https://data-apis.org/array-api/latest/design_topics/data_interchange.html#syntax-for-data-interchange-with-dlpack

.. [2] Python specification for DLPack,
   https://dmlc.github.io/dlpack/latest/python_spec.html

Examples
--------
>>> import torch
>>> x = torch.arange(10)
>>> # create a view of the torch tensor "x" in NumPy
>>> y = np.from_dlpack(x)

func Frombuffer ¶

func Frombuffer(buffer *py.Object, dtype *py.Object, count *py.Object, offset *py.Object) *py.Object

frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None)

Interpret a buffer as a 1-dimensional array.

Parameters
----------
buffer : buffer_like
    An object that exposes the buffer interface.
dtype : data-type, optional
    Data-type of the returned array; default: float.
count : int, optional
    Number of items to read. ``-1`` means all data in the buffer.
offset : int, optional
    Start reading the buffer from this offset (in bytes); default: 0.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray

See also
--------
ndarray.tobytes
    Inverse of this operation, construct Python bytes from the raw data
    bytes in the array.

Notes
-----
If the buffer has data that is not in machine byte-order, this should
be specified as part of the data-type, e.g.::

  >>> dt = np.dtype(int)
  >>> dt = dt.newbyteorder('>')
  >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP

The data of the resulting array will not be byteswapped, but will be
interpreted correctly.

This function creates a view into the original object.  This should be safe
in general, but it may make sense to copy the result when the original
object is mutable or untrusted.

Examples
--------
>>> s = b'hello world'
>>> np.frombuffer(s, dtype='S1', count=5, offset=6)
array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')

>>> np.frombuffer(b'\x01\x02', dtype=np.uint8)
array([1, 2], dtype=uint8)
>>> np.frombuffer(b'\x01\x02\x03\x04\x05', dtype=np.uint8, count=3)
array([1, 2, 3], dtype=uint8)

func Fromfile ¶

func Fromfile(file *py.Object, dtype *py.Object, count *py.Object, sep *py.Object, offset *py.Object) *py.Object

fromfile(file, dtype=float, count=-1, sep=”, offset=0, *, like=None)

Construct an array from data in a text or binary file.

A highly efficient way of reading binary data with a known data-type,
as well as parsing simply formatted text files.  Data written using the
`tofile` method can be read using this function.

Parameters
----------
file : file or str or Path
    Open file object or filename.

    .. versionchanged:: 1.17.0
        `pathlib.Path` objects are now accepted.

dtype : data-type
    Data type of the returned array.
    For binary files, it is used to determine the size and byte-order
    of the items in the file.
    Most builtin numeric types are supported and extension types may be supported.

    .. versionadded:: 1.18.0
        Complex dtypes.

count : int
    Number of items to read. ``-1`` means all items (i.e., the complete
    file).
sep : str
    Separator between items if file is a text file.
    Empty ("") separator means the file should be treated as binary.
    Spaces (" ") in the separator match zero or more whitespace characters.
    A separator consisting only of spaces must match at least one
    whitespace.
offset : int
    The offset (in bytes) from the file's current position. Defaults to 0.
    Only permitted for binary files.

    .. versionadded:: 1.17.0
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

See also
--------
load, save
ndarray.tofile
loadtxt : More flexible way of loading data from a text file.

Notes
-----
Do not rely on the combination of `tofile` and `fromfile` for
data storage, as the binary files generated are not platform
independent.  In particular, no byte-order or data-type information is
saved.  Data can be stored in the platform independent ``.npy`` format
using `save` and `load` instead.

Examples
--------
Construct an ndarray:

>>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),
...                ('temp', float)])
>>> x = np.zeros((1,), dtype=dt)
>>> x['time']['min'] = 10; x['temp'] = 98.25
>>> x
array([((10, 0), 98.25)],
      dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

Save the raw data to disk:

>>> import tempfile
>>> fname = tempfile.mkstemp()[1]
>>> x.tofile(fname)

Read the raw data from disk:

>>> np.fromfile(fname, dtype=dt)
array([((10, 0), 98.25)],
      dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

The recommended way to store and load data:

>>> np.save(fname, x)
>>> np.load(fname + '.npy')
array([((10, 0), 98.25)],
      dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

func Fromfunction ¶

func Fromfunction(function *py.Object, shape *py.Object) *py.Object

Construct an array by executing a function over each coordinate.

The resulting array therefore has a value “fn(x, y, z)“ at coordinate “(x, y, z)“.

Parameters ---------- function : callable

The function is called with N parameters, where N is the rank of
`shape`.  Each parameter represents the coordinates of the array
varying along a specific axis.  For example, if `shape`
were ``(2, 2)``, then the parameters would be
``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])``

shape : (N,) tuple of ints

Shape of the output array, which also determines the shape of
the coordinate arrays passed to `function`.

dtype : data-type, optional

Data-type of the coordinate arrays passed to `function`.
By default, `dtype` is float.

like : array_like, optional

Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns ------- fromfunction : any

The result of the call to `function` is passed back directly.
Therefore the shape of `fromfunction` is completely determined by
`function`.  If `function` returns a scalar value, the shape of
`fromfunction` would not match the `shape` parameter.

See Also -------- indices, meshgrid

Notes ----- Keywords other than `dtype` and `like` are passed to `function`.

Examples -------- >>> np.fromfunction(lambda i, j: i, (2, 2), dtype=float) array([[0., 0.],

[1., 1.]])

>>> np.fromfunction(lambda i, j: j, (2, 2), dtype=float) array([[0., 1.],

[0., 1.]])

>>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) array([[ True, False, False],

[False,  True, False],
[False, False,  True]])

>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) array([[0, 1, 2],

[1, 2, 3],
[2, 3, 4]])

func Fromiter ¶

func Fromiter(iter *py.Object, dtype *py.Object, count *py.Object) *py.Object

fromiter(iter, dtype, count=-1, *, like=None)

Create a new 1-dimensional array from an iterable object.

Parameters
----------
iter : iterable object
    An iterable object providing data for the array.
dtype : data-type
    The data-type of the returned array.

    .. versionchanged:: 1.23
        Object and subarray dtypes are now supported (note that the final
        result is not 1-D for a subarray dtype).

count : int, optional
    The number of items to read from *iterable*.  The default is -1,
    which means all data is read.
like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
out : ndarray
    The output array.

Notes
-----
Specify `count` to improve performance.  It allows ``fromiter`` to
pre-allocate the output array, instead of resizing it on demand.

Examples
--------
>>> iterable = (x*x for x in range(5))
>>> np.fromiter(iterable, float)
array([  0.,   1.,   4.,   9.,  16.])

A carefully constructed subarray dtype will lead to higher dimensional
results:

>>> iterable = ((x+1, x+2) for x in range(5))
>>> np.fromiter(iterable, dtype=np.dtype((int, 2)))
array([[1, 2],
       [2, 3],
       [3, 4],
       [4, 5],
       [5, 6]])

func Frompyfunc ¶

func Frompyfunc(func_ *py.Object, nin *py.Object, nout *py.Object) *py.Object

frompyfunc(func, /, nin, nout, *[, identity])

Takes an arbitrary Python function and returns a NumPy ufunc.

Can be used, for example, to add broadcasting to a built-in Python
function (see Examples section).

Parameters
----------
func : Python function object
    An arbitrary Python function.
nin : int
    The number of input arguments.
nout : int
    The number of objects returned by `func`.
identity : object, optional
    The value to use for the `~numpy.ufunc.identity` attribute of the resulting
    object. If specified, this is equivalent to setting the underlying
    C ``identity`` field to ``PyUFunc_IdentityValue``.
    If omitted, the identity is set to ``PyUFunc_None``. Note that this is
    _not_ equivalent to setting the identity to ``None``, which implies the
    operation is reorderable.

Returns
-------
out : ufunc
    Returns a NumPy universal function (``ufunc``) object.

See Also
--------
vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy.

Notes
-----
The returned ufunc always returns PyObject arrays.

Examples
--------
Use frompyfunc to add broadcasting to the Python function ``oct``:

>>> oct_array = np.frompyfunc(oct, 1, 1)
>>> oct_array(np.array((10, 30, 100)))
array(['0o12', '0o36', '0o144'], dtype=object)
>>> np.array((oct(10), oct(30), oct(100))) # for comparison
array(['0o12', '0o36', '0o144'], dtype='<U5')

func Fromregex ¶

func Fromregex(file *py.Object, regexp *py.Object, dtype *py.Object, encoding *py.Object) *py.Object

Construct an array from a text file, using regular expression parsing.

The returned array is always a structured array, and is constructed from all matches of the regular expression in the file. Groups in the regular expression are converted to fields of the structured array.

Parameters ---------- file : path or file

Filename or file object to read.

.. versionchanged:: 1.22.0
    Now accepts `os.PathLike` implementations.

regexp : str or regexp

Regular expression used to parse the file.
Groups in the regular expression correspond to fields in the dtype.

dtype : dtype or list of dtypes

Dtype for the structured array; must be a structured datatype.

encoding : str, optional

Encoding used to decode the inputfile. Does not apply to input streams.

.. versionadded:: 1.14.0

Returns ------- output : ndarray

The output array, containing the part of the content of `file` that
was matched by `regexp`. `output` is always a structured array.

Raises ------ TypeError

When `dtype` is not a valid dtype for a structured array.

See Also -------- fromstring, loadtxt

Notes ----- Dtypes for structured arrays can be specified in several forms, but all forms specify at least the data type and field name. For details see `basics.rec`.

Examples -------- >>> from io import StringIO >>> text = StringIO("1312 foo\n1534 bar\n444 qux")

>>> regexp = r"(\d+)\s+(...)" # match [digits, whitespace, anything] >>> output = np.fromregex(text, regexp, ... [('num', np.int64), ('key', 'S3')]) >>> output array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],

dtype=[('num', '<i8'), ('key', 'S3')])

>>> output['num'] array([1312, 1534, 444])

func Fromstring ¶

func Fromstring(string *py.Object, dtype *py.Object, count *py.Object) *py.Object

fromstring(string, dtype=float, count=-1, *, sep, like=None)

A new 1-D array initialized from text data in a string.

Parameters
----------
string : str
    A string containing the data.
dtype : data-type, optional
    The data type of the array; default: float.  For binary input data,
    the data must be in exactly this format. Most builtin numeric types are
    supported and extension types may be supported.

    .. versionadded:: 1.18.0
        Complex dtypes.

count : int, optional
    Read this number of `dtype` elements from the data.  If this is
    negative (the default), the count will be determined from the
    length of the data.
sep : str, optional
    The string separating numbers in the data; extra whitespace between
    elements is also ignored.

    .. deprecated:: 1.14
        Passing ``sep=''``, the default, is deprecated since it will
        trigger the deprecated binary mode of this function. This mode
        interprets `string` as binary bytes, rather than ASCII text with
        decimal numbers, an operation which is better spelt
        ``frombuffer(string, dtype, count)``. If `string` contains unicode
        text, the binary mode of `fromstring` will first encode it into
        bytes using utf-8, which will not produce sane results.

like : array_like, optional
    Reference object to allow the creation of arrays which are not
    NumPy arrays. If an array-like passed in as ``like`` supports
    the ``__array_function__`` protocol, the result will be defined
    by it. In this case, it ensures the creation of an array object
    compatible with that passed in via this argument.

    .. versionadded:: 1.20.0

Returns
-------
arr : ndarray
    The constructed array.

Raises
------
ValueError
    If the string is not the correct size to satisfy the requested
    `dtype` and `count`.

See Also
--------
frombuffer, fromfile, fromiter

Examples
--------
>>> np.fromstring('1 2', dtype=int, sep=' ')
array([1, 2])
>>> np.fromstring('1, 2', dtype=int, sep=',')
array([1, 2])

func Full ¶

func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object

Return a new array of given shape and type, filled with `fill_value`.

Parameters ---------- shape : int or sequence of ints

Shape of the new array, e.g., ``(2, 3)`` or ``2``.

fill_value : scalar or array_like

Fill value.

dtype : data-type, optional

The desired data-type for the array  The default, None, means
 ``np.array(fill_value).dtype``.

order : {'C', 'F'}, optional

Whether to store multidimensional data in C- or Fortran-contiguous
(row- or column-wise) order in memory.

like : array_like, optional

Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns ------- out : ndarray

Array of `fill_value` with the given shape, dtype, and order.

See Also -------- full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array. ones : Return a new array setting values to one. zeros : Return a new array setting values to zero.

Examples -------- >>> np.full((2, 2), np.inf) array([[inf, inf],

[inf, inf]])

>>> np.full((2, 2), 10) array([[10, 10],

[10, 10]])

>>> np.full((2, 2), [1, 2]) array([[1, 2],

[1, 2]])

func FullLike ¶

func FullLike(a *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object, subok *py.Object, shape *py.Object) *py.Object

Return a full array with the same shape and type as a given array.

Parameters ---------- a : array_like

The shape and data-type of `a` define these same attributes of
the returned array.

fill_value : array_like

Fill value.

dtype : data-type, optional

Overrides the data type of the result.

order : {'C', 'F', 'A', or 'K'}, optional

Overrides the memory layout of the result. 'C' means C-order,
'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
'C' otherwise. 'K' means match the layout of `a` as closely
as possible.

subok : bool, optional.

If True, then the newly created array will use the sub-class
type of `a`, otherwise it will be a base-class array. Defaults
to True.

shape : int or sequence of ints, optional.

Overrides the shape of the result. If order='K' and the number of
dimensions is unchanged, will try to keep order, otherwise,
order='C' is implied.

.. versionadded:: 1.17.0

Returns ------- out : ndarray

Array of `fill_value` with the same shape and type as `a`.

See Also -------- empty_like : Return an empty array with shape and type of input. ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full : Return a new array of given shape filled with value.

Examples -------- >>> x = np.arange(6, dtype=int) >>> np.full_like(x, 1) array([1, 1, 1, 1, 1, 1]) >>> np.full_like(x, 0.1) array([0, 0, 0, 0, 0, 0]) >>> np.full_like(x, 0.1, dtype=np.double) array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) >>> np.full_like(x, np.nan, dtype=np.double) array([nan, nan, nan, nan, nan, nan])

>>> y = np.arange(6, dtype=np.double) >>> np.full_like(y, 0.1) array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])

>>> y = np.zeros([2, 2, 3], dtype=int) >>> np.full_like(y, [0, 0, 255]) array([[[ 0, 0, 255],

 [  0,   0, 255]],
[[  0,   0, 255],
 [  0,   0, 255]]])

func Gcd ¶

func Gcd(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Returns the greatest common divisor of “|x1|“ and “|x2|“

Parameters ---------- x1, x2 : array_like, int

Arrays of values.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

Returns ------- y : ndarray or scalar

The greatest common divisor of the absolute value of the inputs
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- lcm : The lowest common multiple

Examples -------- >>> np.gcd(12, 20) 4 >>> np.gcd.reduce([15, 25, 35]) 5 >>> np.gcd(np.arange(6), 20) array([20, 1, 2, 1, 4, 5])

func Genfromtxt ¶

func Genfromtxt(fname *py.Object, dtype *py.Object, comments *py.Object, delimiter *py.Object, skipHeader *py.Object, skipFooter *py.Object, converters *py.Object, missingValues *py.Object, fillingValues *py.Object, usecols *py.Object, names *py.Object, excludelist *py.Object, deletechars *py.Object, replaceSpace *py.Object, autostrip *py.Object, caseSensitive *py.Object, defaultfmt *py.Object, unpack *py.Object, usemask *py.Object, loose *py.Object, invalidRaise *py.Object, maxRows *py.Object, encoding *py.Object) *py.Object

Load data from a text file, with missing values handled as specified.

Each line past the first `skip_header` lines is split at the `delimiter` character, and characters following the `comments` character are discarded.

Parameters ---------- fname : file, str, pathlib.Path, list of str, generator

File, filename, list, or generator to read.  If the filename
extension is ``.gz`` or ``.bz2``, the file is first decompressed. Note
that generators must return bytes or strings. The strings
in a list or produced by a generator are treated as lines.

dtype : dtype, optional

Data type of the resulting array.
If None, the dtypes will be determined by the contents of each
column, individually.

comments : str, optional

The character used to indicate the start of a comment.
All the characters occurring on a line after a comment are discarded.

delimiter : str, int, or sequence, optional

The string used to separate values.  By default, any consecutive
whitespaces act as delimiter.  An integer or sequence of integers
can also be provided as width(s) of each field.

skiprows : int, optional

`skiprows` was removed in numpy 1.10. Please use `skip_header` instead.

skip_header : int, optional

The number of lines to skip at the beginning of the file.

skip_footer : int, optional

The number of lines to skip at the end of the file.

converters : variable, optional

The set of functions that convert the data of a column to a value.
The converters can also be used to provide a default value
for missing data: ``converters = {3: lambda s: float(s or 0)}``.

missing : variable, optional

`missing` was removed in numpy 1.10. Please use `missing_values`
instead.

missing_values : variable, optional

The set of strings corresponding to missing data.

filling_values : variable, optional

The set of values to be used as default when the data are missing.

usecols : sequence, optional

Which columns to read, with 0 being the first.  For example,
``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.

names : {None, True, str, sequence}, optional

If `names` is True, the field names are read from the first line after
the first `skip_header` lines. This line can optionally be preceded
by a comment delimiter. If `names` is a sequence or a single-string of
comma-separated names, the names will be used to define the field names
in a structured dtype. If `names` is None, the names of the dtype
fields will be used, if any.

excludelist : sequence, optional

A list of names to exclude. This list is appended to the default list
['return','file','print']. Excluded names are appended with an
underscore: for example, `file` would become `file_`.

deletechars : str, optional

A string combining invalid characters that must be deleted from the
names.

defaultfmt : str, optional

A format used to define default field names, such as "f%i" or "f_%02i".

autostrip : bool, optional

Whether to automatically strip white spaces from the variables.

replace_space : char, optional

Character(s) used in replacement of white spaces in the variable
names. By default, use a '_'.

case_sensitive : {True, False, 'upper', 'lower'}, optional

If True, field names are case sensitive.
If False or 'upper', field names are converted to upper case.
If 'lower', field names are converted to lower case.

unpack : bool, optional

If True, the returned array is transposed, so that arguments may be
unpacked using ``x, y, z = genfromtxt(...)``.  When used with a
structured data-type, arrays are returned for each field.
Default is False.

usemask : bool, optional

If True, return a masked array.
If False, return a regular array.

loose : bool, optional

If True, do not raise errors for invalid values.

invalid_raise : bool, optional

If True, an exception is raised if an inconsistency is detected in the
number of columns.
If False, a warning is emitted and the offending lines are skipped.

max_rows : int, optional

The maximum number of rows to read. Must not be used with skip_footer
at the same time.  If given, the value must be at least 1. Default is
to read the entire file.

.. versionadded:: 1.10.0

encoding : str, optional

Encoding used to decode the inputfile. Does not apply when `fname` is
a file object.  The special value 'bytes' enables backward compatibility
workarounds that ensure that you receive byte arrays when possible
and passes latin1 encoded strings to converters. Override this value to
receive unicode arrays and pass strings as input to converters.  If set
to None the system default is used. The default value is 'bytes'.

.. versionadded:: 1.14.0

ndmin : int, optional

Same parameter as `loadtxt`

.. versionadded:: 1.23.0

like : array_like, optional

Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns ------- out : ndarray

Data read from the text file. If `usemask` is True, this is a
masked array.

See Also -------- numpy.loadtxt : equivalent function when no data is missing.

Notes -----

• When spaces are used as delimiters, or when no delimiter has been given as input, there should not be any missing data between two fields.
• When the variables are named (either by a flexible dtype or with `names`), there must not be any header in the file (else a ValueError exception is raised).
• Individual values are not stripped of spaces by default. When using a custom converter, make sure the function does remove spaces.

References ---------- .. [1] NumPy User Guide, section `I/O with NumPy

<https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.

Examples -------- >>> from io import StringIO >>> import numpy as np

Comma delimited file with mixed dtype ¶

>>> s = StringIO(u"1,1.3,abcde") >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'), ... ('mystring','S5')], delimiter=",") >>> data array((1, 1.3, b'abcde'),

dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])

Using dtype = None

>>> _ = s.seek(0) # needed for StringIO example only >>> data = np.genfromtxt(s, dtype=None, ... names = ['myint','myfloat','mystring'], delimiter=",") >>> data array((1, 1.3, b'abcde'),

dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])

Specifying dtype and names ¶

>>> _ = s.seek(0) >>> data = np.genfromtxt(s, dtype="i8,f8,S5", ... names=['myint','myfloat','mystring'], delimiter=",") >>> data array((1, 1.3, b'abcde'),

dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])

An example with fixed-width columns ¶

>>> s = StringIO(u"11.3abcde") >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'], ... delimiter=[1,3,5]) >>> data array((1, 1.3, b'abcde'),

dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', 'S5')])

An example to show comments ¶

>>> f = StringIO(”' ... text,# of chars ... hello world,11 ... numpy,5”') >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',') array([(b'text', b”), (b'hello world', b'11'), (b'numpy', b'5')],

dtype=[('f0', 'S12'), ('f1', 'S12')])

func Geomspace ¶

func Geomspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, dtype *py.Object, axis *py.Object) *py.Object

Return numbers spaced evenly on a log scale (a geometric progression).

This is similar to `logspace`, but with endpoints specified directly. Each output sample is a constant multiple of the previous.

.. versionchanged:: 1.16.0

Non-scalar `start` and `stop` are now supported.

Parameters ---------- start : array_like

The starting value of the sequence.

stop : array_like

The final value of the sequence, unless `endpoint` is False.
In that case, ``num + 1`` values are spaced over the
interval in log-space, of which all but the last (a sequence of
length `num`) are returned.

num : integer, optional

Number of samples to generate.  Default is 50.

endpoint : boolean, optional

If true, `stop` is the last sample. Otherwise, it is not included.
Default is True.

dtype : dtype

The type of the output array.  If `dtype` is not given, the data type
is inferred from `start` and `stop`. The inferred dtype will never be
an integer; `float` is chosen even if the arguments would produce an
array of integers.

axis : int, optional

The axis in the result to store the samples.  Relevant only if start
or stop are array-like.  By default (0), the samples will be along a
new axis inserted at the beginning. Use -1 to get an axis at the end.

.. versionadded:: 1.16.0

Returns ------- samples : ndarray

`num` samples, equally spaced on a log scale.

See Also -------- logspace : Similar to geomspace, but with endpoints specified using log

and base.

linspace : Similar to geomspace, but with arithmetic instead of geometric

progression.

arange : Similar to linspace, with the step size specified instead of the

number of samples.

:ref:`how-to-partition`

Notes ----- If the inputs or dtype are complex, the output will follow a logarithmic spiral in the complex plane. (There are an infinite number of spirals passing through two points; the output will follow the shortest such path.)

Examples -------- >>> np.geomspace(1, 1000, num=4) array([ 1., 10., 100., 1000.]) >>> np.geomspace(1, 1000, num=3, endpoint=False) array([ 1., 10., 100.]) >>> np.geomspace(1, 1000, num=4, endpoint=False) array([ 1. , 5.62341325, 31.6227766 , 177.827941 ]) >>> np.geomspace(1, 256, num=9) array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.])

Note that the above may not produce exact integers:

>>> np.geomspace(1, 256, num=9, dtype=int) array([ 1, 2, 4, 7, 16, 32, 63, 127, 256]) >>> np.around(np.geomspace(1, 256, num=9)).astype(int) array([ 1, 2, 4, 8, 16, 32, 64, 128, 256])

Negative, decreasing, and complex inputs are allowed:

>>> np.geomspace(1000, 1, num=4) array([1000., 100., 10., 1.]) >>> np.geomspace(-1000, -1, num=4) array([-1000., -100., -10., -1.]) >>> np.geomspace(1j, 1000j, num=4) # Straight line array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j]) >>> np.geomspace(-1+0j, 1+0j, num=5) # Circle array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,

6.12323400e-17+1.00000000e+00j,  7.07106781e-01+7.07106781e-01j,
1.00000000e+00+0.00000000e+00j])

Graphical illustration of `endpoint` parameter:

>>> import matplotlib.pyplot as plt >>> N = 10 >>> y = np.zeros(N) >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o') [<matplotlib.lines.Line2D object at 0x...>] >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o') [<matplotlib.lines.Line2D object at 0x...>] >>> plt.axis([0.5, 2000, 0, 3]) [0.5, 2000, 0, 3] >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both') >>> plt.show()

func GetArrayWrap ¶

func GetArrayWrap(__llgo_va_list ...interface{}) *py.Object

Find the wrapper for the array with the highest priority.

In case of ties, leftmost wins. If no wrapper is found, return None

func GetInclude ¶

func GetInclude() *py.Object

Return the directory that contains the NumPy \*.h header files.

Extension modules that need to compile against NumPy should use this function to locate the appropriate include directory.

Notes ----- When using “distutils“, for example in “setup.py“::

import numpy as np
...
Extension('extension_name', ...
        include_dirs=[np.get_include()])
...

func GetPrintoptions ¶

func GetPrintoptions() *py.Object

Return the current print options.

Returns ------- print_opts : dict

Dictionary of current print options with keys

  - precision : int
  - threshold : int
  - edgeitems : int
  - linewidth : int
  - suppress : bool
  - nanstr : str
  - infstr : str
  - formatter : dict of callables
  - sign : str

For a full description of these options, see `set_printoptions`.

See Also -------- set_printoptions, printoptions, set_string_function

func Getbufsize ¶

func Getbufsize() *py.Object

Return the size of the buffer used in ufuncs.

Returns ------- getbufsize : int

Size of ufunc buffer in bytes.

func Geterr ¶

func Geterr() *py.Object

Get the current way of handling floating-point errors.

Returns ------- res : dict

A dictionary with keys "divide", "over", "under", and "invalid",
whose values are from the strings "ignore", "print", "log", "warn",
"raise", and "call". The keys represent possible floating-point
exceptions, and the values define how these exceptions are handled.

See Also -------- geterrcall, seterr, seterrcall

Notes ----- For complete documentation of the types of floating-point exceptions and treatment options, see `seterr`.

Examples -------- >>> np.geterr() {'divide': 'warn', 'over': 'warn', 'under': 'ignore', 'invalid': 'warn'} >>> np.arange(3.) / np.arange(3.) array([nan, 1., 1.])

>>> oldsettings = np.seterr(all='warn', over='raise') >>> np.geterr() {'divide': 'warn', 'over': 'raise', 'under': 'warn', 'invalid': 'warn'} >>> np.arange(3.) / np.arange(3.) array([nan, 1., 1.])

func Geterrcall ¶

func Geterrcall() *py.Object

Return the current callback function used on floating-point errors.

When the error handling for a floating-point error (one of "divide", "over", "under", or "invalid") is set to 'call' or 'log', the function that is called or the log instance that is written to is returned by `geterrcall`. This function or log instance has been set with `seterrcall`.

Returns ------- errobj : callable, log instance or None

The current error handler. If no handler was set through `seterrcall`,
``None`` is returned.

See Also -------- seterrcall, seterr, geterr

Notes ----- For complete documentation of the types of floating-point exceptions and treatment options, see `seterr`.

Examples -------- >>> np.geterrcall() # we did not yet set a handler, returns None

>>> oldsettings = np.seterr(all='call') >>> def err_handler(type, flag): ... print("Floating point error (%s), with flag %s" % (type, flag)) >>> oldhandler = np.seterrcall(err_handler) >>> np.array([1, 2, 3]) / 0.0 Floating point error (divide by zero), with flag 1 array([inf, inf, inf])

>>> cur_handler = np.geterrcall() >>> cur_handler is err_handler True

func Geterrobj ¶

func Geterrobj() *py.Object

geterrobj()

Return the current object that defines floating-point error handling.

The error object contains all information that defines the error handling
behavior in NumPy. `geterrobj` is used internally by the other
functions that get and set error handling behavior (`geterr`, `seterr`,
`geterrcall`, `seterrcall`).

Returns
-------
errobj : list
    The error object, a list containing three elements:
    [internal numpy buffer size, error mask, error callback function].

    The error mask is a single integer that holds the treatment information
    on all four floating point errors. The information for each error type
    is contained in three bits of the integer. If we print it in base 8, we
    can see what treatment is set for "invalid", "under", "over", and
    "divide" (in that order). The printed string can be interpreted with

    * 0 : 'ignore'
    * 1 : 'warn'
    * 2 : 'raise'
    * 3 : 'call'
    * 4 : 'print'
    * 5 : 'log'

See Also
--------
seterrobj, seterr, geterr, seterrcall, geterrcall
getbufsize, setbufsize

Notes
-----
For complete documentation of the types of floating-point exceptions and
treatment options, see `seterr`.

Examples
--------
>>> np.geterrobj()  # first get the defaults
[8192, 521, None]

>>> def err_handler(type, flag):
...     print("Floating point error (%s), with flag %s" % (type, flag))
...
>>> old_bufsize = np.setbufsize(20000)
>>> old_err = np.seterr(divide='raise')
>>> old_handler = np.seterrcall(err_handler)
>>> np.geterrobj()
[8192, 521, <function err_handler at 0x91dcaac>]

>>> old_err = np.seterr(all='ignore')
>>> np.base_repr(np.geterrobj()[1], 8)
'0'
>>> old_err = np.seterr(divide='warn', over='log', under='call',
...                     invalid='print')
>>> np.base_repr(np.geterrobj()[1], 8)
'4351'

func Gradient ¶

func Gradient(f *py.Object, __llgo_va_list ...interface{}) *py.Object

Return the gradient of an N-dimensional array.

The gradient is computed using second order accurate central differences in the interior points and either first or second order accurate one-sides (forward or backwards) differences at the boundaries. The returned gradient hence has the same shape as the input array.

Parameters ---------- f : array_like

An N-dimensional array containing samples of a scalar function.

varargs : list of scalar or array, optional

Spacing between f values. Default unitary spacing for all dimensions.
Spacing can be specified using:

1. single scalar to specify a sample distance for all dimensions.
2. N scalars to specify a constant sample distance for each dimension.
   i.e. `dx`, `dy`, `dz`, ...
3. N arrays to specify the coordinates of the values along each
   dimension of F. The length of the array must match the size of
   the corresponding dimension
4. Any combination of N scalars/arrays with the meaning of 2. and 3.

If `axis` is given, the number of varargs must equal the number of axes.
Default: 1.

edge_order : {1, 2}, optional

Gradient is calculated using N-th order accurate differences
at the boundaries. Default: 1.

.. versionadded:: 1.9.1

axis : None or int or tuple of ints, optional

Gradient is calculated only along the given axis or axes
The default (axis = None) is to calculate the gradient for all the axes
of the input array. axis may be negative, in which case it counts from
the last to the first axis.

.. versionadded:: 1.11.0

Returns ------- gradient : ndarray or list of ndarray

A list of ndarrays (or a single ndarray if there is only one dimension)
corresponding to the derivatives of f with respect to each dimension.
Each derivative has the same shape as f.

Examples -------- >>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float) >>> np.gradient(f) array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) >>> np.gradient(f, 2) array([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ])

Spacing can be also specified with an array that represents the coordinates of the values F along the dimensions. For instance a uniform spacing:

>>> x = np.arange(f.size) >>> np.gradient(f, x) array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])

Or a non uniform one:

>>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float) >>> np.gradient(f, x) array([1. , 3. , 3.5, 6.7, 6.9, 2.5])

For two dimensional arrays, the return will be two arrays ordered by axis. In this example the first array stands for the gradient in rows and the second one in columns direction:

>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float)) [array([[ 2., 2., -1.],

[ 2.,  2., -1.]]), array([[1. , 2.5, 4. ],
[1. , 1. , 1. ]])]

In this example the spacing is also specified: uniform for axis=0 and non uniform for axis=1

>>> dx = 2. >>> y = [1., 1.5, 3.5] >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y) [array([[ 1. , 1. , -0.5],

[ 1. ,  1. , -0.5]]), array([[2. , 2. , 2. ],
[2. , 1.7, 0.5]])]

It is possible to specify how boundaries are treated using `edge_order`

>>> x = np.array([0, 1, 2, 3, 4]) >>> f = x**2 >>> np.gradient(f, edge_order=1) array([1., 2., 4., 6., 7.]) >>> np.gradient(f, edge_order=2) array([0., 2., 4., 6., 8.])

The `axis` keyword can be used to specify a subset of axes of which the gradient is calculated

>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0) array([[ 2., 2., -1.],

[ 2.,  2., -1.]])

Notes ----- Assuming that :math:`f\in C^{3}` (i.e., :math:`f` has at least 3 continuous derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we minimize the "consistency error" :math:`\eta_{i}` between the true gradient and its estimate from a linear combination of the neighboring grid-points:

.. math::

\eta_{i} = f_{i}^{\left(1\right)} -
            \left[ \alpha f\left(x_{i}\right) +
                    \beta f\left(x_{i} + h_{d}\right) +
                    \gamma f\left(x_{i}-h_{s}\right)
            \right]

By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})` with their Taylor series expansion, this translates into solving the following the linear system:

.. math::

\left\{
    \begin{array}{r}
        \alpha+\beta+\gamma=0 \\
        \beta h_{d}-\gamma h_{s}=1 \\
        \beta h_{d}^{2}+\gamma h_{s}^{2}=0
    \end{array}
\right.

The resulting approximation of :math:`f_{i}^{(1)}` is the following:

.. math::

\hat f_{i}^{(1)} =
    \frac{
        h_{s}^{2}f\left(x_{i} + h_{d}\right)
        + \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right)
        - h_{d}^{2}f\left(x_{i}-h_{s}\right)}
        { h_{s}h_{d}\left(h_{d} + h_{s}\right)}
    + \mathcal{O}\left(\frac{h_{d}h_{s}^{2}
                        + h_{s}h_{d}^{2}}{h_{d}
                        + h_{s}}\right)

It is worth noting that if :math:`h_{s}=h_{d}` (i.e., data are evenly spaced) we find the standard second order approximation:

.. math::

\hat f_{i}^{(1)}=
    \frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h}
    + \mathcal{O}\left(h^{2}\right)

With a similar procedure the forward/backward approximations used for boundaries can be derived.

References ---------- .. [1] Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics

(Texts in Applied Mathematics). New York: Springer.

.. [2] Durran D. R. (1999) Numerical Methods for Wave Equations

in Geophysical Fluid Dynamics. New York: Springer.

.. [3] Fornberg B. (1988) Generation of Finite Difference Formulas on

Arbitrarily Spaced Grids,
Mathematics of Computation 51, no. 184 : 699-706.
`PDF <http://www.ams.org/journals/mcom/1988-51-184/
S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_.

func Greater ¶

func Greater(__llgo_va_list ...interface{}) *py.Object

func GreaterEqual ¶

func GreaterEqual(__llgo_va_list ...interface{}) *py.Object

func Hamming ¶

func Hamming(M *py.Object) *py.Object

Return the Hamming window.

The Hamming window is a taper formed by using a weighted cosine.

Parameters ---------- M : int

Number of points in the output window. If zero or less, an
empty array is returned.

Returns ------- out : ndarray

The window, with the maximum value normalized to one (the value
one appears only if the number of samples is odd).

See Also -------- bartlett, blackman, hanning, kaiser

Notes ----- The Hamming window is defined as

.. math:: w(n) = 0.54 - 0.46\cos\left(\frac{2\pi{n}}{M-1}\right)

\qquad 0 \leq n \leq M-1

The Hamming was named for R. W. Hamming, an associate of J. W. Tukey and is described in Blackman and Tukey. It was recommended for smoothing the truncated autocovariance function in the time domain. Most references to the Hamming window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.

References ---------- .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power

spectra, Dover Publications, New York.

.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The

University of Alberta Press, 1975, pp. 109-110.

.. [3] Wikipedia, "Window function",

https://en.wikipedia.org/wiki/Window_function

.. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,

"Numerical Recipes", Cambridge University Press, 1986, page 425.

Examples -------- >>> np.hamming(12) array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary

0.98136677,  0.98136677,  0.84123594,  0.60546483,  0.34890909,
0.15302337,  0.08      ])

Plot the window and the frequency response:

>>> import matplotlib.pyplot as plt >>> from numpy.fft import fft, fftshift >>> window = np.hamming(51) >>> plt.plot(window) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Hamming window") Text(0.5, 1.0, 'Hamming window') >>> plt.ylabel("Amplitude") Text(0, 0.5, 'Amplitude') >>> plt.xlabel("Sample") Text(0.5, 0, 'Sample') >>> plt.show()

>>> plt.figure() <Figure size 640x480 with 0 Axes> >>> A = fft(window, 2048) / 25.5 >>> mag = np.abs(fftshift(A)) >>> freq = np.linspace(-0.5, 0.5, len(A)) >>> response = 20 * np.log10(mag) >>> response = np.clip(response, -100, 100) >>> plt.plot(freq, response) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Frequency response of Hamming window") Text(0.5, 1.0, 'Frequency response of Hamming window') >>> plt.ylabel("Magnitude [dB]") Text(0, 0.5, 'Magnitude [dB]') >>> plt.xlabel("Normalized frequency [cycles per sample]") Text(0.5, 0, 'Normalized frequency [cycles per sample]') >>> plt.axis('tight') ... >>> plt.show()

func Hanning ¶

func Hanning(M *py.Object) *py.Object

Return the Hanning window.

The Hanning window is a taper formed by using a weighted cosine.

Parameters ---------- M : int

Number of points in the output window. If zero or less, an
empty array is returned.

Returns ------- out : ndarray, shape(M,)

The window, with the maximum value normalized to one (the value
one appears only if `M` is odd).

See Also -------- bartlett, blackman, hamming, kaiser

Notes ----- The Hanning window is defined as

.. math:: w(n) = 0.5 - 0.5\cos\left(\frac{2\pi{n}}{M-1}\right)

\qquad 0 \leq n \leq M-1

The Hanning was named for Julius von Hann, an Austrian meteorologist. It is also known as the Cosine Bell. Some authors prefer that it be called a Hann window, to help avoid confusion with the very similar Hamming window.

Most references to the Hanning window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.

References ---------- .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power

spectra, Dover Publications, New York.

.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics",

The University of Alberta Press, 1975, pp. 106-108.

.. [3] Wikipedia, "Window function",

https://en.wikipedia.org/wiki/Window_function

.. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,

"Numerical Recipes", Cambridge University Press, 1986, page 425.

Examples -------- >>> np.hanning(12) array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037,

0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,
0.07937323, 0.        ])

Plot the window and its frequency response:

>>> import matplotlib.pyplot as plt >>> from numpy.fft import fft, fftshift >>> window = np.hanning(51) >>> plt.plot(window) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Hann window") Text(0.5, 1.0, 'Hann window') >>> plt.ylabel("Amplitude") Text(0, 0.5, 'Amplitude') >>> plt.xlabel("Sample") Text(0.5, 0, 'Sample') >>> plt.show()

>>> plt.figure() <Figure size 640x480 with 0 Axes> >>> A = fft(window, 2048) / 25.5 >>> mag = np.abs(fftshift(A)) >>> freq = np.linspace(-0.5, 0.5, len(A)) >>> with np.errstate(divide='ignore', invalid='ignore'): ... response = 20 * np.log10(mag) ... >>> response = np.clip(response, -100, 100) >>> plt.plot(freq, response) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Frequency response of the Hann window") Text(0.5, 1.0, 'Frequency response of the Hann window') >>> plt.ylabel("Magnitude [dB]") Text(0, 0.5, 'Magnitude [dB]') >>> plt.xlabel("Normalized frequency [cycles per sample]") Text(0.5, 0, 'Normalized frequency [cycles per sample]') >>> plt.axis('tight') ... >>> plt.show()

func Heaviside ¶

func Heaviside(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Compute the Heaviside step function.

The Heaviside step function is defined as::

                      0   if x1 < 0
heaviside(x1, x2) =  x2   if x1 == 0
                      1   if x1 > 0

where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used.

Parameters ---------- x1 : array_like

Input values.

x2 : array_like

The value of the function when x1 is 0.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : ndarray or scalar

The output array, element-wise Heaviside step function of `x1`.
This is a scalar if both `x1` and `x2` are scalars.

Notes ----- .. versionadded:: 1.13.0

References ---------- .. Wikipedia, "Heaviside step function",

https://en.wikipedia.org/wiki/Heaviside_step_function

Examples -------- >>> np.heaviside([-1.5, 0, 2.0], 0.5) array([ 0. , 0.5, 1. ]) >>> np.heaviside([-1.5, 0, 2.0], 1) array([ 0., 1., 1.])

func Histogram ¶

func Histogram(a *py.Object, bins *py.Object, range_ *py.Object, density *py.Object, weights *py.Object) *py.Object

Compute the histogram of a dataset.

Parameters ---------- a : array_like

Input data. The histogram is computed over the flattened array.

bins : int or sequence of scalars or str, optional

If `bins` is an int, it defines the number of equal-width
bins in the given range (10, by default). If `bins` is a
sequence, it defines a monotonically increasing array of bin edges,
including the rightmost edge, allowing for non-uniform bin widths.

.. versionadded:: 1.11.0

If `bins` is a string, it defines the method used to calculate the
optimal bin width, as defined by `histogram_bin_edges`.

range : (float, float), optional

The lower and upper range of the bins.  If not provided, range
is simply ``(a.min(), a.max())``.  Values outside the range are
ignored. The first element of the range must be less than or
equal to the second. `range` affects the automatic bin
computation as well. While bin width is computed to be optimal
based on the actual data within `range`, the bin count will fill
the entire range including portions containing no data.

weights : array_like, optional

An array of weights, of the same shape as `a`.  Each value in
`a` only contributes its associated weight towards the bin count
(instead of 1). If `density` is True, the weights are
normalized, so that the integral of the density over the range
remains 1.

density : bool, optional

If ``False``, the result will contain the number of samples in
each bin. If ``True``, the result is the value of the
probability *density* function at the bin, normalized such that
the *integral* over the range is 1. Note that the sum of the
histogram values will not be equal to 1 unless bins of unity
width are chosen; it is not a probability *mass* function.

Returns ------- hist : array

The values of the histogram. See `density` and `weights` for a
description of the possible semantics.

bin_edges : array of dtype float

Return the bin edges ``(length(hist)+1)``.

See Also -------- histogramdd, bincount, searchsorted, digitize, histogram_bin_edges

Notes ----- All but the last (righthand-most) bin is half-open. In other words, if `bins` is::

[1, 2, 3, 4]

then the first bin is “[1, 2)“ (including 1, but excluding 2) and the second “[2, 3)“. The last bin, however, is “[3, 4]“, which *includes* 4.

Examples -------- >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3]) (array([0, 2, 1]), array([0, 1, 2, 3])) >>> np.histogram(np.arange(4), bins=np.arange(5), density=True) (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4])) >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3]) (array([1, 4, 1]), array([0, 1, 2, 3]))

>>> a = np.arange(5) >>> hist, bin_edges = np.histogram(a, density=True) >>> hist array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5]) >>> hist.sum() 2.4999999999999996 >>> np.sum(hist * np.diff(bin_edges)) 1.0

.. versionadded:: 1.11.0

Automated Bin Selection Methods example, using 2 peak random data with 2000 points:

>>> import matplotlib.pyplot as plt >>> rng = np.random.RandomState(10) # deterministic random data >>> a = np.hstack((rng.normal(size=1000), ... rng.normal(loc=5, scale=2, size=1000))) >>> _ = plt.hist(a, bins='auto') # arguments are passed to np.histogram >>> plt.title("Histogram with 'auto' bins") Text(0.5, 1.0, "Histogram with 'auto' bins") >>> plt.show()

func Histogram2d ¶

func Histogram2d(x *py.Object, y *py.Object, bins *py.Object, range_ *py.Object, density *py.Object, weights *py.Object) *py.Object

Compute the bi-dimensional histogram of two data samples.

Parameters ---------- x : array_like, shape (N,)

An array containing the x coordinates of the points to be
histogrammed.

y : array_like, shape (N,)

An array containing the y coordinates of the points to be
histogrammed.

bins : int or array_like or [int, int] or [array, array], optional

The bin specification:

  * If int, the number of bins for the two dimensions (nx=ny=bins).
  * If array_like, the bin edges for the two dimensions
    (x_edges=y_edges=bins).
  * If [int, int], the number of bins in each dimension
    (nx, ny = bins).
  * If [array, array], the bin edges in each dimension
    (x_edges, y_edges = bins).
  * A combination [int, array] or [array, int], where int
    is the number of bins and array is the bin edges.

range : array_like, shape(2,2), optional

The leftmost and rightmost edges of the bins along each dimension
(if not specified explicitly in the `bins` parameters):
``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
will be considered outliers and not tallied in the histogram.

density : bool, optional

If False, the default, returns the number of samples in each bin.
If True, returns the probability *density* function at the bin,
``bin_count / sample_count / bin_area``.

weights : array_like, shape(N,), optional

An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
Weights are normalized to 1 if `density` is True. If `density` is
False, the values of the returned histogram are equal to the sum of
the weights belonging to the samples falling into each bin.

Returns ------- H : ndarray, shape(nx, ny)

The bi-dimensional histogram of samples `x` and `y`. Values in `x`
are histogrammed along the first dimension and values in `y` are
histogrammed along the second dimension.

xedges : ndarray, shape(nx+1,)

The bin edges along the first dimension.

yedges : ndarray, shape(ny+1,)

The bin edges along the second dimension.

See Also -------- histogram : 1D histogram histogramdd : Multidimensional histogram

Notes ----- When `density` is True, then the returned histogram is the sample density, defined such that the sum over bins of the product “bin_value * bin_area“ is 1.

Please note that the histogram does not follow the Cartesian convention where `x` values are on the abscissa and `y` values on the ordinate axis. Rather, `x` is histogrammed along the first dimension of the array (vertical), and `y` along the second dimension of the array (horizontal). This ensures compatibility with `histogramdd`.

Examples -------- >>> from matplotlib.image import NonUniformImage >>> import matplotlib.pyplot as plt

Construct a 2-D histogram with variable bin width. First define the bin edges:

>>> xedges = [0, 1, 3, 5] >>> yedges = [0, 2, 3, 4, 6]

Next we create a histogram H with random bin content:

>>> x = np.random.normal(2, 1, 100) >>> y = np.random.normal(1, 1, 100) >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges)) >>> # Histogram does not follow Cartesian convention (see Notes), >>> # therefore transpose H for visualization purposes. >>> H = H.T

:func:`imshow <matplotlib.pyplot.imshow>` can only display square bins:

>>> fig = plt.figure(figsize=(7, 3)) >>> ax = fig.add_subplot(131, title='imshow: square bins') >>> plt.imshow(H, interpolation='nearest', origin='lower', ... extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]]) <matplotlib.image.AxesImage object at 0x...>

:func:`pcolormesh <matplotlib.pyplot.pcolormesh>` can display actual edges:

>>> ax = fig.add_subplot(132, title='pcolormesh: actual edges', ... aspect='equal') >>> X, Y = np.meshgrid(xedges, yedges) >>> ax.pcolormesh(X, Y, H) <matplotlib.collections.QuadMesh object at 0x...>

:class:`NonUniformImage <matplotlib.image.NonUniformImage>` can be used to display actual bin edges with interpolation:

>>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated', ... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]]) >>> im = NonUniformImage(ax, interpolation='bilinear') >>> xcenters = (xedges[:-1] + xedges[1:]) / 2 >>> ycenters = (yedges[:-1] + yedges[1:]) / 2 >>> im.set_data(xcenters, ycenters, H) >>> ax.add_image(im) >>> plt.show()

It is also possible to construct a 2-D histogram without specifying bin edges:

>>> # Generate non-symmetric test data >>> n = 10000 >>> x = np.linspace(1, 100, n) >>> y = 2*np.log(x) + np.random.rand(n) - 0.5 >>> # Compute 2d histogram. Note the order of x/y and xedges/yedges >>> H, yedges, xedges = np.histogram2d(y, x, bins=20)

Now we can plot the histogram using :func:`pcolormesh <matplotlib.pyplot.pcolormesh>`, and a :func:`hexbin <matplotlib.pyplot.hexbin>` for comparison.

>>> # Plot histogram using pcolormesh >>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True) >>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow') >>> ax1.plot(x, 2*np.log(x), 'k-') >>> ax1.set_xlim(x.min(), x.max()) >>> ax1.set_ylim(y.min(), y.max()) >>> ax1.set_xlabel('x') >>> ax1.set_ylabel('y') >>> ax1.set_title('histogram2d') >>> ax1.grid()

>>> # Create hexbin plot for comparison >>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow') >>> ax2.plot(x, 2*np.log(x), 'k-') >>> ax2.set_title('hexbin') >>> ax2.set_xlim(x.min(), x.max()) >>> ax2.set_xlabel('x') >>> ax2.grid()

>>> plt.show()

func HistogramBinEdges ¶

func HistogramBinEdges(a *py.Object, bins *py.Object, range_ *py.Object, weights *py.Object) *py.Object

Function to calculate only the edges of the bins used by the `histogram` function.

Parameters ---------- a : array_like

Input data. The histogram is computed over the flattened array.

bins : int or sequence of scalars or str, optional

If `bins` is an int, it defines the number of equal-width
bins in the given range (10, by default). If `bins` is a
sequence, it defines the bin edges, including the rightmost
edge, allowing for non-uniform bin widths.

If `bins` is a string from the list below, `histogram_bin_edges` will use
the method chosen to calculate the optimal bin width and
consequently the number of bins (see `Notes` for more detail on
the estimators) from the data that falls within the requested
range. While the bin width will be optimal for the actual data
in the range, the number of bins will be computed to fill the
entire range, including the empty portions. For visualisation,
using the 'auto' option is suggested. Weighted data is not
supported for automated bin size selection.

'auto'
    Maximum of the 'sturges' and 'fd' estimators. Provides good
    all around performance.

'fd' (Freedman Diaconis Estimator)
    Robust (resilient to outliers) estimator that takes into
    account data variability and data size.

'doane'
    An improved version of Sturges' estimator that works better
    with non-normal datasets.

'scott'
    Less robust estimator that takes into account data variability
    and data size.

'stone'
    Estimator based on leave-one-out cross-validation estimate of
    the integrated squared error. Can be regarded as a generalization
    of Scott's rule.

'rice'
    Estimator does not take variability into account, only data
    size. Commonly overestimates number of bins required.

'sturges'
    R's default method, only accounts for data size. Only
    optimal for gaussian data and underestimates number of bins
    for large non-gaussian datasets.

'sqrt'
    Square root (of data size) estimator, used by Excel and
    other programs for its speed and simplicity.

range : (float, float), optional

The lower and upper range of the bins.  If not provided, range
is simply ``(a.min(), a.max())``.  Values outside the range are
ignored. The first element of the range must be less than or
equal to the second. `range` affects the automatic bin
computation as well. While bin width is computed to be optimal
based on the actual data within `range`, the bin count will fill
the entire range including portions containing no data.

weights : array_like, optional

An array of weights, of the same shape as `a`.  Each value in
`a` only contributes its associated weight towards the bin count
(instead of 1). This is currently not used by any of the bin estimators,
but may be in the future.

Returns ------- bin_edges : array of dtype float

The edges to pass into `histogram`

See Also -------- histogram

Notes ----- The methods to estimate the optimal number of bins are well founded in literature, and are inspired by the choices R provides for histogram visualisation. Note that having the number of bins proportional to :math:`n^{1/3}` is asymptotically optimal, which is why it appears in most estimators. These are simply plug-in methods that give good starting points for number of bins. In the equations below, :math:`h` is the binwidth and :math:`n_h` is the number of bins. All estimators that compute bin counts are recast to bin width using the `ptp` of the data. The final bin count is obtained from “np.round(np.ceil(range / h))“. The final bin width is often less than what is returned by the estimators below.

'auto' (maximum of the 'sturges' and 'fd' estimators)

A compromise to get a good value. For small datasets the Sturges
value will usually be chosen, while larger datasets will usually
default to FD.  Avoids the overly conservative behaviour of FD
and Sturges for small and large datasets respectively.
Switchover point is usually :math:`a.size \approx 1000`.

'fd' (Freedman Diaconis Estimator)

.. math:: h = 2 \frac{IQR}{n^{1/3}}

The binwidth is proportional to the interquartile range (IQR)
and inversely proportional to cube root of a.size. Can be too
conservative for small datasets, but is quite good for large
datasets. The IQR is very robust to outliers.

'scott'

.. math:: h = \sigma \sqrt[3]{\frac{24 \sqrt{\pi}}{n}}

The binwidth is proportional to the standard deviation of the
data and inversely proportional to cube root of ``x.size``. Can
be too conservative for small datasets, but is quite good for
large datasets. The standard deviation is not very robust to
outliers. Values are very similar to the Freedman-Diaconis
estimator in the absence of outliers.

'rice'

.. math:: n_h = 2n^{1/3}

The number of bins is only proportional to cube root of
``a.size``. It tends to overestimate the number of bins and it
does not take into account data variability.

'sturges'

.. math:: n_h = \log _{2}(n) + 1

The number of bins is the base 2 log of ``a.size``.  This
estimator assumes normality of data and is too conservative for
larger, non-normal datasets. This is the default method in R's
``hist`` method.

'doane'

.. math:: n_h = 1 + \log_{2}(n) +
                \log_{2}\left(1 + \frac{|g_1|}{\sigma_{g_1}}\right)

    g_1 = mean\left[\left(\frac{x - \mu}{\sigma}\right)^3\right]

    \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}}

An improved version of Sturges' formula that produces better
estimates for non-normal datasets. This estimator attempts to
account for the skew of the data.

'sqrt'

.. math:: n_h = \sqrt n

The simplest and fastest estimator. Only takes into account the
data size.

Examples -------- >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]) >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1)) array([0. , 0.25, 0.5 , 0.75, 1. ]) >>> np.histogram_bin_edges(arr, bins=2) array([0. , 2.5, 5. ])

For consistency with histogram, an array of pre-computed bins is passed through unmodified:

>>> np.histogram_bin_edges(arr, [1, 2]) array([1, 2])

This function allows one set of bins to be computed, and reused across multiple histograms:

>>> shared_bins = np.histogram_bin_edges(arr, bins='auto') >>> shared_bins array([0., 1., 2., 3., 4., 5.])

>>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1]) >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins) >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)

>>> hist_0; hist_1 array([1, 1, 0, 1, 0]) array([2, 0, 1, 1, 2])

Which gives more easily comparable results than using separate bins for each histogram:

>>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto') >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto') >>> hist_0; hist_1 array([1, 1, 1]) array([2, 1, 1, 2]) >>> bins_0; bins_1 array([0., 1., 2., 3.]) array([0. , 1.25, 2.5 , 3.75, 5. ])

func Histogramdd ¶

func Histogramdd(sample *py.Object, bins *py.Object, range_ *py.Object, density *py.Object, weights *py.Object) *py.Object

Compute the multidimensional histogram of some data.

Parameters ---------- sample : (N, D) array, or (N, D) array_like

The data to be histogrammed.

Note the unusual interpretation of sample when an array_like:

* When an array, each row is a coordinate in a D-dimensional space -
  such as ``histogramdd(np.array([p1, p2, p3]))``.
* When an array_like, each element is the list of values for single
  coordinate - such as ``histogramdd((X, Y, Z))``.

The first form should be preferred.

bins : sequence or int, optional

The bin specification:

* A sequence of arrays describing the monotonically increasing bin
  edges along each dimension.
* The number of bins for each dimension (nx, ny, ... =bins)
* The number of bins for all dimensions (nx=ny=...=bins).

range : sequence, optional

A sequence of length D, each an optional (lower, upper) tuple giving
the outer bin edges to be used if the edges are not given explicitly in
`bins`.
An entry of None in the sequence results in the minimum and maximum
values being used for the corresponding dimension.
The default, None, is equivalent to passing a tuple of D None values.

density : bool, optional

If False, the default, returns the number of samples in each bin.
If True, returns the probability *density* function at the bin,
``bin_count / sample_count / bin_volume``.

weights : (N,) array_like, optional

An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`.
Weights are normalized to 1 if density is True. If density is False,
the values of the returned histogram are equal to the sum of the
weights belonging to the samples falling into each bin.

Returns ------- H : ndarray

The multidimensional histogram of sample x. See density and weights
for the different possible semantics.

edges : list

A list of D arrays describing the bin edges for each dimension.

See Also -------- histogram: 1-D histogram histogram2d: 2-D histogram

Examples -------- >>> r = np.random.randn(100,3) >>> H, edges = np.histogramdd(r, bins = (5, 8, 4)) >>> H.shape, edges[0].size, edges[1].size, edges[2].size ((5, 8, 4), 6, 9, 5)

func Hsplit ¶

func Hsplit(ary *py.Object, indicesOrSections *py.Object) *py.Object

Split an array into multiple sub-arrays horizontally (column-wise).

Please refer to the `split` documentation. `hsplit` is equivalent to `split` with “axis=1“, the array is always split along the second axis except for 1-D arrays, where it is split at “axis=0“.

See Also -------- split : Split an array into multiple sub-arrays of equal size.

Examples -------- >>> x = np.arange(16.0).reshape(4, 4) >>> x array([[ 0., 1., 2., 3.],

[ 4.,   5.,   6.,   7.],
[ 8.,   9.,  10.,  11.],
[12.,  13.,  14.,  15.]])

>>> np.hsplit(x, 2) [array([[ 0., 1.],

      [  4.,   5.],
      [  8.,   9.],
      [12.,  13.]]),
array([[  2.,   3.],
      [  6.,   7.],
      [10.,  11.],
      [14.,  15.]])]

>>> np.hsplit(x, np.array([3, 6])) [array([[ 0., 1., 2.],

      [ 4.,   5.,   6.],
      [ 8.,   9.,  10.],
      [12.,  13.,  14.]]),
array([[ 3.],
      [ 7.],
      [11.],
      [15.]]),
array([], shape=(4, 0), dtype=float64)]

With a higher dimensional array the split is still along the second axis.

>>> x = np.arange(8.0).reshape(2, 2, 2) >>> x array([[[0., 1.],

 [2.,  3.]],
[[4.,  5.],
 [6.,  7.]]])

>>> np.hsplit(x, 2) [array([[[0., 1.]],

      [[4.,  5.]]]),
array([[[2.,  3.]],
      [[6.,  7.]]])]

With a 1-D array, the split is along axis 0.

>>> x = np.array([0, 1, 2, 3, 4, 5]) >>> np.hsplit(x, 2) [array([0, 1, 2]), array([3, 4, 5])]

func Hstack ¶

func Hstack(tup *py.Object) *py.Object

Stack arrays in sequence horizontally (column wise).

This is equivalent to concatenation along the second axis, except for 1-D arrays where it concatenates along the first axis. Rebuilds arrays divided by `hsplit`.

This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions `concatenate`, `stack` and `block` provide more general stacking and concatenation operations.

Parameters ---------- tup : sequence of ndarrays

The arrays must have the same shape along all but the second axis,
except 1-D arrays which can be any length.

dtype : str or dtype

If provided, the destination array will have this dtype. Cannot be
provided together with `out`.

.. versionadded:: 1.24

casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

Controls what kind of data casting may occur. Defaults to 'same_kind'.

.. versionadded:: 1.24

Returns ------- stacked : ndarray

The array formed by stacking the given arrays.

See Also -------- concatenate : Join a sequence of arrays along an existing axis. stack : Join a sequence of arrays along a new axis. block : Assemble an nd-array from nested lists of blocks. vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third axis). column_stack : Stack 1-D arrays as columns into a 2-D array. hsplit : Split an array into multiple sub-arrays horizontally (column-wise).

Examples -------- >>> a = np.array((1,2,3)) >>> b = np.array((4,5,6)) >>> np.hstack((a,b)) array([1, 2, 3, 4, 5, 6]) >>> a = np.array([[1],[2],[3]]) >>> b = np.array([[4],[5],[6]]) >>> np.hstack((a,b)) array([[1, 4],

[2, 5],
[3, 6]])

func Hypot ¶

func Hypot(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Given the "legs" of a right triangle, return its hypotenuse.

Equivalent to “sqrt(x1**2 + x2**2)“, element-wise. If `x1` or `x2` is scalar_like (i.e., unambiguously cast-able to a scalar type), it is broadcast for use with each element of the other argument. (See Examples)

Parameters ---------- x1, x2 : array_like

Leg of the triangle(s).
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- z : ndarray

The hypotenuse of the triangle(s).
This is a scalar if both `x1` and `x2` are scalars.

Examples -------- >>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) array([[ 5., 5., 5.],

[ 5.,  5.,  5.],
[ 5.,  5.,  5.]])

Example showing broadcast of scalar_like argument:

>>> np.hypot(3*np.ones((3, 3)), [4]) array([[ 5., 5., 5.],

[ 5.,  5.,  5.],
[ 5.,  5.,  5.]])

func I0 ¶

func I0(x *py.Object) *py.Object

Modified Bessel function of the first kind, order 0.

Usually denoted :math:`I_0`.

Parameters ---------- x : array_like of float

Argument of the Bessel function.

Returns ------- out : ndarray, shape = x.shape, dtype = float

The modified Bessel function evaluated at each of the elements of `x`.

See Also -------- scipy.special.i0, scipy.special.iv, scipy.special.ive

Notes ----- The scipy implementation is recommended over this function: it is a proper ufunc written in C, and more than an order of magnitude faster.

We use the algorithm published by Clenshaw [1]_ and referenced by Abramowitz and Stegun [2]_, for which the function domain is partitioned into the two intervals [0,8] and (8,inf), and Chebyshev polynomial expansions are employed in each interval. Relative error on the domain [0,30] using IEEE arithmetic is documented [3]_ as having a peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).

References ---------- .. [1] C. W. Clenshaw, "Chebyshev series for mathematical functions", in

*National Physical Laboratory Mathematical Tables*, vol. 5, London:
Her Majesty's Stationery Office, 1962.

.. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical

Functions*, 10th printing, New York: Dover, 1964, pp. 379.
https://personal.math.ubc.ca/~cbm/aands/page_379.htm

.. [3] https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero

Examples -------- >>> np.i0(0.) array(1.0) >>> np.i0([0, 1, 2, 3]) array([1. , 1.26606588, 2.2795853 , 4.88079259])

func Identity ¶

func Identity(n *py.Object, dtype *py.Object) *py.Object

Return the identity array.

The identity array is a square array with ones on the main diagonal.

Parameters ---------- n : int

Number of rows (and columns) in `n` x `n` output.

dtype : data-type, optional

Data-type of the output.  Defaults to ``float``.

like : array_like, optional

Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.

.. versionadded:: 1.20.0

Returns ------- out : ndarray

`n` x `n` array with its main diagonal set to one,
and all other elements 0.

Examples -------- >>> np.identity(3) array([[1., 0., 0.],

[0.,  1.,  0.],
[0.,  0.,  1.]])

func Imag ¶

func Imag(val *py.Object) *py.Object

Return the imaginary part of the complex argument.

Parameters ---------- val : array_like

Input array.

Returns ------- out : ndarray or scalar

The imaginary component of the complex argument. If `val` is real,
the type of `val` is used for the output.  If `val` has complex
elements, the returned type is float.

See Also -------- real, angle, real_if_close

Examples -------- >>> a = np.array([1+2j, 3+4j, 5+6j]) >>> a.imag array([2., 4., 6.]) >>> a.imag = np.array([8, 10, 12]) >>> a array([1. +8.j, 3.+10.j, 5.+12.j]) >>> np.imag(1 + 1j) 1.0

func In1d ¶

func In1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object, invert *py.Object) *py.Object

Test whether each element of a 1-D array is also present in a second array.

Returns a boolean array the same length as `ar1` that is True where an element of `ar1` is in `ar2` and False otherwise.

We recommend using :func:`isin` instead of `in1d` for new code.

Parameters ---------- ar1 : (M,) array_like

Input array.

ar2 : array_like

The values against which to test each value of `ar1`.

assume_unique : bool, optional

If True, the input arrays are both assumed to be unique, which
can speed up the calculation.  Default is False.

invert : bool, optional

If True, the values in the returned array are inverted (that is,
False where an element of `ar1` is in `ar2` and True otherwise).
Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
to (but is faster than) ``np.invert(in1d(a, b))``.

kind : {None, 'sort', 'table'}, optional

The algorithm to use. This will not affect the final result,
but will affect the speed and memory use. The default, None,
will select automatically based on memory considerations.

* If 'sort', will use a mergesort-based approach. This will have
  a memory usage of roughly 6 times the sum of the sizes of
  `ar1` and `ar2`, not accounting for size of dtypes.
* If 'table', will use a lookup table approach similar
  to a counting sort. This is only available for boolean and
  integer arrays. This will have a memory usage of the
  size of `ar1` plus the max-min value of `ar2`. `assume_unique`
  has no effect when the 'table' option is used.
* If None, will automatically choose 'table' if
  the required memory allocation is less than or equal to
  6 times the sum of the sizes of `ar1` and `ar2`,
  otherwise will use 'sort'. This is done to not use
  a large amount of memory by default, even though
  'table' may be faster in most cases. If 'table' is chosen,
  `assume_unique` will have no effect.

.. versionadded:: 1.8.0

Returns ------- in1d : (M,) ndarray, bool

The values `ar1[in1d]` are in `ar2`.

See Also -------- isin : Version of this function that preserves the

shape of ar1.

numpy.lib.arraysetops : Module with a number of other functions for

performing set operations on arrays.

Notes ----- `in1d` can be considered as an element-wise function version of the python keyword `in`, for 1-D sequences. “in1d(a, b)“ is roughly equivalent to “np.array([item in b for item in a])“. However, this idea fails if `ar2` is a set, or similar (non-sequence) container: As “ar2“ is converted to an array, in those cases “asarray(ar2)“ is an object array rather than the expected array of contained values.

Using “kind='table'“ tends to be faster than `kind='sort'` if the following relationship is true: “log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927“, but may use greater memory. The default value for `kind` will be automatically selected based only on memory usage, so one may manually set “kind='table'“ if memory constraints can be relaxed.

.. versionadded:: 1.4.0

Examples -------- >>> test = np.array([0, 1, 2, 5, 0]) >>> states = [0, 2] >>> mask = np.in1d(test, states) >>> mask array([ True, False, True, False, True]) >>> test[mask] array([0, 2, 0]) >>> mask = np.in1d(test, states, invert=True) >>> mask array([False, True, False, True, False]) >>> test[mask] array([1, 5])

func Indices ¶

func Indices(dimensions *py.Object, dtype *py.Object, sparse *py.Object) *py.Object

Return an array representing the indices of a grid.

Compute an array where the subarrays contain index values 0, 1, ... varying only along the corresponding axis.

Parameters ---------- dimensions : sequence of ints

The shape of the grid.

dtype : dtype, optional

Data type of the result.

sparse : boolean, optional

Return a sparse representation of the grid instead of a dense
representation. Default is False.

.. versionadded:: 1.17

Returns ------- grid : one ndarray or tuple of ndarrays

If sparse is False:
    Returns one array of grid indices,
    ``grid.shape = (len(dimensions),) + tuple(dimensions)``.
If sparse is True:
    Returns a tuple of arrays, with
    ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with
    dimensions[i] in the ith place

See Also -------- mgrid, ogrid, meshgrid

Notes ----- The output shape in the dense case is obtained by prepending the number of dimensions in front of the tuple of dimensions, i.e. if `dimensions` is a tuple “(r0, ..., rN-1)“ of length “N“, the output shape is “(N, r0, ..., rN-1)“.

The subarrays “grid[k]“ contains the N-D array of indices along the “k-th“ axis. Explicitly::

grid[k, i0, i1, ..., iN-1] = ik

Examples -------- >>> grid = np.indices((2, 3)) >>> grid.shape (2, 2, 3) >>> grid[0] # row indices array([[0, 0, 0],

[1, 1, 1]])

>>> grid[1] # column indices array([[0, 1, 2],

[0, 1, 2]])

The indices can be used as an index into an array.

>>> x = np.arange(20).reshape(5, 4) >>> row, col = np.indices((2, 3)) >>> x[row, col] array([[0, 1, 2],

[4, 5, 6]])

Note that it would be more straightforward in the above example to extract the required elements directly with “x[:2, :3]“.

If sparse is set to true, the grid will be returned in a sparse representation.

>>> i, j = np.indices((2, 3), sparse=True) >>> i.shape (2, 1) >>> j.shape (1, 3) >>> i # row indices array([[0],

[1]])

>>> j # column indices array([[0, 1, 2]])

func Info ¶

func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object

Get help information for an array, function, class, or module.

Parameters ---------- object : object or str, optional

Input object or name to get information about. If `object` is
an `ndarray` instance, information about the array is printed.
If `object` is a numpy object, its docstring is given. If it is
a string, available modules are searched for matching objects.
If None, information about `info` itself is returned.

maxwidth : int, optional

Printing width.

output : file like object, optional

File like object that the output is written to, default is
``None``, in which case ``sys.stdout`` will be used.
The object has to be opened in 'w' or 'a' mode.

toplevel : str, optional

Start search at this level.

See Also -------- source, lookfor

Notes ----- When used interactively with an object, “np.info(obj)“ is equivalent to “help(obj)“ on the Python prompt or “obj?“ on the IPython prompt.

Examples -------- >>> np.info(np.polyval) # doctest: +SKIP

polyval(p, x)
  Evaluate the polynomial p at x.
  ...

When using a string for `object` it is possible to get multiple results.

>>> np.info('fft') # doctest: +SKIP

*** Found in numpy ***

Core FFT routines ...

    *** Found in numpy.fft ***
fft(a, n=None, axis=-1)

...

*** Repeat reference found in numpy.fft.fftpack ***
*** Total of 3 references found. ***

When the argument is an array, information about the array is printed.

>>> a = np.array([[1 + 2j, 3, -4], [-5j, 6, 0]], dtype=np.complex64) >>> np.info(a) class: ndarray shape: (2, 3) strides: (24, 8) itemsize: 8 aligned: True contiguous: True fortran: False data pointer: 0x562b6e0d2860 # may vary byteorder: little byteswap: False type: complex64

func Inner ¶

func Inner(a *py.Object, b *py.Object) *py.Object

inner(a, b, /)

Inner product of two arrays.

Ordinary inner product of vectors for 1-D arrays (without complex conjugation), in higher dimensions a sum product over the last axes.

Parameters ---------- a, b : array_like

If `a` and `b` are nonscalar, their last dimensions must match.

Returns ------- out : ndarray

If `a` and `b` are both
scalars or both 1-D arrays then a scalar is returned; otherwise
an array is returned.
``out.shape = (*a.shape[:-1], *b.shape[:-1])``

Raises ------ ValueError

If both `a` and `b` are nonscalar and their last dimensions have
different sizes.

See Also -------- tensordot : Sum products over arbitrary axes. dot : Generalised matrix product, using second last dimension of `b`. einsum : Einstein summation convention.

Notes ----- For vectors (1-D arrays) it computes the ordinary inner-product::

np.inner(a, b) = sum(a[:]*b[:])

More generally, if “ndim(a) = r > 0“ and “ndim(b) = s > 0“::

np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))

or explicitly::

np.inner(a, b)[i0,...,ir-2,j0,...,js-2]
     = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])

In addition `a` or `b` may be scalars, in which case::

np.inner(a,b) = a*b

Examples -------- Ordinary inner product for vectors:

>>> a = np.array([1,2,3]) >>> b = np.array([0,1,0]) >>> np.inner(a, b) 2

Some multidimensional examples:

>>> a = np.arange(24).reshape((2,3,4)) >>> b = np.arange(4) >>> c = np.inner(a, b) >>> c.shape (2, 3) >>> c array([[ 14, 38, 62],

[ 86, 110, 134]])

>>> a = np.arange(2).reshape((1,1,2)) >>> b = np.arange(6).reshape((3,2)) >>> c = np.inner(a, b) >>> c.shape (1, 1, 3) >>> c array([[[1, 3, 5]]])

An example where `b` is a scalar:

>>> np.inner(np.eye(2), 7) array([[7., 0.],

[0., 7.]])

func Insert ¶

func Insert(arr *py.Object, obj *py.Object, values *py.Object, axis *py.Object) *py.Object

Insert values along the given axis before the given indices.

Parameters ---------- arr : array_like

Input array.

obj : int, slice or sequence of ints

Object that defines the index or indices before which `values` is
inserted.

.. versionadded:: 1.8.0

Support for multiple insertions when `obj` is a single scalar or a
sequence with one element (similar to calling insert multiple
times).

values : array_like

Values to insert into `arr`. If the type of `values` is different
from that of `arr`, `values` is converted to the type of `arr`.
`values` should be shaped so that ``arr[...,obj,...] = values``
is legal.

axis : int, optional

Axis along which to insert `values`.  If `axis` is None then `arr`
is flattened first.

Returns ------- out : ndarray

A copy of `arr` with `values` inserted.  Note that `insert`
does not occur in-place: a new array is returned. If
`axis` is None, `out` is a flattened array.

See Also -------- append : Append elements at the end of an array. concatenate : Join a sequence of arrays along an existing axis. delete : Delete elements from an array.

Notes ----- Note that for higher dimensional inserts “obj=0“ behaves very different from “obj=[0]“ just like “arr[:,0,:] = values“ is different from “arr[:,[0],:] = values“.

Examples -------- >>> a = np.array([[1, 1], [2, 2], [3, 3]]) >>> a array([[1, 1],

[2, 2],
[3, 3]])

>>> np.insert(a, 1, 5) array([1, 5, 1, ..., 2, 3, 3]) >>> np.insert(a, 1, 5, axis=1) array([[1, 5, 1],

[2, 5, 2],
[3, 5, 3]])

Difference between sequence and scalars:

>>> np.insert(a, [1], [[1],[2],[3]], axis=1) array([[1, 1, 1],

[2, 2, 2],
[3, 3, 3]])

>>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1), ... np.insert(a, [1], [[1],[2],[3]], axis=1)) True

>>> b = a.flatten() >>> b array([1, 1, 2, 2, 3, 3]) >>> np.insert(b, [2, 2], [5, 6]) array([1, 1, 5, ..., 2, 3, 3])

>>> np.insert(b, slice(2, 4), [5, 6]) array([1, 1, 5, ..., 2, 3, 3])

>>> np.insert(b, [2, 2], [7.13, False]) # type casting array([1, 1, 7, ..., 2, 3, 3])

>>> x = np.arange(8).reshape(2, 4) >>> idx = (1, 3) >>> np.insert(x, idx, 999, axis=1) array([[ 0, 999, 1, 2, 999, 3],

[  4, 999,   5,   6, 999,   7]])

func Interp ¶

func Interp(x *py.Object, xp *py.Object, fp *py.Object, left *py.Object, right *py.Object, period *py.Object) *py.Object

One-dimensional linear interpolation for monotonically increasing sample points.

Returns the one-dimensional piecewise linear interpolant to a function with given discrete data points (`xp`, `fp`), evaluated at `x`.

Parameters ---------- x : array_like

The x-coordinates at which to evaluate the interpolated values.

xp : 1-D sequence of floats

The x-coordinates of the data points, must be increasing if argument
`period` is not specified. Otherwise, `xp` is internally sorted after
normalizing the periodic boundaries with ``xp = xp % period``.

fp : 1-D sequence of float or complex

The y-coordinates of the data points, same length as `xp`.

left : optional float or complex corresponding to fp

Value to return for `x < xp[0]`, default is `fp[0]`.

right : optional float or complex corresponding to fp

Value to return for `x > xp[-1]`, default is `fp[-1]`.

period : None or float, optional

A period for the x-coordinates. This parameter allows the proper
interpolation of angular x-coordinates. Parameters `left` and `right`
are ignored if `period` is specified.

.. versionadded:: 1.10.0

Returns ------- y : float or complex (corresponding to fp) or ndarray

The interpolated values, same shape as `x`.

Raises ------ ValueError

If `xp` and `fp` have different length
If `xp` or `fp` are not 1-D sequences
If `period == 0`

See Also -------- scipy.interpolate

Warnings -------- The x-coordinate sequence is expected to be increasing, but this is not explicitly enforced. However, if the sequence `xp` is non-increasing, interpolation results are meaningless.

Note that, since NaN is unsortable, `xp` also cannot contain NaNs.

A simple check for `xp` being strictly increasing is::

np.all(np.diff(xp) > 0)

Examples -------- >>> xp = [1, 2, 3] >>> fp = [3, 2, 0] >>> np.interp(2.5, xp, fp) 1.0 >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp) array([3. , 3. , 2.5 , 0.56, 0. ]) >>> UNDEF = -99.0 >>> np.interp(3.14, xp, fp, right=UNDEF) -99.0

Plot an interpolant to the sine function:

>>> x = np.linspace(0, 2*np.pi, 10) >>> y = np.sin(x) >>> xvals = np.linspace(0, 2*np.pi, 50) >>> yinterp = np.interp(xvals, x, y) >>> import matplotlib.pyplot as plt >>> plt.plot(x, y, 'o') [<matplotlib.lines.Line2D object at 0x...>] >>> plt.plot(xvals, yinterp, '-x') [<matplotlib.lines.Line2D object at 0x...>] >>> plt.show()

Interpolation with periodic x-coordinates:

>>> x = [-180, -170, -185, 185, -10, -5, 0, 365] >>> xp = [190, -190, 350, -350] >>> fp = [5, 10, 3, 4] >>> np.interp(x, xp, fp, period=360) array([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75])

Complex interpolation:

>>> x = [1.5, 4.0] >>> xp = [2,3,5] >>> fp = [1.0j, 0, 2+3j] >>> np.interp(x, xp, fp) array([0.+1.j , 1.+1.5j])

func Intersect1d ¶

func Intersect1d(ar1 *py.Object, ar2 *py.Object, assumeUnique *py.Object, returnIndices *py.Object) *py.Object

Find the intersection of two arrays.

Return the sorted, unique values that are in both of the input arrays.

Parameters ---------- ar1, ar2 : array_like

Input arrays. Will be flattened if not already 1D.

assume_unique : bool

If True, the input arrays are both assumed to be unique, which
can speed up the calculation.  If True but ``ar1`` or ``ar2`` are not
unique, incorrect results and out-of-bounds indices could result.
Default is False.

return_indices : bool

If True, the indices which correspond to the intersection of the two
arrays are returned. The first instance of a value is used if there are
multiple. Default is False.

.. versionadded:: 1.15.0

Returns ------- intersect1d : ndarray

Sorted 1D array of common and unique elements.

comm1 : ndarray

The indices of the first occurrences of the common values in `ar1`.
Only provided if `return_indices` is True.

comm2 : ndarray

The indices of the first occurrences of the common values in `ar2`.
Only provided if `return_indices` is True.

See Also -------- numpy.lib.arraysetops : Module with a number of other functions for

performing set operations on arrays.

Examples -------- >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1]) array([1, 3])

To intersect more than two arrays, use functools.reduce:

>>> from functools import reduce >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) array([3])

To return the indices of the values common to the input arrays along with the intersected values:

>>> x = np.array([1, 1, 2, 3, 4]) >>> y = np.array([2, 1, 4, 6]) >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True) >>> x_ind, y_ind (array([0, 2, 4]), array([1, 0, 2])) >>> xy, x[x_ind], y[y_ind] (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))

func Invert ¶

func Invert(x *py.Object, out *py.Object) *py.Object

invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Compute bit-wise inversion, or bit-wise NOT, element-wise.

Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator “~“.

For signed integer inputs, the two's complement is returned. In a two's-complement system negative numbers are represented by the two's complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two's-complement system can represent every integer in the range :math:`-2^{N-1}` to :math:`+2^{N-1}-1`.

Parameters ---------- x : array_like

Only integer and boolean types are handled.

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

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 ------- out : ndarray or scalar

Result.
This is a scalar if `x` is a scalar.

See Also -------- bitwise_and, bitwise_or, bitwise_xor logical_not binary_repr :

Return the binary representation of the input number as a string.

Notes ----- `bitwise_not` is an alias for `invert`:

>>> np.bitwise_not is np.invert True

References ---------- .. [1] Wikipedia, "Two's complement",

https://en.wikipedia.org/wiki/Two's_complement

Examples -------- We've seen that 13 is represented by “00001101“. The invert or bit-wise NOT of 13 is then:

>>> x = np.invert(np.array(13, dtype=np.uint8)) >>> x 242 >>> np.binary_repr(x, width=8) '11110010'

The result depends on the bit-width:

>>> x = np.invert(np.array(13, dtype=np.uint16)) >>> x 65522 >>> np.binary_repr(x, width=16) '1111111111110010'

When using signed integer types the result is the two's complement of the result for the unsigned type:

>>> np.invert(np.array([13], dtype=np.int8)) array([-14], dtype=int8) >>> np.binary_repr(-14, width=8) '11110010'

Booleans are accepted as well:

>>> np.invert(np.array([True, False])) array([False, True])

The “~“ operator can be used as a shorthand for “np.invert“ on ndarrays.

>>> x1 = np.array([True, False]) >>> ~x1 array([False, True])

func IsBusday ¶

func IsBusday(dates *py.Object, weekmask *py.Object, holidays *py.Object, busdaycal *py.Object, out *py.Object) *py.Object

is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)

Calculates which of the given dates are valid days, and which are not.

.. versionadded:: 1.7.0

Parameters ---------- dates : array_like of datetime64[D]

The array of dates to process.

weekmask : str or array_like of bool, optional

A seven-element array indicating which of Monday through Sunday are
valid days. May be specified as a length-seven list or array, like
[1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for
weekdays, optionally separated by white space. Valid abbreviations
are: Mon Tue Wed Thu Fri Sat Sun

holidays : array_like of datetime64[D], optional

An array of dates to consider as invalid dates.  They may be
specified in any order, and NaT (not-a-time) dates are ignored.
This list is saved in a normalized form that is suited for
fast calculations of valid days.

busdaycal : busdaycalendar, optional

A `busdaycalendar` object which specifies the valid days. If this
parameter is provided, neither weekmask nor holidays may be
provided.

out : array of bool, optional

If provided, this array is filled with the result.

Returns ------- out : array of bool

An array with the same shape as ``dates``, containing True for
each valid day, and False for each invalid day.

See Also -------- busdaycalendar : An object that specifies a custom set of valid days. busday_offset : Applies an offset counted in valid days. busday_count : Counts how many valid days are in a half-open date range.

Examples -------- >>> # The weekdays are Friday, Saturday, and Monday ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'], ... holidays=['2011-07-01', '2011-07-04', '2011-07-17']) array([False, False, True])

func Isclose ¶

func Isclose(a *py.Object, b *py.Object, rtol *py.Object, atol *py.Object, equalNan *py.Object) *py.Object

Returns a boolean array where two arrays are element-wise equal within a tolerance.

The tolerance values are positive, typically very small numbers. The relative difference (`rtol` * abs(`b`)) and the absolute difference `atol` are added together to compare against the absolute difference between `a` and `b`.

.. warning:: The default `atol` is not appropriate for comparing numbers

that are much smaller than one (see Notes).

Parameters ---------- a, b : array_like

Input arrays to compare.

rtol : float

The relative tolerance parameter (see Notes).

atol : float

The absolute tolerance parameter (see Notes).

equal_nan : bool

Whether to compare NaN's as equal.  If True, NaN's in `a` will be
considered equal to NaN's in `b` in the output array.

Returns ------- y : array_like

Returns a boolean array of where `a` and `b` are equal within the
given tolerance. If both `a` and `b` are scalars, returns a single
boolean value.

See Also -------- allclose math.isclose

Notes ----- .. versionadded:: 1.7.0

For finite values, isclose uses the following equation to test whether two floating point values are equivalent.

absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))

Unlike the built-in `math.isclose`, the above equation is not symmetric in `a` and `b` -- it assumes `b` is the reference value -- so that `isclose(a, b)` might be different from `isclose(b, a)`. Furthermore, the default value of atol is not zero, and is used to determine what small values should be considered close to zero. The default value is appropriate for expected values of order unity: if the expected values are significantly smaller than one, it can result in false positives. `atol` should be carefully selected for the use case at hand. A zero value for `atol` will result in `False` if either `a` or `b` is zero.

`isclose` is not defined for non-numeric data types. `bool` is considered a numeric data-type for this purpose.

Examples -------- >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8]) array([ True, False]) >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9]) array([ True, True]) >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9]) array([False, True]) >>> np.isclose([1.0, np.nan], [1.0, np.nan]) array([ True, False]) >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) array([ True, True]) >>> np.isclose([1e-8, 1e-7], [0.0, 0.0]) array([ True, False]) >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0) array([False, False]) >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0]) array([ True, True]) >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0) array([False, True])

func Iscomplex ¶

func Iscomplex(x *py.Object) *py.Object

Returns a bool array, where True if input element is complex.

What is tested is whether the input has a non-zero imaginary part, not if the input type is complex.

Parameters ---------- x : array_like

Input array.

Returns ------- out : ndarray of bools

Output array.

See Also -------- isreal iscomplexobj : Return True if x is a complex type or an array of complex

numbers.

Examples -------- >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j]) array([ True, False, False, False, False, True])

func Iscomplexobj ¶

func Iscomplexobj(x *py.Object) *py.Object

Check for a complex type or an array of complex numbers.

The type of the input is checked, not the value. Even if the input has an imaginary part equal to zero, `iscomplexobj` evaluates to True.

Parameters ---------- x : any

The input can be of any type and shape.

Returns ------- iscomplexobj : bool

The return value, True if `x` is of a complex type or has at least
one complex element.

See Also -------- isrealobj, iscomplex

Examples -------- >>> np.iscomplexobj(1) False >>> np.iscomplexobj(1+0j) True >>> np.iscomplexobj([3, 1+0j, True]) True

func Isfinite ¶

func Isfinite(x *py.Object, out *py.Object) *py.Object

isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Test element-wise for finiteness (not infinity and not Not a Number).

The result is returned as a boolean array.

Parameters ---------- x : array_like

Input values.

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

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, bool

True where ``x`` is not positive infinity, negative infinity,
or NaN; false otherwise.
This is a scalar if `x` is a scalar.

See Also -------- isinf, isneginf, isposinf, isnan

Notes ----- Not a Number, positive infinity and negative infinity are considered to be non-finite.

NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Also that positive infinity is not equivalent to negative infinity. But infinity is equivalent to positive infinity. Errors result if the second argument is also supplied when `x` is a scalar input, or if first and second arguments have different shapes.

Examples -------- >>> np.isfinite(1) True >>> np.isfinite(0) True >>> np.isfinite(np.nan) False >>> np.isfinite(np.inf) False >>> np.isfinite(np.NINF) False >>> np.isfinite([np.log(-1.),1.,np.log(0)]) array([False, True, False])

>>> x = np.array([-np.inf, 0., np.inf]) >>> y = np.array([2, 2, 2]) >>> np.isfinite(x, y) array([0, 1, 0]) >>> y array([0, 1, 0])

func Isfortran ¶

func Isfortran(a *py.Object) *py.Object

Check if the array is Fortran contiguous but *not* C contiguous.

This function is obsolete and, because of changes due to relaxed stride checking, its return value for the same array may differ for versions of NumPy >= 1.10.0 and previous versions. If you only want to check if an array is Fortran contiguous use “a.flags.f_contiguous“ instead.

Parameters ---------- a : ndarray

Input array.

Returns ------- isfortran : bool

Returns True if the array is Fortran contiguous but *not* C contiguous.

Examples --------

np.array allows to specify whether the array is written in C-contiguous order (last index varies the fastest), or FORTRAN-contiguous order in memory (first index varies the fastest).

>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') >>> a array([[1, 2, 3],

[4, 5, 6]])

>>> np.isfortran(a) False

>>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F') >>> b array([[1, 2, 3],

[4, 5, 6]])

>>> np.isfortran(b) True

The transpose of a C-ordered array is a FORTRAN-ordered array.

>>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C') >>> a array([[1, 2, 3],

[4, 5, 6]])

>>> np.isfortran(a) False >>> b = a.T >>> b array([[1, 4],

[2, 5],
[3, 6]])

>>> np.isfortran(b) True

C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.

>>> np.isfortran(np.array([1, 2], order='F')) False

func Isin ¶

func Isin(element *py.Object, testElements *py.Object, assumeUnique *py.Object, invert *py.Object) *py.Object

Calculates “element in test_elements“, broadcasting over `element` only. Returns a boolean array of the same shape as `element` that is True where an element of `element` is in `test_elements` and False otherwise.

Parameters ---------- element : array_like

Input array.

test_elements : array_like

The values against which to test each value of `element`.
This argument is flattened if it is an array or array_like.
See notes for behavior with non-array-like parameters.

assume_unique : bool, optional

If True, the input arrays are both assumed to be unique, which
can speed up the calculation.  Default is False.

invert : bool, optional

If True, the values in the returned array are inverted, as if
calculating `element not in test_elements`. Default is False.
``np.isin(a, b, invert=True)`` is equivalent to (but faster
than) ``np.invert(np.isin(a, b))``.

kind : {None, 'sort', 'table'}, optional

The algorithm to use. This will not affect the final result,
but will affect the speed and memory use. The default, None,
will select automatically based on memory considerations.

* If 'sort', will use a mergesort-based approach. This will have
  a memory usage of roughly 6 times the sum of the sizes of
  `ar1` and `ar2`, not accounting for size of dtypes.
* If 'table', will use a lookup table approach similar
  to a counting sort. This is only available for boolean and
  integer arrays. This will have a memory usage of the
  size of `ar1` plus the max-min value of `ar2`. `assume_unique`
  has no effect when the 'table' option is used.
* If None, will automatically choose 'table' if
  the required memory allocation is less than or equal to
  6 times the sum of the sizes of `ar1` and `ar2`,
  otherwise will use 'sort'. This is done to not use
  a large amount of memory by default, even though
  'table' may be faster in most cases. If 'table' is chosen,
  `assume_unique` will have no effect.

Returns ------- isin : ndarray, bool

Has the same shape as `element`. The values `element[isin]`
are in `test_elements`.

See Also -------- in1d : Flattened version of this function. numpy.lib.arraysetops : Module with a number of other functions for

performing set operations on arrays.

Notes -----

`isin` is an element-wise function version of the python keyword `in`. “isin(a, b)“ is roughly equivalent to “np.array([item in b for item in a])“ if `a` and `b` are 1-D sequences.

`element` and `test_elements` are converted to arrays if they are not already. If `test_elements` is a set (or other non-sequence collection) it will be converted to an object array with one element, rather than an array of the values contained in `test_elements`. This is a consequence of the `array` constructor's way of handling non-sequence collections. Converting the set to a list usually gives the desired behavior.

Using “kind='table'“ tends to be faster than `kind='sort'` if the following relationship is true: “log10(len(ar2)) > (log10(max(ar2)-min(ar2)) - 2.27) / 0.927“, but may use greater memory. The default value for `kind` will be automatically selected based only on memory usage, so one may manually set “kind='table'“ if memory constraints can be relaxed.

.. versionadded:: 1.13.0

Examples -------- >>> element = 2*np.arange(4).reshape((2, 2)) >>> element array([[0, 2],

[4, 6]])

>>> test_elements = [1, 2, 4, 8] >>> mask = np.isin(element, test_elements) >>> mask array([[False, True],

[ True, False]])

>>> element[mask] array([2, 4])

The indices of the matched values can be obtained with `nonzero`:

>>> np.nonzero(mask) (array([0, 1]), array([1, 0]))

The test can also be inverted:

>>> mask = np.isin(element, test_elements, invert=True) >>> mask array([[ True, False],

[False,  True]])

>>> element[mask] array([0, 6])

Because of how `array` handles sets, the following does not work as expected:

>>> test_set = {1, 2, 4, 8} >>> np.isin(element, test_set) array([[False, False],

[False, False]])

Casting the set to a list gives the expected result:

>>> np.isin(element, list(test_set)) array([[False, True],

[ True, False]])

func Isinf ¶

func Isinf(x *py.Object, out *py.Object) *py.Object

isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Test element-wise for positive or negative infinity.

Returns a boolean array of the same shape as `x`, True where “x == +/-inf“, otherwise False.

Parameters ---------- x : array_like

Input values

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

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 : bool (scalar) or boolean ndarray

True where ``x`` is positive or negative infinity, false otherwise.
This is a scalar if `x` is a scalar.

See Also -------- isneginf, isposinf, isnan, isfinite

Notes ----- NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).

Errors result if the second argument is supplied when the first argument is a scalar, or if the first and second arguments have different shapes.

Examples -------- >>> np.isinf(np.inf) True >>> np.isinf(np.nan) False >>> np.isinf(np.NINF) True >>> np.isinf([np.inf, -np.inf, 1.0, np.nan]) array([ True, True, False, False])

>>> x = np.array([-np.inf, 0., np.inf]) >>> y = np.array([2, 2, 2]) >>> np.isinf(x, y) array([1, 0, 1]) >>> y array([1, 0, 1])

func Isnan ¶

func Isnan(x *py.Object, out *py.Object) *py.Object

isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Test element-wise for NaN and return result as a boolean array.

Parameters ---------- x : array_like

Input array.

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

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 or bool

True where ``x`` is NaN, false otherwise.
This is a scalar if `x` is a scalar.

See Also -------- isinf, isneginf, isposinf, isfinite, isnat

Notes ----- NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity.

Examples -------- >>> np.isnan(np.nan) True >>> np.isnan(np.inf) False >>> np.isnan([np.log(-1.),1.,np.log(0)]) array([ True, False, False])

func Isnat ¶

func Isnat(x *py.Object, out *py.Object) *py.Object

isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Test element-wise for NaT (not a time) and return result as a boolean array.

.. versionadded:: 1.13.0

Parameters ---------- x : array_like

Input array with datetime or timedelta data type.

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

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 or bool

True where ``x`` is NaT, false otherwise.
This is a scalar if `x` is a scalar.

See Also -------- isnan, isinf, isneginf, isposinf, isfinite

Examples -------- >>> np.isnat(np.datetime64("NaT")) True >>> np.isnat(np.datetime64("2016-01-01")) False >>> np.isnat(np.array(["NaT", "2016-01-01"], dtype="datetime64[ns]")) array([ True, False])

func Isneginf ¶

func Isneginf(x *py.Object, out *py.Object) *py.Object

Test element-wise for negative infinity, return result as bool array.

Parameters ---------- x : array_like

The input array.

out : array_like, optional

A location into which the result is stored. If provided, it must have a
shape that the input broadcasts to. If not provided or None, a
freshly-allocated boolean array is returned.

Returns ------- out : ndarray

A boolean array with the same dimensions as the input.
If second argument is not supplied then a numpy boolean array is
returned with values True where the corresponding element of the
input is negative infinity and values False where the element of
the input is not negative infinity.

If a second argument is supplied the result is stored there. If the
type of that array is a numeric type the result is represented as
zeros and ones, if the type is boolean then as False and True. The
return value `out` is then a reference to that array.

See Also -------- isinf, isposinf, isnan, isfinite

Notes ----- NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).

Errors result if the second argument is also supplied when x is a scalar input, if first and second arguments have different shapes, or if the first argument has complex values.

Examples -------- >>> np.isneginf(np.NINF) True >>> np.isneginf(np.inf) False >>> np.isneginf(np.PINF) False >>> np.isneginf([-np.inf, 0., np.inf]) array([ True, False, False])

>>> x = np.array([-np.inf, 0., np.inf]) >>> y = np.array([2, 2, 2]) >>> np.isneginf(x, y) array([1, 0, 0]) >>> y array([1, 0, 0])

func Isposinf ¶

func Isposinf(x *py.Object, out *py.Object) *py.Object

Test element-wise for positive infinity, return result as bool array.

Parameters ---------- x : array_like

The input array.

out : array_like, optional

A location into which the result is stored. If provided, it must have a
shape that the input broadcasts to. If not provided or None, a
freshly-allocated boolean array is returned.

Returns ------- out : ndarray

A boolean array with the same dimensions as the input.
If second argument is not supplied then a boolean array is returned
with values True where the corresponding element of the input is
positive infinity and values False where the element of the input is
not positive infinity.

If a second argument is supplied the result is stored there. If the
type of that array is a numeric type the result is represented as zeros
and ones, if the type is boolean then as False and True.
The return value `out` is then a reference to that array.

See Also -------- isinf, isneginf, isfinite, isnan

Notes ----- NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).

Errors result if the second argument is also supplied when x is a scalar input, if first and second arguments have different shapes, or if the first argument has complex values

Examples -------- >>> np.isposinf(np.PINF) True >>> np.isposinf(np.inf) True >>> np.isposinf(np.NINF) False >>> np.isposinf([-np.inf, 0., np.inf]) array([False, False, True])

>>> x = np.array([-np.inf, 0., np.inf]) >>> y = np.array([2, 2, 2]) >>> np.isposinf(x, y) array([0, 0, 1]) >>> y array([0, 0, 1])

func Isreal ¶

func Isreal(x *py.Object) *py.Object

Returns a bool array, where True if input element is real.

If element has complex type with zero complex part, the return value for that element is True.

Parameters ---------- x : array_like

Input array.

Returns ------- out : ndarray, bool

Boolean array of same shape as `x`.

Notes ----- `isreal` may behave unexpectedly for string or object arrays (see examples)

See Also -------- iscomplex isrealobj : Return True if x is not a complex type.

Examples -------- >>> a = np.array([1+1j, 1+0j, 4.5, 3, 2, 2j], dtype=complex) >>> np.isreal(a) array([False, True, True, True, True, False])

The function does not work on string arrays.

>>> a = np.array([2j, "a"], dtype="U") >>> np.isreal(a) # Warns about non-elementwise comparison False

Returns True for all elements in input array of “dtype=object“ even if any of the elements is complex.

>>> a = np.array([1, "2", 3+4j], dtype=object) >>> np.isreal(a) array([ True, True, True])

isreal should not be used with object arrays

>>> a = np.array([1+2j, 2+1j], dtype=object) >>> np.isreal(a) array([ True, True])

func Isrealobj ¶

func Isrealobj(x *py.Object) *py.Object

Return True if x is a not complex type or an array of complex numbers.

The type of the input is checked, not the value. So even if the input has an imaginary part equal to zero, `isrealobj` evaluates to False if the data type is complex.

Parameters ---------- x : any

The input can be of any type and shape.

Returns ------- y : bool

The return value, False if `x` is of a complex type.

See Also -------- iscomplexobj, isreal

Notes ----- The function is only meant for arrays with numerical values but it accepts all other objects. Since it assumes array input, the return value of other objects may be True.

>>> np.isrealobj('A string') True >>> np.isrealobj(False) True >>> np.isrealobj(None) True

Examples -------- >>> np.isrealobj(1) True >>> np.isrealobj(1+0j) False >>> np.isrealobj([3, 1+0j, True]) False

func Isscalar ¶

func Isscalar(element *py.Object) *py.Object

Returns True if the type of `element` is a scalar type.

Parameters ---------- element : any

Input argument, can be of any type and shape.

Returns ------- val : bool

True if `element` is a scalar type, False if it is not.

See Also -------- ndim : Get the number of dimensions of an array

Notes ----- If you need a stricter way to identify a *numerical* scalar, use “isinstance(x, numbers.Number)“, as that returns “False“ for most non-numerical elements such as strings.

In most cases “np.ndim(x) == 0“ should be used instead of this function, as that will also return true for 0d arrays. This is how numpy overloads functions in the style of the “dx“ arguments to `gradient` and the “bins“ argument to `histogram`. Some key differences:

+--------------------------------------+---------------+-------------------+ | x |“isscalar(x)“|“np.ndim(x) == 0“| +======================================+===============+===================+ | PEP 3141 numeric objects (including | “True“ | “True“ | | builtins) | | | +--------------------------------------+---------------+-------------------+ | builtin string and buffer objects | “True“ | “True“ | +--------------------------------------+---------------+-------------------+ | other builtin objects, like | “False“ | “True“ | | `pathlib.Path`, `Exception`, | | | | the result of `re.compile` | | | +--------------------------------------+---------------+-------------------+ | third-party objects like | “False“ | “True“ | | `matplotlib.figure.Figure` | | | +--------------------------------------+---------------+-------------------+ | zero-dimensional numpy arrays | “False“ | “True“ | +--------------------------------------+---------------+-------------------+ | other numpy arrays | “False“ | “False“ | +--------------------------------------+---------------+-------------------+ | `list`, `tuple`, and other sequence | “False“ | “False“ | | objects | | | +--------------------------------------+---------------+-------------------+

Examples -------- >>> np.isscalar(3.1) True >>> np.isscalar(np.array(3.1)) False >>> np.isscalar([3.1]) False >>> np.isscalar(False) True >>> np.isscalar('numpy') True

NumPy supports PEP 3141 numbers:

>>> from fractions import Fraction >>> np.isscalar(Fraction(5, 17)) True >>> from numbers import Number >>> np.isscalar(Number()) True

func Issctype ¶

func Issctype(rep *py.Object) *py.Object

Determines whether the given object represents a scalar data-type.

Parameters ---------- rep : any

If `rep` is an instance of a scalar dtype, True is returned. If not,
False is returned.

Returns ------- out : bool

Boolean result of check whether `rep` is a scalar dtype.

See Also -------- issubsctype, issubdtype, obj2sctype, sctype2char

Examples -------- >>> np.issctype(np.int32) True >>> np.issctype(list) False >>> np.issctype(1.1) False

Strings are also a scalar type:

>>> np.issctype(np.dtype('str')) True

func Issubclass_ ¶

func Issubclass_(arg1 *py.Object, arg2 *py.Object) *py.Object

Determine if a class is a subclass of a second class.

`issubclass_` is equivalent to the Python built-in “issubclass“, except that it returns False instead of raising a TypeError if one of the arguments is not a class.

Parameters ---------- arg1 : class

Input class. True is returned if `arg1` is a subclass of `arg2`.

arg2 : class or tuple of classes.

Input class. If a tuple of classes, True is returned if `arg1` is a
subclass of any of the tuple elements.

Returns ------- out : bool

Whether `arg1` is a subclass of `arg2` or not.

See Also -------- issubsctype, issubdtype, issctype

Examples -------- >>> np.issubclass_(np.int32, int) False >>> np.issubclass_(np.int32, float) False >>> np.issubclass_(np.float64, float) True

func Issubdtype ¶

func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object

Returns True if first argument is a typecode lower/equal in type hierarchy.

This is like the builtin :func:`issubclass`, but for `dtype`\ s.

Parameters ---------- arg1, arg2 : dtype_like

`dtype` or object coercible to one

Returns ------- out : bool

See Also -------- :ref:`arrays.scalars` : Overview of the numpy type hierarchy. issubsctype, issubclass_

Examples -------- `issubdtype` can be used to check the type of arrays:

>>> ints = np.array([1, 2, 3], dtype=np.int32) >>> np.issubdtype(ints.dtype, np.integer) True >>> np.issubdtype(ints.dtype, np.floating) False

>>> floats = np.array([1, 2, 3], dtype=np.float32) >>> np.issubdtype(floats.dtype, np.integer) False >>> np.issubdtype(floats.dtype, np.floating) True

Similar types of different sizes are not subdtypes of each other:

>>> np.issubdtype(np.float64, np.float32) False >>> np.issubdtype(np.float32, np.float64) False

but both are subtypes of `floating`:

>>> np.issubdtype(np.float64, np.floating) True >>> np.issubdtype(np.float32, np.floating) True

For convenience, dtype-like objects are allowed too:

>>> np.issubdtype('S1', np.string_) True >>> np.issubdtype('i4', np.signedinteger) True

func Issubsctype ¶

func Issubsctype(arg1 *py.Object, arg2 *py.Object) *py.Object

Determine if the first argument is a subclass of the second argument.

Parameters ---------- arg1, arg2 : dtype or dtype specifier

Data-types.

Returns ------- out : bool

The result.

See Also -------- issctype, issubdtype, obj2sctype

Examples -------- >>> np.issubsctype('S8', str) False >>> np.issubsctype(np.array([1]), int) True >>> np.issubsctype(np.array([1]), float) False

func Iterable ¶

func Iterable(y *py.Object) *py.Object

Check whether or not an object can be iterated over.

Parameters ---------- y : object

Input object.

Returns ------- b : bool

Return ``True`` if the object has an iterator method or is a
sequence and ``False`` otherwise.

Examples -------- >>> np.iterable([1, 2, 3]) True >>> np.iterable(2) False

Notes ----- In most cases, the results of “np.iterable(obj)“ are consistent with “isinstance(obj, collections.abc.Iterable)“. One notable exception is the treatment of 0-dimensional arrays::

>>> from collections.abc import Iterable
>>> a = np.array(1.0)  # 0-dimensional numpy array
>>> isinstance(a, Iterable)
True
>>> np.iterable(a)
False

func Ix_ ¶

func Ix_(__llgo_va_list ...interface{}) *py.Object

Construct an open mesh from multiple sequences.

This function takes N 1-D sequences and returns N outputs with N dimensions each, such that the shape is 1 in all but one dimension and the dimension with the non-unit shape value cycles through all N dimensions.

Using `ix_` one can quickly construct index arrays that will index the cross product. “a[np.ix_([1,3],[2,5])]“ returns the array “[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]“.

Parameters ---------- args : 1-D sequences

Each sequence should be of integer or boolean type.
Boolean sequences will be interpreted as boolean masks for the
corresponding dimension (equivalent to passing in
``np.nonzero(boolean_sequence)``).

Returns ------- out : tuple of ndarrays

N arrays with N dimensions each, with N the number of input
sequences. Together these arrays form an open mesh.

See Also -------- ogrid, mgrid, meshgrid

Examples -------- >>> a = np.arange(10).reshape(2, 5) >>> a array([[0, 1, 2, 3, 4],

[5, 6, 7, 8, 9]])

>>> ixgrid = np.ix_([0, 1], [2, 4]) >>> ixgrid (array([[0],

[1]]), array([[2, 4]]))

>>> ixgrid[0].shape, ixgrid[1].shape ((2, 1), (1, 2)) >>> a[ixgrid] array([[2, 4],

[7, 9]])

>>> ixgrid = np.ix_([True, True], [2, 4]) >>> a[ixgrid] array([[2, 4],

[7, 9]])

>>> ixgrid = np.ix_([True, True], [False, False, True, False, True]) >>> a[ixgrid] array([[2, 4],

[7, 9]])

func Kaiser ¶

func Kaiser(M *py.Object, beta *py.Object) *py.Object

Return the Kaiser window.

The Kaiser window is a taper formed by using a Bessel function.

Parameters ---------- M : int

Number of points in the output window. If zero or less, an
empty array is returned.

beta : float

Shape parameter for window.

Returns ------- out : array

The window, with the maximum value normalized to one (the value
one appears only if the number of samples is odd).

See Also -------- bartlett, blackman, hamming, hanning

Notes ----- The Kaiser window is defined as

.. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}}

\right)/I_0(\beta)

with

.. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2},

where :math:`I_0` is the modified zeroth-order Bessel function.

The Kaiser was named for Jim Kaiser, who discovered a simple approximation to the DPSS window based on Bessel functions. The Kaiser window is a very good approximation to the Digital Prolate Spheroidal Sequence, or Slepian window, which is the transform which maximizes the energy in the main lobe of the window relative to total energy.

The Kaiser can approximate many other windows by varying the beta parameter.

==== ======================= beta Window shape ==== ======================= 0 Rectangular 5 Similar to a Hamming 6 Similar to a Hanning 8.6 Similar to a Blackman ==== =======================

A beta value of 14 is probably a good starting point. Note that as beta gets large, the window narrows, and so the number of samples needs to be large enough to sample the increasingly narrow spike, otherwise NaNs will get returned.

Most references to the Kaiser window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means "removing the foot", i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.

References ---------- .. [1] J. F. Kaiser, "Digital Filters" - Ch 7 in "Systems analysis by

digital computer", Editors: F.F. Kuo and J.F. Kaiser, p 218-285.
John Wiley and Sons, New York, (1966).

.. [2] E.R. Kanasewich, "Time Sequence Analysis in Geophysics", The

University of Alberta Press, 1975, pp. 177-178.

.. [3] Wikipedia, "Window function",

https://en.wikipedia.org/wiki/Window_function

Examples -------- >>> import matplotlib.pyplot as plt >>> np.kaiser(12, 14)

array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary
       2.29737120e-01, 5.99885316e-01, 9.45674898e-01,
       9.45674898e-01, 5.99885316e-01, 2.29737120e-01,
       4.65200189e-02, 3.46009194e-03, 7.72686684e-06])

Plot the window and the frequency response:

>>> from numpy.fft import fft, fftshift >>> window = np.kaiser(51, 14) >>> plt.plot(window) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Kaiser window") Text(0.5, 1.0, 'Kaiser window') >>> plt.ylabel("Amplitude") Text(0, 0.5, 'Amplitude') >>> plt.xlabel("Sample") Text(0.5, 0, 'Sample') >>> plt.show()

>>> plt.figure() <Figure size 640x480 with 0 Axes> >>> A = fft(window, 2048) / 25.5 >>> mag = np.abs(fftshift(A)) >>> freq = np.linspace(-0.5, 0.5, len(A)) >>> response = 20 * np.log10(mag) >>> response = np.clip(response, -100, 100) >>> plt.plot(freq, response) [<matplotlib.lines.Line2D object at 0x...>] >>> plt.title("Frequency response of Kaiser window") Text(0.5, 1.0, 'Frequency response of Kaiser window') >>> plt.ylabel("Magnitude [dB]") Text(0, 0.5, 'Magnitude [dB]') >>> plt.xlabel("Normalized frequency [cycles per sample]") Text(0.5, 0, 'Normalized frequency [cycles per sample]') >>> plt.axis('tight') (-0.5, 0.5, -100.0, ...) # may vary >>> plt.show()

func Kron ¶

func Kron(a *py.Object, b *py.Object) *py.Object

Kronecker product of two arrays.

Computes the Kronecker product, a composite array made of blocks of the second array scaled by the first.

Parameters ---------- a, b : array_like

Returns ------- out : ndarray

See Also -------- outer : The outer product

Notes ----- The function assumes that the number of dimensions of `a` and `b` are the same, if necessary prepending the smallest with ones. If “a.shape = (r0,r1,..,rN)“ and “b.shape = (s0,s1,...,sN)“, the Kronecker product has shape “(r0*s0, r1*s1, ..., rN*SN)“. The elements are products of elements from `a` and `b`, organized explicitly by::

kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]

where::

kt = it * st + jt,  t = 0,...,N

In the common 2-D case (N=1), the block structure can be visualized::

[[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
 [  ...                              ...   ],
 [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]

Examples -------- >>> np.kron([1,10,100], [5,6,7]) array([ 5, 6, 7, ..., 500, 600, 700]) >>> np.kron([5,6,7], [1,10,100]) array([ 5, 50, 500, ..., 7, 70, 700])

>>> np.kron(np.eye(2), np.ones((2,2))) array([[1., 1., 0., 0.],

[1.,  1.,  0.,  0.],
[0.,  0.,  1.,  1.],
[0.,  0.,  1.,  1.]])

>>> a = np.arange(100).reshape((2,5,2,5)) >>> b = np.arange(24).reshape((2,3,4)) >>> c = np.kron(a,b) >>> c.shape (2, 10, 6, 20) >>> I = (1,3,0,2) >>> J = (0,2,1) >>> J1 = (0,) + J # extend to ndim=4 >>> S1 = (1,) + b.shape >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1)) >>> c[K] == a[I]*b[J] True

func Lcm ¶

func Lcm(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Returns the lowest common multiple of “|x1|“ and “|x2|“

Parameters ---------- x1, x2 : array_like, int

Arrays of values.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

Returns ------- y : ndarray or scalar

The lowest common multiple of the absolute value of the inputs
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- gcd : The greatest common divisor

Examples -------- >>> np.lcm(12, 20) 60 >>> np.lcm.reduce([3, 12, 20]) 60 >>> np.lcm.reduce([40, 12, 20]) 120 >>> np.lcm(np.arange(6), 20) array([ 0, 20, 20, 60, 20, 20])

func Ldexp ¶

func Ldexp(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Returns x1 * 2**x2, element-wise.

The mantissas `x1` and twos exponents `x2` are used to construct floating point numbers “x1 * 2**x2“.

Parameters ---------- x1 : array_like

Array of multipliers.

x2 : array_like, int

Array of twos exponents.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 or scalar

The result of ``x1 * 2**x2``.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- frexp : Return (y1, y2) from “x = y1 * 2**y2“, inverse to `ldexp`.

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

`ldexp` is useful as the inverse of `frexp`, if used by itself it is more clear to simply use the expression “x1 * 2**x2“.

Examples -------- >>> np.ldexp(5, np.arange(4)) array([ 5., 10., 20., 40.], dtype=float16)

>>> x = np.arange(6) >>> np.ldexp(*np.frexp(x)) array([ 0., 1., 2., 3., 4., 5.])

func LeftShift ¶

func LeftShift(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Shift the bits of an integer to the left.

Bits are shifted to the left by appending `x2` 0s at the right of `x1`. Since the internal representation of numbers is in binary format, this operation is equivalent to multiplying `x1` by “2**x2“.

Parameters ---------- x1 : array_like of integer type

Input values.

x2 : array_like of integer type

Number of zeros to append to `x1`. Has to be non-negative.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : array of integer type

Return `x1` with bits shifted `x2` times to the left.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- right_shift : Shift the bits of an integer to the right. binary_repr : Return the binary representation of the input number

as a string.

Examples -------- >>> np.binary_repr(5) '101' >>> np.left_shift(5, 2) 20 >>> np.binary_repr(20) '10100'

>>> np.left_shift(5, [1,2,3]) array([10, 20, 40])

Note that the dtype of the second argument may change the dtype of the result and can lead to unexpected results in some cases (see :ref:`Casting Rules <ufuncs.casting>`):

>>> a = np.left_shift(np.uint8(255), 1) # Expect 254 >>> print(a, type(a)) # Unexpected result due to upcasting 510 <class 'numpy.int64'> >>> b = np.left_shift(np.uint8(255), np.uint8(1)) >>> print(b, type(b)) 254 <class 'numpy.uint8'>

The “<<“ operator can be used as a shorthand for “np.left_shift“ on ndarrays.

>>> x1 = 5 >>> x2 = np.array([1, 2, 3]) >>> x1 << x2 array([10, 20, 40])

func Less ¶

func Less(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the truth value of (x1 < x2) element-wise.

Parameters ---------- x1, x2 : array_like

Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : ndarray or scalar

Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- greater, less_equal, greater_equal, equal, not_equal

Examples -------- >>> np.less([1, 2], [2, 2]) array([ True, False])

The “<“ operator can be used as a shorthand for “np.less“ on ndarrays.

>>> a = np.array([1, 2]) >>> b = np.array([2, 2]) >>> a < b array([ True, False])

func LessEqual ¶

func LessEqual(x1 *py.Object, x2 *py.Object, out *py.Object) *py.Object

less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

Return the truth value of (x1 <= x2) element-wise.

Parameters ---------- x1, x2 : array_like

Input arrays.
If ``x1.shape != x2.shape``, they must be broadcastable to a common
shape (which becomes the shape of the output).

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

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 ------- out : ndarray or scalar

Output array, element-wise comparison of `x1` and `x2`.
Typically of type bool, unless ``dtype=object`` is passed.
This is a scalar if both `x1` and `x2` are scalars.

See Also -------- greater, less, greater_equal, equal, not_equal

Examples -------- >>> np.less_equal([4, 2, 1], [2, 2, 2]) array([False, True, True])

The “<=“ operator can be used as a shorthand for “np.less_equal“ on ndarrays.

>>> a = np.array([4, 2, 1]) >>> b = np.array([2, 2, 2]) >>> a <= b array([False, True, True])

func Lexsort ¶

func Lexsort(keys *py.Object, axis *py.Object) *py.Object

lexsort(keys, axis=-1)

Perform an indirect stable sort using a sequence of keys.

Given multiple sorting keys, which can be interpreted as columns in a spreadsheet, lexsort returns an array of integer indices that describes the sort order by multiple columns. The last key in the sequence is used for the primary sort order, the second-to-last key for the secondary sort order, and so on. The keys argument must be a sequence of objects that can be converted to arrays of the same shape. If a 2D array is provided for the keys argument, its rows are interpreted as the sorting keys and sorting is according to the last row, second last row etc.

Parameters ---------- keys : (k, N) array or tuple containing k (N,)-shaped sequences

The `k` different "columns" to be sorted.  The last column (or row if
`keys` is a 2D array) is the primary sort key.

axis : int, optional

Axis to be indirectly sorted.  By default, sort over the last axis.

Returns ------- indices : (N,) ndarray of ints

Array of indices that sort the keys along the specified axis.

See Also -------- argsort : Indirect sort. ndarray.sort : In-place sort. sort : Return a sorted copy of an array.

Examples -------- Sort names: first by surname, then by name.

>>> surnames = ('Hertz', 'Galilei', 'Hertz') >>> first_names = ('Heinrich', 'Galileo', 'Gustav') >>> ind = np.lexsort((first_names, surnames)) >>> ind array([1, 2, 0])

>>> [surnames[i] + ", " + first_names[i] for i in ind] ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']

Sort two columns of numbers:

>>> a = [1,5,1,4,3,4,4] # First column >>> b = [9,4,0,4,0,2,1] # Second column >>> ind = np.lexsort((b,a)) # Sort by a, then by b >>> ind array([2, 0, 4, 6, 5, 3, 1])

>>> [(a[i],b[i]) for i in ind] [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]

Note that sorting is first according to the elements of “a“. Secondary sorting is according to the elements of “b“.

A normal “argsort“ would have yielded:

>>> [(a[i],b[i]) for i in np.argsort(a)] [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]

Structured arrays are sorted lexically by “argsort“:

>>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)], ... dtype=np.dtype([('x', int), ('y', int)]))

>>> np.argsort(x) # or np.argsort(x, order=('x', 'y')) array([2, 0, 4, 6, 5, 3, 1])

func Linspace ¶

func Linspace(start *py.Object, stop *py.Object, num *py.Object, endpoint *py.Object, retstep *py.Object, dtype *py.Object, axis *py.Object) *py.Object

Return evenly spaced numbers over a specified interval.

Returns `num` evenly spaced samples, calculated over the interval [`start`, `stop`].

The endpoint of the interval can optionally be excluded.

.. versionchanged:: 1.16.0

Non-scalar `start` and `stop` are now supported.

.. versionchanged:: 1.20.0

Values are rounded towards ``-inf`` instead of ``0`` when an
integer ``dtype`` is specified. The old behavior can
still be obtained with ``np.linspace(start, stop, num).astype(int)``

Parameters ---------- start : array_like

The starting value of the sequence.

stop : array_like

The end value of the sequence, unless `endpoint` is set to False.
In that case, the sequence consists of all but the last of ``num + 1``
evenly spaced samples, so that `stop` is excluded.  Note that the step
size changes when `endpoint` is False.

num : int, optional

Number of samples to generate. Default is 50. Must be non-negative.

endpoint : bool, optional

If True, `stop` is the last sample. Otherwise, it is not included.
Default is True.

retstep : bool, optional

If True, return (`samples`, `step`), where `step` is the spacing
between samples.

dtype : dtype, optional

The type of the output array.  If `dtype` is not given, the data type
is inferred from `start` and `stop`. The inferred dtype will never be
an integer; `float` is chosen even if the arguments would produce an
array of integers.

.. versionadded:: 1.9.0

axis : int, optional

The axis in the result to store the samples.  Relevant only if start
or stop are array-like.  By default (0), the samples will be along a
new axis inserted at the beginning. Use -1 to get an axis at the end.

.. versionadded:: 1.16.0

Returns ------- samples : ndarray

There are `num` equally spaced samples in the closed interval
``[start, stop]`` or the half-open interval ``[start, stop)``
(depending on whether `endpoint` is True or False).

step : float, optional

Only returned if `retstep` is True

Size of spacing between samples.

See Also -------- arange : Similar to `linspace`, but uses a step size (instead of the

number of samples).

geomspace : Similar to `linspace`, but with numbers spaced evenly on a log

scale (a geometric progression).

logspace : Similar to `geomspace`, but with the end points specified as

logarithms.

:ref:`how-to-partition`

Examples -------- >>> np.linspace(2.0, 3.0, num=5) array([2. , 2.25, 2.5 , 2.75, 3. ]) >>> np.linspace(2.0, 3.0, num=5, endpoint=False) array([2. , 2.2, 2.4, 2.6, 2.8]) >>> np.linspace(2.0, 3.0, num=5, retstep=True) (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)

Graphical illustration:

>>> import matplotlib.pyplot as plt >>> N = 8 >>> y = np.zeros(N) >>> x1 = np.linspace(0, 10, N, endpoint=True) >>> x2 = np.linspace(0, 10, N, endpoint=False) >>> plt.plot(x1, y, 'o') [<matplotlib.lines.Line2D object at 0x...>] >>> plt.plot(x2, y + 0.5, 'o') [<matplotlib.lines.Line2D object at 0x...>] >>> plt.ylim([-0.5, 1]) (-0.5, 1) >>> plt.show()

func Load ¶

func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *py.Object, encoding *py.Object) *py.Object

Load arrays or pickled objects from “.npy“, “.npz“ or pickled files.

.. warning:: Loading files that contain object arrays uses the “pickle“

module, which is not secure against erroneous or maliciously
constructed data. Consider passing ``allow_pickle=False`` to
load data that is known not to contain object arrays for the
safer handling of untrusted sources.

Parameters ---------- file : file-like object, string, or pathlib.Path

The file to read. File-like objects must support the
``seek()`` and ``read()`` methods and must always
be opened in binary mode.  Pickled files require that the
file-like object support the ``readline()`` method as well.

mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional

If not None, then memory-map the file, using the given mode (see
`numpy.memmap` for a detailed description of the modes).  A
memory-mapped array is kept on disk. However, it can be accessed
and sliced like any ndarray.  Memory mapping is especially useful
for accessing small fragments of large files without reading the
entire file into memory.

allow_pickle : bool, optional

Allow loading pickled object arrays stored in npy files. Reasons for
disallowing pickles include security, as loading pickled data can
execute arbitrary code. If pickles are disallowed, loading object
arrays will fail. Default: False

.. versionchanged:: 1.16.3
    Made default False in response to CVE-2019-6446.

fix_imports : bool, optional

Only useful when loading Python 2 generated pickled files on Python 3,
which includes npy/npz files containing object arrays. If `fix_imports`
is True, pickle will try to map the old Python 2 names to the new names
used in Python 3.

encoding : str, optional