package numpy

import (
	_ "unsafe"

	"github.com/goplus/llgo/py"
)

const LLGoPackage = "py.numpy"

// Show libraries and system information on which NumPy was built
// and is being used
//
// Parameters
// ----------
// mode : {`'stdout'`, `'dicts'`}, optional.
//
//	Indicates how to display the config information.
//	`'stdout'` prints to console, `'dicts'` returns a dictionary
//	of the configuration.
//
// Returns
// -------
// out : {`dict`, `None`}
//
//	If mode is `'dicts'`, a dict is returned, else None
//
// See Also
// --------
// get_include : Returns the directory containing NumPy C
//
//	header files.
//
// Notes
// -----
//  1. The `'stdout'` mode will give more readable
//     output if “pyyaml“ is installed
//
//go:linkname ShowConfig py.show_config
func ShowConfig(mode *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
//
//go:linkname Isfortran py.isfortran
func Isfortran(a *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]])
//
//go:linkname Fromfunction py.fromfunction
func Fromfunction(function *py.Object, shape *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
//
//go:linkname Isscalar py.isscalar
func Isscalar(element *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'
//
//go:linkname BinaryRepr py.binary_repr
func BinaryRepr(num *py.Object, width *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'
//
//go:linkname BaseRepr py.base_repr
func BaseRepr(number *py.Object, base *py.Object, padding *py.Object) *py.Object

// Return a new array of given shape and type, filled with ones.
//
// Parameters
// ----------
// shape : int or sequence of ints
//
//	Shape of the new array, e.g., ``(2, 3)`` or ``2``.
//
// dtype : data-type, optional
//
//	The desired 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 ones with the given shape, dtype, and order.
//
// See Also
// --------
// ones_like : Return an array of ones with shape and type of input.
// empty : Return a new uninitialized array.
// zeros : Return a new array setting values to zero.
// full : Return a new array of given shape filled with value.
//
// Examples
// --------
// >>> np.ones(5)
// array([1., 1., 1., 1., 1.])
//
// >>> np.ones((5,), dtype=int)
// array([1, 1, 1, 1, 1])
//
// >>> np.ones((2, 1))
// array([[1.],
//
//	[1.]])
//
// >>> s = (2,2)
// >>> np.ones(s)
// array([[1.,  1.],
//
//	[1.,  1.]])
//
//go:linkname Ones py.ones
func Ones(shape *py.Object, dtype *py.Object, order *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.]])
//
//go:linkname Identity py.identity
func Identity(n *py.Object, dtype *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])
//
//go:linkname BitwiseNot py.bitwise_not
func BitwiseNot(args ...*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]])
//
//go:linkname Full py.full
func Full(shape *py.Object, fillValue *py.Object, dtype *py.Object, order *py.Object) *py.Object

// matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj, axes, axis])
//
// Matrix product of two arrays.
//
// Parameters
// ----------
// x1, x2 : array_like
//
//	Input arrays, scalars not allowed.
//
// out : ndarray, optional
//
//	A location into which the result is stored. If provided, it must have
//	a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not
//	provided or None, a freshly-allocated array is returned.
//
// **kwargs
//
//	For other keyword-only arguments, see the
//	:ref:`ufunc docs <ufuncs.kwargs>`.
//
//	.. versionadded:: 1.16
//	   Now handles ufunc kwargs
//
// Returns
// -------
// y : ndarray
//
//	The matrix product of the inputs.
//	This is a scalar only when both x1, x2 are 1-d vectors.
//
// Raises
// ------
// ValueError
//
//	If the last dimension of `x1` is not the same size as
//	the second-to-last dimension of `x2`.
//
//	If a scalar value is passed in.
//
// See Also
// --------
// vdot : Complex-conjugating dot product.
// tensordot : Sum products over arbitrary axes.
// einsum : Einstein summation convention.
// dot : alternative matrix product with different broadcasting rules.
//
// Notes
// -----
//
// The behavior depends on the arguments in the following way.
//
//   - If both arguments are 2-D they are multiplied like conventional
//     matrices.
//   - If either argument is N-D, N > 2, it is treated as a stack of
//     matrices residing in the last two indexes and broadcast accordingly.
//   - If the first argument is 1-D, it is promoted to a matrix by
//     prepending a 1 to its dimensions. After matrix multiplication
//     the prepended 1 is removed.
//   - If the second argument is 1-D, it is promoted to a matrix by
//     appending a 1 to its dimensions. After matrix multiplication
//     the appended 1 is removed.
//
// “matmul“ differs from “dot“ in two important ways:
//
//   - Multiplication by scalars is not allowed, use “*“ instead.
//
//   - Stacks of matrices are broadcast together as if the matrices
//     were elements, respecting the signature “(n,k),(k,m)->(n,m)“:
//
//     >>> a = np.ones([9, 5, 7, 4])
//     >>> c = np.ones([9, 5, 4, 3])
//     >>> np.dot(a, c).shape
//     (9, 5, 7, 9, 5, 3)
//     >>> np.matmul(a, c).shape
//     (9, 5, 7, 3)
//     >>> # n is 7, k is 4, m is 3
//
// The matmul function implements the semantics of the “@“ operator
// introduced in Python 3.5 following :pep:`465`.
//
// It uses an optimized BLAS library when possible (see `numpy.linalg`).
//
// Examples
// --------
// For 2-D arrays it is the matrix product:
//
// >>> a = np.array([[1, 0],
// ...               [0, 1]])
// >>> b = np.array([[4, 1],
// ...               [2, 2]])
// >>> np.matmul(a, b)
// array([[4, 1],
//
//	[2, 2]])
//
// For 2-D mixed with 1-D, the result is the usual.
//
// >>> a = np.array([[1, 0],
// ...               [0, 1]])
// >>> b = np.array([1, 2])
// >>> np.matmul(a, b)
// array([1, 2])
// >>> np.matmul(b, a)
// array([1, 2])
//
// # Broadcasting is conventional for stacks of arrays
//
// >>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
// >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
// >>> np.matmul(a,b).shape
// (2, 2, 2)
// >>> np.matmul(a, b)[0, 1, 1]
// 98
// >>> sum(a[0, 1, :] * b[0 , :, 1])
// 98
//
// Vector, vector returns the scalar inner product, but neither argument
// is complex-conjugated:
//
// >>> np.matmul([2j, 3j], [2j, 3j])
// (-13+0j)
//
// Scalar multiplication raises an error.
//
// >>> np.matmul([1,2], 3)
// Traceback (most recent call last):
// ...
// ValueError: matmul: Input operand 1 does not have enough dimensions ...
//
// The “@“ operator can be used as a shorthand for “np.matmul“ on
// ndarrays.
//
// >>> x1 = np.array([2j, 3j])
// >>> x2 = np.array([2j, 3j])
// >>> x1 @ x2
// (-13+0j)
//
// .. versionadded:: 1.10.0
//
//go:linkname Matmul py.matmul
func Matmul(args ...*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])
//
//go:linkname Absolute py.absolute
func Absolute(args ...*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.]])
//
//go:linkname Add py.add
func Add(args ...*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()
//
//go:linkname Arccos py.arccos
func Arccos(args ...*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
//
//go:linkname Arccosh py.arccosh
func Arccosh(args ...*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
//
//go:linkname Arcsin py.arcsin
func Arcsin(args ...*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])
//
//go:linkname Arcsinh py.arcsinh
func Arcsinh(args ...*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()
//
//go:linkname Arctan py.arctan
func Arctan(args ...*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])
//
//go:linkname Arctan2 py.arctan2
func Arctan2(args ...*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])
//
//go:linkname Arctanh py.arctanh
func Arctanh(args ...*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])
//
//go:linkname BitwiseAnd py.bitwise_and
func BitwiseAnd(args ...*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])
//
//go:linkname BitwiseOr py.bitwise_or
func BitwiseOr(args ...*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])
//
//go:linkname BitwiseXor py.bitwise_xor
func BitwiseXor(args ...*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.])
//
//go:linkname Cbrt py.cbrt
func Cbrt(args ...*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.])
//
//go:linkname Ceil py.ceil
func Ceil(args ...*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]])
//
//go:linkname Conj py.conj
func Conj(args ...*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]])
//
//go:linkname Conjugate py.conjugate
func Conjugate(args ...*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.])
//
//go:linkname Copysign py.copysign
func Copysign(args ...*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)
//
//go:linkname Cos py.cos
func Cos(args ...*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()
//
//go:linkname Cosh py.cosh
func Cosh(args ...*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
//
//go:linkname Deg2rad py.deg2rad
func Deg2rad(args ...*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
//
//go:linkname Degrees py.degrees
func Degrees(args ...*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. ]])
//
//go:linkname Divide py.divide
func Divide(args ...*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]))
//
//go:linkname Divmod py.divmod
func Divmod(args ...*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])
//
//go:linkname Equal py.equal
func Equal(args ...*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()
//
//go:linkname Exp py.exp
func Exp(args ...*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.])
//
//go:linkname Exp2 py.exp2
func Exp2(args ...*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
//
//go:linkname Expm1 py.expm1
func Expm1(args ...*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])
//
//go:linkname Fabs py.fabs
func Fabs(args ...*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.])
//
//go:linkname Floor py.floor
func Floor(args ...*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.])
//
//go:linkname FloorDivide py.floor_divide
func FloorDivide(args ...*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])
//
//go:linkname FloatPower py.float_power
func FloatPower(args ...*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])
//
//go:linkname Fmax py.fmax
func Fmax(args ...*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])
//
//go:linkname Fmin py.fmin
func Fmin(args ...*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]])
//
//go:linkname Fmod py.fmod
func Fmod(args ...*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.])
//
//go:linkname Frexp py.frexp
func Frexp(args ...*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])
//
//go:linkname Gcd py.gcd
func Gcd(args ...*py.Object) *py.Object

// greater_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 : bool or ndarray of bool
//
//	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, less_equal, equal, not_equal
//
// Examples
// --------
// >>> np.greater_equal([4, 2, 1], [2, 2, 2])
// array([ True, True, False])
//
// The “>=“ operator can be used as a shorthand for “np.greater_equal“
// on ndarrays.
//
// >>> a = np.array([4, 2, 1])
// >>> b = np.array([2, 2, 2])
// >>> a >= b
// array([ True,  True, False])
//
//go:linkname GreaterEqual py.greater_equal
func GreaterEqual(args ...*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.])
//
//go:linkname Heaviside py.heaviside
func Heaviside(args ...*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.]])
//
//go:linkname Hypot py.hypot
func Hypot(args ...*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])
//
//go:linkname Invert py.invert
func Invert(args ...*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])
//
//go:linkname Isfinite py.isfinite
func Isfinite(args ...*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])
//
//go:linkname Isinf py.isinf
func Isinf(args ...*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])
//
//go:linkname Isnan py.isnan
func Isnan(args ...*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])
//
//go:linkname Isnat py.isnat
func Isnat(args ...*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])
//
//go:linkname Lcm py.lcm
func Lcm(args ...*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.])
//
//go:linkname Ldexp py.ldexp
func Ldexp(args ...*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])
//
//go:linkname LeftShift py.left_shift
func LeftShift(args ...*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])
//
//go:linkname Less py.less
func Less(args ...*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])
//
//go:linkname LessEqual py.less_equal
func LessEqual(args ...*py.Object) *py.Object

// log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Natural logarithm, element-wise.
//
// The natural logarithm `log` is the inverse of the exponential function,
// so that `log(exp(x)) = x`. The natural logarithm is logarithm in base
// `e`.
//
// Parameters
// ----------
// x : array_like
//
//	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 natural logarithm of `x`, element-wise.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// log10, log2, log1p, emath.log
//
// Notes
// -----
// Logarithm is a multivalued function: for each `x` there is an infinite
// number of `z` such that `exp(z) = x`. The convention is to return the
// `z` whose imaginary part lies in `(-pi, pi]`.
//
// For real-valued input data types, `log` always returns real output. For
// each value that cannot be expressed as a real number or infinity, it
// yields “nan“ and sets the `invalid` floating point error flag.
//
// For complex-valued input, `log` is a complex analytical function that
// has a branch cut `[-inf, 0]` and is continuous from above on it. `log`
// handles the floating-point negative zero as an infinitesimal negative
// number, conforming to the C99 standard.
//
// In the cases where the input has a negative real part and a very small
// negative complex part (approaching 0), the result is so close to `-pi`
// that it evaluates to exactly `-pi`.
//
// References
// ----------
// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
//
//	10th printing, 1964, pp. 67.
//	https://personal.math.ubc.ca/~cbm/aands/page_67.htm
//
// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm
//
// Examples
// --------
// >>> np.log([1, np.e, np.e**2, 0])
// array([  0.,   1.,   2., -Inf])
//
//go:linkname Log py.log
func Log(args ...*py.Object) *py.Object

// log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the base 10 logarithm of the input array, element-wise.
//
// 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
//
//	The logarithm to the base 10 of `x`, element-wise. NaNs are
//	returned where x is negative.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// emath.log10
//
// Notes
// -----
// Logarithm is a multivalued function: for each `x` there is an infinite
// number of `z` such that `10**z = x`. The convention is to return the
// `z` whose imaginary part lies in `(-pi, pi]`.
//
// For real-valued input data types, `log10` 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, `log10` is a complex analytical function that
// has a branch cut `[-inf, 0]` and is continuous from above on it.
// `log10` handles the floating-point negative zero as an infinitesimal
// negative number, conforming to the C99 standard.
//
// In the cases where the input has a negative real part and a very small
// negative complex part (approaching 0), the result is so close to `-pi`
// that it evaluates to exactly `-pi`.
//
// References
// ----------
// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
//
//	10th printing, 1964, pp. 67.
//	https://personal.math.ubc.ca/~cbm/aands/page_67.htm
//
// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm
//
// Examples
// --------
// >>> np.log10([1e-15, -3.])
// array([-15.,  nan])
//
//go:linkname Log10 py.log10
func Log10(args ...*py.Object) *py.Object

// log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the natural logarithm of one plus the input array, element-wise.
//
// Calculates “log(1 + x)“.
//
// 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
//
//	Natural logarithm of `1 + x`, element-wise.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// expm1 : “exp(x) - 1“, the inverse of `log1p`.
//
// Notes
// -----
// For real-valued input, `log1p` is accurate also for `x` so small
// that `1 + x == 1` in floating-point accuracy.
//
// Logarithm is a multivalued function: for each `x` there is an infinite
// number of `z` such that `exp(z) = 1 + x`. The convention is to return
// the `z` whose imaginary part lies in `[-pi, pi]`.
//
// For real-valued input data types, `log1p` 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, `log1p` is a complex analytical function that
// has a branch cut `[-inf, -1]` and is continuous from above on it.
// `log1p` handles the floating-point negative zero as an infinitesimal
// negative number, conforming to the C99 standard.
//
// References
// ----------
// .. [1] M. Abramowitz and I.A. Stegun, "Handbook of Mathematical Functions",
//
//	10th printing, 1964, pp. 67.
//	https://personal.math.ubc.ca/~cbm/aands/page_67.htm
//
// .. [2] Wikipedia, "Logarithm". https://en.wikipedia.org/wiki/Logarithm
//
// Examples
// --------
// >>> np.log1p(1e-99)
// 1e-99
// >>> np.log(1 + 1e-99)
// 0.0
//
//go:linkname Log1p py.log1p
func Log1p(args ...*py.Object) *py.Object

// log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Base-2 logarithm of `x`.
//
// 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
//
//	Base-2 logarithm of `x`.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// log, log10, log1p, emath.log2
//
// Notes
// -----
// .. versionadded:: 1.3.0
//
// Logarithm is a multivalued function: for each `x` there is an infinite
// number of `z` such that `2**z = x`. The convention is to return the `z`
// whose imaginary part lies in `(-pi, pi]`.
//
// For real-valued input data types, `log2` 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, `log2` is a complex analytical function that
// has a branch cut `[-inf, 0]` and is continuous from above on it. `log2`
// handles the floating-point negative zero as an infinitesimal negative
// number, conforming to the C99 standard.
//
// In the cases where the input has a negative real part and a very small
// negative complex part (approaching 0), the result is so close to `-pi`
// that it evaluates to exactly `-pi`.
//
// Examples
// --------
// >>> x = np.array([0, 1, 2, 2**4])
// >>> np.log2(x)
// array([-Inf,   0.,   1.,   4.])
//
// >>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])
// >>> np.log2(xi)
// array([ 0.+2.26618007j,  0.+0.j        ,  1.+0.j        ,  2.+2.26618007j])
//
//go:linkname Log2 py.log2
func Log2(args ...*py.Object) *py.Object

// logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Logarithm of the sum of exponentiations of the inputs.
//
// Calculates “log(exp(x1) + exp(x2))“. This function is useful in
// statistics where the calculated probabilities of events may be so small
// as to exceed the range of normal floating point numbers.  In such cases
// the logarithm of the calculated probability is stored. This function
// allows adding probabilities stored in such a fashion.
//
// Parameters
// ----------
// x1, x2 : array_like
//
//	Input values.
//	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
// -------
// result : ndarray
//
//	Logarithm of ``exp(x1) + exp(x2)``.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// See Also
// --------
// logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.
//
// Notes
// -----
// .. versionadded:: 1.3.0
//
// Examples
// --------
// >>> prob1 = np.log(1e-50)
// >>> prob2 = np.log(2.5e-50)
// >>> prob12 = np.logaddexp(prob1, prob2)
// >>> prob12
// -113.87649168120691
// >>> np.exp(prob12)
// 3.5000000000000057e-50
//
//go:linkname Logaddexp py.logaddexp
func Logaddexp(args ...*py.Object) *py.Object

// logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Logarithm of the sum of exponentiations of the inputs in base-2.
//
// Calculates “log2(2**x1 + 2**x2)“. This function is useful in machine
// learning when the calculated probabilities of events may be so small as
// to exceed the range of normal floating point numbers.  In such cases
// the base-2 logarithm of the calculated probability can be used instead.
// This function allows adding probabilities stored in such a fashion.
//
// Parameters
// ----------
// x1, x2 : array_like
//
//	Input values.
//	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
// -------
// result : ndarray
//
//	Base-2 logarithm of ``2**x1 + 2**x2``.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// See Also
// --------
// logaddexp: Logarithm of the sum of exponentiations of the inputs.
//
// Notes
// -----
// .. versionadded:: 1.3.0
//
// Examples
// --------
// >>> prob1 = np.log2(1e-50)
// >>> prob2 = np.log2(2.5e-50)
// >>> prob12 = np.logaddexp2(prob1, prob2)
// >>> prob1, prob2, prob12
// (-166.09640474436813, -164.77447664948076, -164.28904982231052)
// >>> 2**prob12
// 3.4999999999999914e-50
//
//go:linkname Logaddexp2 py.logaddexp2
func Logaddexp2(args ...*py.Object) *py.Object

// logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Compute the truth value of x1 AND 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
// -------
// y : ndarray or bool
//
//	Boolean result of the logical AND operation applied to the elements
//	of `x1` and `x2`; the shape is determined by broadcasting.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// See Also
// --------
// logical_or, logical_not, logical_xor
// bitwise_and
//
// Examples
// --------
// >>> np.logical_and(True, False)
// False
// >>> np.logical_and([True, False], [False, False])
// array([False, False])
//
// >>> x = np.arange(5)
// >>> np.logical_and(x>1, x<4)
// array([False, False,  True,  True, False])
//
// The “&“ operator can be used as a shorthand for “np.logical_and“ on
// boolean ndarrays.
//
// >>> a = np.array([True, False])
// >>> b = np.array([False, False])
// >>> a & b
// array([False, False])
//
//go:linkname LogicalAnd py.logical_and
func LogicalAnd(args ...*py.Object) *py.Object

// logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Compute the truth value of NOT x element-wise.
//
// Parameters
// ----------
// x : array_like
//
//	Logical NOT is applied to the elements of `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
// -------
// y : bool or ndarray of bool
//
//	Boolean result with the same shape as `x` of the NOT operation
//	on elements of `x`.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// logical_and, logical_or, logical_xor
//
// Examples
// --------
// >>> np.logical_not(3)
// False
// >>> np.logical_not([True, False, 0, 1])
// array([False,  True,  True, False])
//
// >>> x = np.arange(5)
// >>> np.logical_not(x<3)
// array([False, False, False,  True,  True])
//
//go:linkname LogicalNot py.logical_not
func LogicalNot(args ...*py.Object) *py.Object

// logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Compute the truth value of x1 OR x2 element-wise.
//
// Parameters
// ----------
// x1, x2 : array_like
//
//	Logical OR is applied to the elements of `x1` and `x2`.
//	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 bool
//
//	Boolean result of the logical OR operation applied to the elements
//	of `x1` and `x2`; the shape is determined by broadcasting.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// See Also
// --------
// logical_and, logical_not, logical_xor
// bitwise_or
//
// Examples
// --------
// >>> np.logical_or(True, False)
// True
// >>> np.logical_or([True, False], [False, False])
// array([ True, False])
//
// >>> x = np.arange(5)
// >>> np.logical_or(x < 1, x > 3)
// array([ True, False, False, False,  True])
//
// The “|“ operator can be used as a shorthand for “np.logical_or“ on
// boolean ndarrays.
//
// >>> a = np.array([True, False])
// >>> b = np.array([False, False])
// >>> a | b
// array([ True, False])
//
//go:linkname LogicalOr py.logical_or
func LogicalOr(args ...*py.Object) *py.Object

// logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Compute the truth value of x1 XOR x2, element-wise.
//
// Parameters
// ----------
// x1, x2 : array_like
//
//	Logical XOR is applied to the elements of `x1` and `x2`.
//	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 : bool or ndarray of bool
//
//	Boolean result of the logical XOR operation applied to the elements
//	of `x1` and `x2`; the shape is determined by broadcasting.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// See Also
// --------
// logical_and, logical_or, logical_not, bitwise_xor
//
// Examples
// --------
// >>> np.logical_xor(True, False)
// True
// >>> np.logical_xor([True, True, False, False], [True, False, True, False])
// array([False,  True,  True, False])
//
// >>> x = np.arange(5)
// >>> np.logical_xor(x < 1, x > 3)
// array([ True, False, False, False,  True])
//
// # Simple example showing support of broadcasting
//
// >>> np.logical_xor(0, np.eye(2))
// array([[ True, False],
//
//	[False,  True]])
//
//go:linkname LogicalXor py.logical_xor
func LogicalXor(args ...*py.Object) *py.Object

// maximum(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 that
// 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 propagated.
//
// 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
// --------
// minimum :
//
//	Element-wise minimum of two arrays, propagates NaNs.
//
// fmax :
//
//	Element-wise maximum of two arrays, ignores 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.
//
// fmin, amin, nanmin
//
// Notes
// -----
// The maximum 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.maximum([2, 3, 4], [1, 5, 2])
// array([2, 5, 4])
//
// >>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting
// array([[ 1. ,  2. ],
//
//	[ 0.5,  2. ]])
//
// >>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan])
// array([nan, nan, nan])
// >>> np.maximum(np.Inf, 1)
// inf
//
//go:linkname Maximum py.maximum
func Maximum(args ...*py.Object) *py.Object

// minimum(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 that
// 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 propagated.
//
// 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
// --------
// maximum :
//
//	Element-wise maximum of two arrays, propagates NaNs.
//
// fmin :
//
//	Element-wise minimum of two arrays, ignores 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.
//
// fmax, amax, nanmax
//
// Notes
// -----
// The minimum 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.minimum([2, 3, 4], [1, 5, 2])
// array([1, 3, 2])
//
// >>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting
// array([[ 0.5,  0. ],
//
//	[ 0. ,  1. ]])
//
// >>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan])
// array([nan, nan, nan])
// >>> np.minimum(-np.Inf, 1)
// -inf
//
//go:linkname Minimum py.minimum
func Minimum(args ...*py.Object) *py.Object

// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Returns the element-wise remainder of division.
//
// Computes the remainder complementary to the `floor_divide` function.  It is
// equivalent to the Python modulus operator“x1 % x2“ and has the same sign
// as the divisor `x2`. The MATLAB function equivalent to “np.remainder“
// is “mod“.
//
// .. warning::
//
//	This should not be confused with:
//
//	* Python 3.7's `math.remainder` and C's ``remainder``, which
//	  computes the IEEE remainder, which are the complement to
//	  ``round(x1 / x2)``.
//	* The MATLAB ``rem`` function and or the C ``%`` operator which is the
//	  complement to ``int(x1 / x2)``.
//
// 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
//
//	The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// See Also
// --------
// floor_divide : Equivalent of Python “//“ operator.
// divmod : Simultaneous floor division and remainder.
// fmod : Equivalent of the MATLAB “rem“ function.
// divide, floor
//
// Notes
// -----
// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
// integers.
// “mod“ is an alias of “remainder“.
//
// Examples
// --------
// >>> np.remainder([4, 7], [2, 3])
// array([0, 1])
// >>> np.remainder(np.arange(7), 5)
// array([0, 1, 2, 3, 4, 0, 1])
//
// The “%“ operator can be used as a shorthand for “np.remainder“ on
// ndarrays.
//
// >>> x1 = np.arange(7)
// >>> x1 % 5
// array([0, 1, 2, 3, 4, 0, 1])
//
//go:linkname Mod py.mod
func Mod(args ...*py.Object) *py.Object

// modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the fractional and integral parts of an array, element-wise.
//
// The fractional and integral parts are negative if the given number is
// negative.
//
// Parameters
// ----------
// x : array_like
//
//	Input array.
//
// out : ndarray, None, or tuple of ndarray and None, optional
//
//	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
// -------
// y1 : ndarray
//
//	Fractional part of `x`.
//	This is a scalar if `x` is a scalar.
//
// y2 : ndarray
//
//	Integral part of `x`.
//	This is a scalar if `x` is a scalar.
//
// Notes
// -----
// For integer input the return values are floats.
//
// See Also
// --------
// divmod : “divmod(x, 1)“ is equivalent to “modf“ with the return values
//
//	switched, except it always has a positive remainder.
//
// Examples
// --------
// >>> np.modf([0, 3.5])
// (array([ 0. ,  0.5]), array([ 0.,  3.]))
// >>> np.modf(-0.5)
// (-0.5, -0)
//
//go:linkname Modf py.modf
func Modf(args ...*py.Object) *py.Object

// multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Multiply arguments element-wise.
//
// Parameters
// ----------
// x1, x2 : array_like
//
//	Input arrays to be multiplied.
//	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 product 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.multiply(2.0, 4.0)
// 8.0
//
// >>> x1 = np.arange(9.0).reshape((3, 3))
// >>> x2 = np.arange(3.0)
// >>> np.multiply(x1, x2)
// array([[  0.,   1.,   4.],
//
//	[  0.,   4.,  10.],
//	[  0.,   7.,  16.]])
//
// The “*“ operator can be used as a shorthand for “np.multiply“ on
// ndarrays.
//
// >>> x1 = np.arange(9.0).reshape((3, 3))
// >>> x2 = np.arange(3.0)
// >>> x1 * x2
// array([[  0.,   1.,   4.],
//
//	[  0.,   4.,  10.],
//	[  0.,   7.,  16.]])
//
//go:linkname Multiply py.multiply
func Multiply(args ...*py.Object) *py.Object

// negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Numerical negative, element-wise.
//
// Parameters
// ----------
// x : array_like or scalar
//
//	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 scalar
//
//	Returned array or scalar: `y = -x`.
//	This is a scalar if `x` is a scalar.
//
// Examples
// --------
// >>> np.negative([1.,-1.])
// array([-1.,  1.])
//
// The unary “-“ operator can be used as a shorthand for “np.negative“ on
// ndarrays.
//
// >>> x1 = np.array(([1., -1.]))
// >>> -x1
// array([-1.,  1.])
//
//go:linkname Negative py.negative
func Negative(args ...*py.Object) *py.Object

// nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the next floating-point value after x1 towards x2, element-wise.
//
// Parameters
// ----------
// x1 : array_like
//
//	Values to find the next representable value of.
//
// x2 : array_like
//
//	The direction where to look for the next representable value of `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 next representable values of `x1` in the direction of `x2`.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// Examples
// --------
// >>> eps = np.finfo(np.float64).eps
// >>> np.nextafter(1, 2) == eps + 1
// True
// >>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]
// array([ True,  True])
//
//go:linkname Nextafter py.nextafter
func Nextafter(args ...*py.Object) *py.Object

// not_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
// --------
// equal, greater, greater_equal, less, less_equal
//
// Examples
// --------
// >>> np.not_equal([1.,2.], [1., 3.])
// array([False,  True])
// >>> np.not_equal([1, 2], [[1, 3],[1, 4]])
// array([[False,  True],
//
//	[False,  True]])
//
// The “!=“ operator can be used as a shorthand for “np.not_equal“ on
// ndarrays.
//
// >>> a = np.array([1., 2.])
// >>> b = np.array([1., 3.])
// >>> a != b
// array([False,  True])
//
//go:linkname NotEqual py.not_equal
func NotEqual(args ...*py.Object) *py.Object

// positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Numerical positive, element-wise.
//
// .. versionadded:: 1.13.0
//
// Parameters
// ----------
// x : array_like or scalar
//
//	Input array.
//
// Returns
// -------
// y : ndarray or scalar
//
//	Returned array or scalar: `y = +x`.
//	This is a scalar if `x` is a scalar.
//
// Notes
// -----
// Equivalent to `x.copy()`, but only defined for types that support
// arithmetic.
//
// Examples
// --------
//
// >>> x1 = np.array(([1., -1.]))
// >>> np.positive(x1)
// array([ 1., -1.])
//
// The unary “+“ operator can be used as a shorthand for “np.positive“ on
// ndarrays.
//
// >>> x1 = np.array(([1., -1.]))
// >>> +x1
// array([ 1., -1.])
//
//go:linkname Positive py.positive
func Positive(args ...*py.Object) *py.Object

// 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.
//
// An integer type raised to a negative integer power will raise a
// “ValueError“.
//
// 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).
//
// 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
// --------
// float_power : power function that promotes integers to float
//
// Examples
// --------
// Cube each element in an array.
//
// >>> x1 = np.arange(6)
// >>> x1
// [0, 1, 2, 3, 4, 5]
// >>> np.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.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.power(x1, x2)
// array([[ 0,  1,  8, 27, 16,  5],
//
//	[ 0,  1,  8, 27, 16,  5]])
//
// The “**“ operator can be used as a shorthand for “np.power“ on
// ndarrays.
//
// >>> x2 = np.array([1, 2, 3, 3, 2, 1])
// >>> x1 = np.arange(6)
// >>> x1 ** x2
// array([ 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.0, -4.0])
// >>> with np.errstate(invalid='ignore'):
// ...     p = np.power(x3, 1.5)
// ...
// >>> p
// array([nan, nan])
//
// To get complex results, give the argument “dtype=complex“.
//
// >>> np.power(x3, 1.5, dtype=complex)
// array([-1.83697020e-16-1.j, -1.46957616e-15-8.j])
//
//go:linkname Power py.power
func Power(args ...*py.Object) *py.Object

// rad2deg(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
//
//	Angle 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 angle in degrees.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// deg2rad : Convert angles from degrees to radians.
// unwrap : Remove large jumps in angle by wrapping.
//
// Notes
// -----
// .. versionadded:: 1.3.0
//
// rad2deg(x) is “180 * x / pi“.
//
// Examples
// --------
// >>> np.rad2deg(np.pi/2)
// 90.0
//
//go:linkname Rad2deg py.rad2deg
func Rad2deg(args ...*py.Object) *py.Object

// radians(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
//
//	Input array 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 radian values.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// deg2rad : equivalent function
//
// Examples
// --------
// Convert a degree array to radians
//
// >>> deg = np.arange(12.) * 30.
// >>> np.radians(deg)
// array([ 0.        ,  0.52359878,  1.04719755,  1.57079633,  2.0943951 ,
//
//	2.61799388,  3.14159265,  3.66519143,  4.1887902 ,  4.71238898,
//	5.23598776,  5.75958653])
//
// >>> out = np.zeros((deg.shape))
// >>> ret = np.radians(deg, out)
// >>> ret is out
// True
//
//go:linkname Radians py.radians
func Radians(args ...*py.Object) *py.Object

// reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the reciprocal of the argument, element-wise.
//
// Calculates “1/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
// -------
// y : ndarray
//
//	Return array.
//	This is a scalar if `x` is a scalar.
//
// Notes
// -----
// .. note::
//
//	This function is not designed to work with integers.
//
// For integer arguments with absolute value larger than 1 the result is
// always zero because of the way Python handles integer division.  For
// integer zero the result is an overflow.
//
// Examples
// --------
// >>> np.reciprocal(2.)
// 0.5
// >>> np.reciprocal([1, 2., 3.33])
// array([ 1.       ,  0.5      ,  0.3003003])
//
//go:linkname Reciprocal py.reciprocal
func Reciprocal(args ...*py.Object) *py.Object

// remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Returns the element-wise remainder of division.
//
// Computes the remainder complementary to the `floor_divide` function.  It is
// equivalent to the Python modulus operator“x1 % x2“ and has the same sign
// as the divisor `x2`. The MATLAB function equivalent to “np.remainder“
// is “mod“.
//
// .. warning::
//
//	This should not be confused with:
//
//	* Python 3.7's `math.remainder` and C's ``remainder``, which
//	  computes the IEEE remainder, which are the complement to
//	  ``round(x1 / x2)``.
//	* The MATLAB ``rem`` function and or the C ``%`` operator which is the
//	  complement to ``int(x1 / x2)``.
//
// 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
//
//	The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// See Also
// --------
// floor_divide : Equivalent of Python “//“ operator.
// divmod : Simultaneous floor division and remainder.
// fmod : Equivalent of the MATLAB “rem“ function.
// divide, floor
//
// Notes
// -----
// Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
// integers.
// “mod“ is an alias of “remainder“.
//
// Examples
// --------
// >>> np.remainder([4, 7], [2, 3])
// array([0, 1])
// >>> np.remainder(np.arange(7), 5)
// array([0, 1, 2, 3, 4, 0, 1])
//
// The “%“ operator can be used as a shorthand for “np.remainder“ on
// ndarrays.
//
// >>> x1 = np.arange(7)
// >>> x1 % 5
// array([0, 1, 2, 3, 4, 0, 1])
//
//go:linkname Remainder py.remainder
func Remainder(args ...*py.Object) *py.Object

// right_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 right.
//
// Bits are shifted to the right `x2`.  Because the internal
// representation of numbers is in binary format, this operation is
// equivalent to dividing `x1` by “2**x2“.
//
// Parameters
// ----------
// x1 : array_like, int
//
//	Input values.
//
// x2 : array_like, int
//
//	Number of bits to remove at the right of `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, int
//
//	Return `x1` with bits shifted `x2` times to the right.
//	This is a scalar if both `x1` and `x2` are scalars.
//
// See Also
// --------
// left_shift : Shift the bits of an integer to the left.
// binary_repr : Return the binary representation of the input number
//
//	as a string.
//
// Examples
// --------
// >>> np.binary_repr(10)
// '1010'
// >>> np.right_shift(10, 1)
// 5
// >>> np.binary_repr(5)
// '101'
//
// >>> np.right_shift(10, [1,2,3])
// array([5, 2, 1])
//
// The “>>“ operator can be used as a shorthand for “np.right_shift“ on
// ndarrays.
//
// >>> x1 = 10
// >>> x2 = np.array([1,2,3])
// >>> x1 >> x2
// array([5, 2, 1])
//
//go:linkname RightShift py.right_shift
func RightShift(args ...*py.Object) *py.Object

// rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Round elements of the array to the nearest integer.
//
// 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 is same shape and type as `x`.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// fix, ceil, floor, trunc
//
// Notes
// -----
// For values exactly halfway between rounded decimal values, NumPy
// rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
// -0.5 and 0.5 round to 0.0, etc.
//
// Examples
// --------
// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
// >>> np.rint(a)
// array([-2., -2., -0.,  0.,  2.,  2.,  2.])
//
//go:linkname Rint py.rint
func Rint(args ...*py.Object) *py.Object

// signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Returns element-wise True where signbit is set (less than zero).
//
// Parameters
// ----------
// x : array_like
//
//	The input value(s).
//
// 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
// -------
// result : ndarray of bool
//
//	Output array, or reference to `out` if that was supplied.
//	This is a scalar if `x` is a scalar.
//
// Examples
// --------
// >>> np.signbit(-1.2)
// True
// >>> np.signbit(np.array([1, -2.3, 2.1]))
// array([False,  True, False])
//
//go:linkname Signbit py.signbit
func Signbit(args ...*py.Object) *py.Object

// sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Trigonometric sine, element-wise.
//
// Parameters
// ----------
// x : array_like
//
//	Angle, in radians (:math:`2 \pi` rad equals 360 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 : array_like
//
//	The sine of each element of x.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// arcsin, sinh, cos
//
// Notes
// -----
// The sine is one of the fundamental functions of trigonometry (the
// mathematical study of triangles).  Consider a circle of radius 1
// centered on the origin.  A ray comes in from the :math:`+x` axis, makes
// an angle at the origin (measured counter-clockwise from that axis), and
// departs from the origin.  The :math:`y` coordinate of the outgoing
// ray's intersection with the unit circle is the sine of that angle.  It
// ranges from -1 for :math:`x=3\pi / 2` to +1 for :math:`\pi / 2.`  The
// function has zeroes where the angle is a multiple of :math:`\pi`.
// Sines of angles between :math:`\pi` and :math:`2\pi` are negative.
// The numerous properties of the sine and related functions are included
// in any standard trigonometry text.
//
// Examples
// --------
// Print sine of one angle:
//
// >>> np.sin(np.pi/2.)
// 1.0
//
// Print sines of an array of angles given in degrees:
//
// >>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )
// array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])
//
// Plot the sine function:
//
// >>> import matplotlib.pylab as plt
// >>> x = np.linspace(-np.pi, np.pi, 201)
// >>> plt.plot(x, np.sin(x))
// >>> plt.xlabel('Angle [rad]')
// >>> plt.ylabel('sin(x)')
// >>> plt.axis('tight')
// >>> plt.show()
//
//go:linkname Sin py.sin
func Sin(args ...*py.Object) *py.Object

// sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Hyperbolic sine, element-wise.
//
// Equivalent to “1/2 * (np.exp(x) - np.exp(-x))“ or
// “-1j * np.sin(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
// -------
// y : ndarray
//
//	The corresponding hyperbolic sine 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, pg. 83.
//
// Examples
// --------
// >>> np.sinh(0)
// 0.0
// >>> np.sinh(np.pi*1j/2)
// 1j
// >>> np.sinh(np.pi*1j) # (exact value is 0)
// 1.2246063538223773e-016j
// >>> # Discrepancy due to vagaries of floating point arithmetic.
//
// >>> # Example of providing the optional output parameter
// >>> out1 = np.array([0], dtype='d')
// >>> out2 = np.sinh([0.1], out1)
// >>> out2 is out1
// True
//
// >>> # Example of ValueError due to provision of shape mis-matched `out`
// >>> np.sinh(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)
//
//go:linkname Sinh py.sinh
func Sinh(args ...*py.Object) *py.Object

// spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the distance between x and the nearest adjacent number.
//
// Parameters
// ----------
// x : array_like
//
//	Values to find the spacing of.
//
// 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 spacing of values of `x`.
//	This is a scalar if `x` is a scalar.
//
// Notes
// -----
// It can be considered as a generalization of EPS:
// “spacing(np.float64(1)) == np.finfo(np.float64).eps“, and there
// should not be any representable number between “x + spacing(x)“ and
// x for any finite x.
//
// Spacing of +- inf and NaN is NaN.
//
// Examples
// --------
// >>> np.spacing(1) == np.finfo(np.float64).eps
// True
//
//go:linkname Spacing py.spacing
func Spacing(args ...*py.Object) *py.Object

// sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the non-negative square-root of an array, element-wise.
//
// Parameters
// ----------
// x : array_like
//
//	The values whose square-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 positive
//	square-root of each element in `x`.  If any element in `x` is
//	complex, a complex array is returned (and the square-roots of
//	negative reals are calculated).  If all of the elements in `x`
//	are real, so is `y`, with negative elements returning ``nan``.
//	If `out` was provided, `y` is a reference to it.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// emath.sqrt
//
//	A version which returns complex numbers when given negative reals.
//	Note that 0.0 and -0.0 are handled differently for complex inputs.
//
// Notes
// -----
// *sqrt* has--consistent with common convention--as its branch cut the
// real "interval" [`-inf`, 0), and is continuous from above on it.
// A branch cut is a curve in the complex plane across which a given
// complex function fails to be continuous.
//
// Examples
// --------
// >>> np.sqrt([1,4,9])
// array([ 1.,  2.,  3.])
//
// >>> np.sqrt([4, -1, -3+4J])
// array([ 2.+0.j,  0.+1.j,  1.+2.j])
//
// >>> np.sqrt([4, -1, np.inf])
// array([ 2., nan, inf])
//
//go:linkname Sqrt py.sqrt
func Sqrt(args ...*py.Object) *py.Object

// square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the element-wise square of the input.
//
// 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
// -------
// out : ndarray or scalar
//
//	Element-wise `x*x`, of the same shape and dtype as `x`.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// numpy.linalg.matrix_power
// sqrt
// power
//
// Examples
// --------
// >>> np.square([-1j, 1])
// array([-1.-0.j,  1.+0.j])
//
//go:linkname Square py.square
func Square(args ...*py.Object) *py.Object

// subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Subtract arguments, element-wise.
//
// Parameters
// ----------
// x1, x2 : array_like
//
//	The arrays to be subtracted from each other.
//	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 difference 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.subtract(1.0, 4.0)
// -3.0
//
// >>> x1 = np.arange(9.0).reshape((3, 3))
// >>> x2 = np.arange(3.0)
// >>> np.subtract(x1, x2)
// array([[ 0.,  0.,  0.],
//
//	[ 3.,  3.,  3.],
//	[ 6.,  6.,  6.]])
//
// The “-“ operator can be used as a shorthand for “np.subtract“ on
// ndarrays.
//
// >>> x1 = np.arange(9.0).reshape((3, 3))
// >>> x2 = np.arange(3.0)
// >>> x1 - x2
// array([[0., 0., 0.],
//
//	[3., 3., 3.],
//	[6., 6., 6.]])
//
//go:linkname Subtract py.subtract
func Subtract(args ...*py.Object) *py.Object

// tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Compute tangent element-wise.
//
// Equivalent to “np.sin(x)/np.cos(x)“ 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
// -------
// y : ndarray
//
//	The corresponding tangent 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
// --------
// >>> from math import pi
// >>> np.tan(np.array([-pi,pi/2,pi]))
// array([  1.22460635e-16,   1.63317787e+16,  -1.22460635e-16])
// >>>
// >>> # Example of providing the optional output parameter illustrating
// >>> # that what is returned is a reference to said 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)
//
//go:linkname Tan py.tan
func Tan(args ...*py.Object) *py.Object

// tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Compute hyperbolic tangent element-wise.
//
// Equivalent to “np.sinh(x)/np.cosh(x)“ or “-1j * np.tan(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
// -------
// y : ndarray
//
//	The corresponding hyperbolic tangent 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
// ----------
// .. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
//
//	New York, NY: Dover, 1972, pg. 83.
//	https://personal.math.ubc.ca/~cbm/aands/page_83.htm
//
// .. [2] Wikipedia, "Hyperbolic function",
//
//	https://en.wikipedia.org/wiki/Hyperbolic_function
//
// Examples
// --------
// >>> np.tanh((0, np.pi*1j, np.pi*1j/2))
// array([ 0. +0.00000000e+00j,  0. -1.22460635e-16j,  0. +1.63317787e+16j])
//
// >>> # Example of providing the optional output parameter illustrating
// >>> # that what is returned is a reference to said parameter
// >>> out1 = np.array([0], dtype='d')
// >>> out2 = np.tanh([0.1], out1)
// >>> out2 is out1
// True
//
// >>> # Example of ValueError due to provision of shape mis-matched `out`
// >>> np.tanh(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)
//
//go:linkname Tanh py.tanh
func Tanh(args ...*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. ]])
//
//go:linkname TrueDivide py.true_divide
func TrueDivide(args ...*py.Object) *py.Object

// trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
//
// Return the truncated value of the input, element-wise.
//
// The truncated value of the scalar `x` is the nearest integer `i` which
// is closer to zero than `x` is. In short, the fractional part of the
// signed number `x` is discarded.
//
// 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 truncated value of each element in `x`.
//	This is a scalar if `x` is a scalar.
//
// See Also
// --------
// ceil, floor, rint, fix
//
// Notes
// -----
// .. versionadded:: 1.3.0
//
// Examples
// --------
// >>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
// >>> np.trunc(a)
// array([-1., -1., -0.,  0.,  1.,  1.,  2.])
//
//go:linkname Trunc py.trunc
func Trunc(args ...*py.Object) *py.Object

// Return the scalar dtype or NumPy equivalent of Python type of an object.
//
// Parameters
// ----------
// rep : any
//
//	The object of which the type is returned.
//
// default : any, optional
//
//	If given, this is returned for objects whose types can not be
//	determined. If not given, None is returned for those objects.
//
// Returns
// -------
// dtype : dtype or Python type
//
//	The data type of `rep`.
//
// See Also
// --------
// sctype2char, issctype, issubsctype, issubdtype, maximum_sctype
//
// Examples
// --------
// >>> np.obj2sctype(np.int32)
// <class 'numpy.int32'>
// >>> np.obj2sctype(np.array([1., 2.]))
// <class 'numpy.float64'>
// >>> np.obj2sctype(np.array([1.j]))
// <class 'numpy.complex128'>
//
// >>> np.obj2sctype(dict)
// <class 'numpy.object_'>
// >>> np.obj2sctype('string')
//
// >>> np.obj2sctype(1, default=list)
// <class 'list'>
//
//go:linkname Obj2sctype py.obj2sctype
func Obj2sctype(rep *py.Object, default_ *py.Object) *py.Object

// Return the string representation of a scalar dtype.
//
// Parameters
// ----------
// sctype : scalar dtype or object
//
//	If a scalar dtype, the corresponding string character is
//	returned. If an object, `sctype2char` tries to infer its scalar type
//	and then return the corresponding string character.
//
// Returns
// -------
// typechar : str
//
//	The string character corresponding to the scalar type.
//
// Raises
// ------
// ValueError
//
//	If `sctype` is an object for which the type can not be inferred.
//
// See Also
// --------
// obj2sctype, issctype, issubsctype, mintypecode
//
// Examples
// --------
// >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]:
// ...     print(np.sctype2char(sctype))
// l # may vary
// d
// D
// S
// O
//
// >>> x = np.array([1., 2-1.j])
// >>> np.sctype2char(x)
// 'D'
// >>> np.sctype2char(list)
// 'O'
//
//go:linkname Sctype2char py.sctype2char
func Sctype2char(sctype *py.Object) *py.Object

// Return the scalar type of highest precision of the same kind as the input.
//
// Parameters
// ----------
// t : dtype or dtype specifier
//
//	The input data type. This can be a `dtype` object or an object that
//	is convertible to a `dtype`.
//
// Returns
// -------
// out : dtype
//
//	The highest precision data type of the same kind (`dtype.kind`) as `t`.
//
// See Also
// --------
// obj2sctype, mintypecode, sctype2char
// dtype
//
// Examples
// --------
// >>> np.maximum_sctype(int)
// <class 'numpy.int64'>
// >>> np.maximum_sctype(np.uint8)
// <class 'numpy.uint64'>
// >>> np.maximum_sctype(complex)
// <class 'numpy.complex256'> # may vary
//
// >>> np.maximum_sctype(str)
// <class 'numpy.str_'>
//
// >>> np.maximum_sctype('i2')
// <class 'numpy.int64'>
// >>> np.maximum_sctype('f4')
// <class 'numpy.float128'> # may vary
//
//go:linkname MaximumSctype py.maximum_sctype
func MaximumSctype(t *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
//
//go:linkname Issctype py.issctype
func Issctype(rep *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')
//
//go:linkname FindCommonType py.find_common_type
func FindCommonType(arrayTypes *py.Object, scalarTypes *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
//
//go:linkname Issubdtype py.issubdtype
func Issubdtype(arg1 *py.Object, arg2 *py.Object) *py.Object

// Set a Python function to be used when pretty printing arrays.
//
// Parameters
// ----------
// f : function or None
//
//	Function to be used to pretty print arrays. The function should expect
//	a single array argument and return a string of the representation of
//	the array. If None, the function is reset to the default NumPy function
//	to print arrays.
//
// repr : bool, optional
//
//	If True (default), the function for pretty printing (``__repr__``)
//	is set, if False the function that returns the default string
//	representation (``__str__``) is set.
//
// See Also
// --------
// set_printoptions, get_printoptions
//
// Examples
// --------
// >>> def pprint(arr):
// ...     return 'HA! - What are you going to do now?'
// ...
// >>> np.set_string_function(pprint)
// >>> a = np.arange(10)
// >>> a
// HA! - What are you going to do now?
// >>> _ = a
// >>> # [0 1 2 3 4 5 6 7 8 9]
//
// We can reset the function to the default:
//
// >>> np.set_string_function(None)
// >>> a
// array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
//
// `repr` affects either pretty printing or normal string representation.
// Note that “__repr__“ is still affected by setting “__str__“
// because the width of each array element in the returned string becomes
// equal to the length of the result of “__str__()“.
//
// >>> x = np.arange(4)
// >>> np.set_string_function(lambda x:'random', repr=False)
// >>> x.__str__()
// 'random'
// >>> x.__repr__()
// 'array([0, 1, 2, 3])'
//
//go:linkname SetStringFunction py.set_string_function
func SetStringFunction(f *py.Object, repr *py.Object) *py.Object

// Set printing options.
//
// These options determine the way floating point numbers, arrays and
// other NumPy objects are displayed.
//
// Parameters
// ----------
// precision : int or None, optional
//
//	Number of digits of precision for floating point output (default 8).
//	May be None if `floatmode` is not `fixed`, to print as many digits as
//	necessary to uniquely specify the value.
//
// threshold : int, optional
//
//	Total number of array elements which trigger summarization
//	rather than full repr (default 1000).
//	To always use the full repr without summarization, pass `sys.maxsize`.
//
// edgeitems : int, optional
//
//	Number of array items in summary at beginning and end of
//	each dimension (default 3).
//
// linewidth : int, optional
//
//	The number of characters per line for the purpose of inserting
//	line breaks (default 75).
//
// suppress : bool, optional
//
//	If True, always print floating point numbers using fixed point
//	notation, in which case numbers equal to zero in the current precision
//	will print as zero.  If False, then scientific notation is used when
//	absolute value of the smallest number is < 1e-4 or the ratio of the
//	maximum absolute value to the minimum is > 1e3. The default is False.
//
// nanstr : str, optional
//
//	String representation of floating point not-a-number (default nan).
//
// infstr : str, optional
//
//	String representation of floating point infinity (default inf).
//
// 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. (default '-')
//
// 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
//	- 'numpystr' : types `numpy.bytes_` and `numpy.str_`
//	- 'object' : `np.object_` arrays
//
//	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'
//
// floatmode : str, optional
//
//	Controls the interpretation of the `precision` option for
//	floating-point types. Can take the following values
//	(default maxprec_equal):
//
//	* '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. This also
//	enables 1.21 legacy printing mode (described below).
//
//	If set to the string `'1.21'` enables 1.21 legacy printing mode. This
//	approximates numpy 1.21 print output of complex structured dtypes
//	by not inserting spaces after commas that separate fields and after
//	colons.
//
//	If set to `False`, disables legacy mode.
//
//	Unrecognized strings will be ignored with a warning for forward
//	compatibility.
//
//	.. versionadded:: 1.14.0
//	.. versionchanged:: 1.22.0
//
// See Also
// --------
// get_printoptions, printoptions, set_string_function, array2string
//
// Notes
// -----
// `formatter` is always reset with a call to `set_printoptions`.
//
// Use `printoptions` as a context manager to set the values temporarily.
//
// Examples
// --------
// Floating point precision can be set:
//
// >>> np.set_printoptions(precision=4)
// >>> np.array([1.123456789])
// [1.1235]
//
// Long arrays can be summarised:
//
// >>> np.set_printoptions(threshold=5)
// >>> np.arange(10)
// array([0, 1, 2, ..., 7, 8, 9])
//
// Small results can be suppressed:
//
// >>> eps = np.finfo(float).eps
// >>> x = np.arange(4.)
// >>> x**2 - (x + eps)**2
// array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
// >>> np.set_printoptions(suppress=True)
// >>> x**2 - (x + eps)**2
// array([-0., -0.,  0.,  0.])
//
// A custom formatter can be used to display array elements as desired:
//
// >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
// >>> x = np.arange(3)
// >>> x
// array([int: 0, int: -1, int: -2])
// >>> np.set_printoptions()  # formatter gets reset
// >>> x
// array([0, 1, 2])
//
// To put back the default options, you can use:
//
// >>> np.set_printoptions(edgeitems=3, infstr='inf',
// ... linewidth=75, nanstr='nan', precision=8,
// ... suppress=False, threshold=1000, formatter=None)
//
// Also to temporarily override options, use `printoptions` as a context manager:
//
// >>> with np.printoptions(precision=2, suppress=True, threshold=5):
// ...     np.linspace(0, 10, 10)
// array([ 0.  ,  1.11,  2.22, ...,  7.78,  8.89, 10.  ])
//
//go:linkname SetPrintoptions py.set_printoptions
func SetPrintoptions(precision *py.Object, threshold *py.Object, edgeitems *py.Object, linewidth *py.Object, suppress *py.Object, nanstr *py.Object, infstr *py.Object, formatter *py.Object, sign *py.Object, floatmode *py.Object) *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
//
//go:linkname GetPrintoptions py.get_printoptions
func GetPrintoptions() *py.Object

// Context manager for setting print options.
//
//	Set print options for the scope of the `with` block, and restore the old
//	options at the end. See `set_printoptions` for the full description of
//	available options.
//
//	Examples
//	--------
//
//	>>> from numpy.testing import assert_equal
//	>>> with np.printoptions(precision=2):
//	...     np.array([2.0]) / 3
//	array([0.67])
//
//	The `as`-clause of the `with`-statement gives the current print options:
//
//	>>> with np.printoptions(precision=2) as opts:
//	...      assert_equal(opts, np.get_printoptions())
//
//	See Also
//	--------
//	set_printoptions, get_printoptions
//
//go:linkname Printoptions py.printoptions
func Printoptions(args ...*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'
//
//go:linkname FormatFloatPositional py.format_float_positional
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 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'
//
//go:linkname FormatFloatScientific py.format_float_scientific
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

// Return an ndarray of the provided type that satisfies requirements.
//
// This function is useful to be sure that an array with the correct flags
// is returned for passing to compiled code (perhaps through ctypes).
//
// Parameters
// ----------
// a : array_like
//
//	The object to be converted to a type-and-requirement-satisfying array.
//
// dtype : data-type
//
//	The required data-type. If None preserve the current dtype. If your
//	application requires the data to be in native byteorder, include
//	a byteorder specification as a part of the dtype specification.
//
// requirements : str or sequence of str
//
//	The requirements list can be any of the following
//
//	* 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
//	* 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
//	* 'ALIGNED' ('A')      - ensure a data-type aligned array
//	* 'WRITEABLE' ('W')    - ensure a writable array
//	* 'OWNDATA' ('O')      - ensure an array that owns its own data
//	* 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass
//
// 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 with specified requirements and type if given.
//
// See Also
// --------
// asarray : Convert input to an ndarray.
// asanyarray : Convert to an ndarray, but pass through ndarray subclasses.
// ascontiguousarray : Convert input to a contiguous array.
// asfortranarray : Convert input to an ndarray with column-major
//
//	memory order.
//
// ndarray.flags : Information about the memory layout of the array.
//
// Notes
// -----
// The returned array will be guaranteed to have the listed requirements
// by making a copy if needed.
//
// Examples
// --------
// >>> x = np.arange(6).reshape(2,3)
// >>> x.flags
//
//	C_CONTIGUOUS : True
//	F_CONTIGUOUS : False
//	OWNDATA : False
//	WRITEABLE : True
//	ALIGNED : True
//	WRITEBACKIFCOPY : False
//
// >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
// >>> y.flags
//
//	C_CONTIGUOUS : False
//	F_CONTIGUOUS : True
//	OWNDATA : True
//	WRITEABLE : True
//	ALIGNED : True
//	WRITEBACKIFCOPY : False
//
//go:linkname Require py.require
func Require(a *py.Object, dtype *py.Object, requirements *py.Object) *py.Object

// Set how floating-point errors are handled.
//
// Note that operations on integer scalar types (such as `int16`) are
// handled like floating point, and are affected by these settings.
//
// Parameters
// ----------
// all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
//
//	Set treatment for all types of floating-point errors at once:
//
//	- ignore: Take no action when the exception occurs.
//	- warn: Print a `RuntimeWarning` (via the Python `warnings` module).
//	- raise: Raise a `FloatingPointError`.
//	- call: Call a function specified using the `seterrcall` function.
//	- print: Print a warning directly to ``stdout``.
//	- log: Record error in a Log object specified by `seterrcall`.
//
//	The default is not to change the current behavior.
//
// divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
//
//	Treatment for division by zero.
//
// over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
//
//	Treatment for floating-point overflow.
//
// under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
//
//	Treatment for floating-point underflow.
//
// invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
//
//	Treatment for invalid floating-point operation.
//
// Returns
// -------
// old_settings : dict
//
//	Dictionary containing the old settings.
//
// See also
// --------
// seterrcall : Set a callback function for the 'call' mode.
// geterr, geterrcall, errstate
//
// Notes
// -----
// The floating-point exceptions are defined in the IEEE 754 standard [1]_:
//
//   - Division by zero: infinite result obtained from finite numbers.
//   - Overflow: result too large to be expressed.
//   - Underflow: result so close to zero that some precision
//     was lost.
//   - Invalid operation: result is not an expressible number, typically
//     indicates that a NaN was produced.
//
// .. [1] https://en.wikipedia.org/wiki/IEEE_754
//
// Examples
// --------
// >>> old_settings = np.seterr(all='ignore')  #seterr to known value
// >>> np.seterr(over='raise')
// {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
// >>> np.seterr(**old_settings)  # reset to default
// {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'}
//
// >>> np.int16(32000) * np.int16(3)
// 30464
// >>> old_settings = np.seterr(all='warn', over='raise')
// >>> np.int16(32000) * np.int16(3)
// Traceback (most recent call last):
//
//	File "<stdin>", line 1, in <module>
//
// FloatingPointError: overflow encountered in scalar multiply
//
// >>> old_settings = np.seterr(all='print')
// >>> np.geterr()
// {'divide': 'print', 'over': 'print', 'under': 'print', 'invalid': 'print'}
// >>> np.int16(32000) * np.int16(3)
// 30464
//
//go:linkname Seterr py.seterr
func Seterr(all *py.Object, divide *py.Object, over *py.Object, under *py.Object, invalid *py.Object) *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.])
//
//go:linkname Geterr py.geterr
func Geterr() *py.Object

// Set the size of the buffer used in ufuncs.
//
// Parameters
// ----------
// size : int
//
//	Size of buffer.
//
//go:linkname Setbufsize py.setbufsize
func Setbufsize(size *py.Object) *py.Object

// Return the size of the buffer used in ufuncs.
//
// Returns
// -------
// getbufsize : int
//
//	Size of ufunc buffer in bytes.
//
//go:linkname Getbufsize py.getbufsize
func Getbufsize() *py.Object

// Set the floating-point error callback function or log object.
//
// There are two ways to capture floating-point error messages.  The first
// is to set the error-handler to 'call', using `seterr`.  Then, set
// the function to call using this function.
//
// The second is to set the error-handler to 'log', using `seterr`.
// Floating-point errors then trigger a call to the 'write' method of
// the provided object.
//
// Parameters
// ----------
// func : callable f(err, flag) or object with write method
//
//	Function to call upon floating-point errors ('call'-mode) or
//	object whose 'write' method is used to log such message ('log'-mode).
//
//	The call function takes two arguments. The first is a string describing
//	the type of error (such as "divide by zero", "overflow", "underflow",
//	or "invalid value"), and the second is the status flag.  The flag is a
//	byte, whose four least-significant bits indicate the type of error, one
//	of "divide", "over", "under", "invalid"::
//
//	  [0 0 0 0 divide over under invalid]
//
//	In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
//
//	If an object is provided, its write method should take one argument,
//	a string.
//
// Returns
// -------
// h : callable, log instance or None
//
//	The old error handler.
//
// See Also
// --------
// seterr, geterr, geterrcall
//
// Examples
// --------
// Callback upon error:
//
// >>> def err_handler(type, flag):
// ...     print("Floating point error (%s), with flag %s" % (type, flag))
// ...
//
// >>> saved_handler = np.seterrcall(err_handler)
// >>> save_err = np.seterr(all='call')
//
// >>> np.array([1, 2, 3]) / 0.0
// Floating point error (divide by zero), with flag 1
// array([inf, inf, inf])
//
// >>> np.seterrcall(saved_handler)
// <function err_handler at 0x...>
// >>> np.seterr(**save_err)
// {'divide': 'call', 'over': 'call', 'under': 'call', 'invalid': 'call'}
//
// Log error message:
//
// >>> class Log:
// ...     def write(self, msg):
// ...         print("LOG: %s" % msg)
// ...
//
// >>> log = Log()
// >>> saved_handler = np.seterrcall(log)
// >>> save_err = np.seterr(all='log')
//
// >>> np.array([1, 2, 3]) / 0.0
// LOG: Warning: divide by zero encountered in divide
// array([inf, inf, inf])
//
// >>> np.seterrcall(saved_handler)
// <numpy.core.numeric.Log object at 0x...>
// >>> np.seterr(**save_err)
// {'divide': 'log', 'over': 'log', 'under': 'log', 'invalid': 'log'}
//
//go:linkname Seterrcall py.seterrcall
func Seterrcall(func_ *py.Object) *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
//
//go:linkname Geterrcall py.geterrcall
func Geterrcall() *py.Object

// Return a description for the given data type code.
//
// Parameters
// ----------
// char : str
//
//	Data type code.
//
// Returns
// -------
// out : str
//
//	Description of the input data type code.
//
// See Also
// --------
// dtype, typecodes
//
// Examples
// --------
// >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
// ...              'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
// >>> for typechar in typechars:
// ...     print(typechar, ' : ', np.typename(typechar))
// ...
// S1  :  character
// ?  :  bool
// B  :  unsigned char
// D  :  complex double precision
// G  :  complex long double precision
// F  :  complex single precision
// I  :  unsigned integer
// H  :  unsigned short
// L  :  unsigned long integer
// O  :  object
// Q  :  unsigned long long integer
// S  :  string
// U  :  unicode
// V  :  void
// b  :  signed char
// d  :  double precision
// g  :  long precision
// f  :  single precision
// i  :  integer
// h  :  short
// l  :  long integer
// q  :  long long integer
//
//go:linkname Typename py.typename
func Typename(char *py.Object) *py.Object

// Return the character for the minimum-size type to which given types can
// be safely cast.
//
// The returned type character must represent the smallest size dtype such
// that an array of the returned type can handle the data from an array of
// all types in `typechars` (or if `typechars` is an array, then its
// dtype.char).
//
// Parameters
// ----------
// typechars : list of str or array_like
//
//	If a list of strings, each string should represent a dtype.
//	If array_like, the character representation of the array dtype is used.
//
// typeset : str or list of str, optional
//
//	The set of characters that the returned character is chosen from.
//	The default set is 'GDFgdf'.
//
// default : str, optional
//
//	The default character, this is returned if none of the characters in
//	`typechars` matches a character in `typeset`.
//
// Returns
// -------
// typechar : str
//
//	The character representing the minimum-size type that was found.
//
// See Also
// --------
// dtype, sctype2char, maximum_sctype
//
// Examples
// --------
// >>> np.mintypecode(['d', 'f', 'S'])
// 'd'
// >>> x = np.array([1.1, 2-3.j])
// >>> np.mintypecode(x)
// 'D'
//
// >>> np.mintypecode('abceh', default='G')
// 'G'
//
//go:linkname Mintypecode py.mintypecode
func Mintypecode(typechars *py.Object, typeset *py.Object, default_ *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]]])
//
//go:linkname DiagIndices py.diag_indices
func DiagIndices(n *py.Object, ndim *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
//
//go:linkname Iterable py.iterable
func Iterable(y *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'
//
//go:linkname Disp py.disp
func Disp(mesg *py.Object, device *py.Object, linefeed *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
//
//go:linkname AsarrayChkfinite py.asarray_chkfinite
func AsarrayChkfinite(a *py.Object, dtype *py.Object, order *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()
//
//go:linkname Hamming py.hamming
func Hamming(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()
//
//go:linkname Hanning py.hanning
func Hanning(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()
//
//go:linkname Bartlett py.bartlett
func Bartlett(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()
//
//go:linkname Blackman py.blackman
func Blackman(M *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()
//
//go:linkname Kaiser py.kaiser
func Kaiser(M *py.Object, beta *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.
//
//go:linkname AddNewdoc py.add_newdoc
func AddNewdoc(place *py.Object, obj *py.Object, doc *py.Object, warnOnPython *py.Object) *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
//
//go:linkname GetArrayWrap py.get_array_wrap
func GetArrayWrap(args ...*py.Object) *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)
//
//go:linkname BroadcastShapes py.broadcast_shapes
func BroadcastShapes(args ...*py.Object) *py.Object

// Return the indices to access (n, n) arrays, given a masking function.
//
// Assume `mask_func` is a function that, for a square array a of size
// “(n, n)“ with a possible offset argument `k`, when called as
// “mask_func(a, k)“ returns a new array with zeros in certain locations
// (functions like `triu` or `tril` do precisely this). Then this function
// returns the indices where the non-zero values would be located.
//
// Parameters
// ----------
// n : int
//
//	The returned indices will be valid to access arrays of shape (n, n).
//
// mask_func : callable
//
//	A function whose call signature is similar to that of `triu`, `tril`.
//	That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`.
//	`k` is an optional argument to the function.
//
// k : scalar
//
//	An optional argument which is passed through to `mask_func`. Functions
//	like `triu`, `tril` take a second argument that is interpreted as an
//	offset.
//
// Returns
// -------
// indices : tuple of arrays.
//
//	The `n` arrays of indices corresponding to the locations where
//	``mask_func(np.ones((n, n)), k)`` is True.
//
// See Also
// --------
// triu, tril, triu_indices, tril_indices
//
// Notes
// -----
// .. versionadded:: 1.4.0
//
// Examples
// --------
// These are the indices that would allow you to access the upper triangular
// part of any 3x3 array:
//
// >>> iu = np.mask_indices(3, np.triu)
//
// For example, if `a` is a 3x3 array:
//
// >>> a = np.arange(9).reshape(3, 3)
// >>> a
// array([[0, 1, 2],
//
//	[3, 4, 5],
//	[6, 7, 8]])
//
// >>> a[iu]
// array([0, 1, 2, 4, 5, 8])
//
// An offset can be passed also to the masking function.  This gets us the
// indices starting on the first diagonal right of the main one:
//
// >>> iu1 = np.mask_indices(3, np.triu, 1)
//
// with which we now extract only three elements:
//
// >>> a[iu1]
// array([1, 2, 5])
//
//go:linkname MaskIndices py.mask_indices
func MaskIndices(n *py.Object, maskFunc *py.Object, k *py.Object) *py.Object

// Return the indices for the lower-triangle of an (n, m) array.
//
// Parameters
// ----------
// n : int
//
//	The row dimension of the arrays for which the returned
//	indices will be valid.
//
// k : int, optional
//
//	Diagonal offset (see `tril` for details).
//
// m : int, optional
//
//	.. versionadded:: 1.9.0
//
//	The column dimension of the arrays for which the returned
//	arrays will be valid.
//	By default `m` is taken equal to `n`.
//
// Returns
// -------
// inds : tuple of arrays
//
//	The indices for the triangle. The returned tuple contains two arrays,
//	each with the indices along one dimension of the array.
//
// See also
// --------
// triu_indices : similar function, for upper-triangular.
// mask_indices : generic function accepting an arbitrary mask function.
// tril, triu
//
// Notes
// -----
// .. versionadded:: 1.4.0
//
// Examples
// --------
// Compute two different sets of indices to access 4x4 arrays, one for the
// lower triangular part starting at the main diagonal, and one starting two
// diagonals further right:
//
// >>> il1 = np.tril_indices(4)
// >>> il2 = np.tril_indices(4, 2)
//
// Here is how they can be used with a sample 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]])
//
// Both for indexing:
//
// >>> a[il1]
// array([ 0,  4,  5, ..., 13, 14, 15])
//
// And for assigning values:
//
// >>> a[il1] = -1
// >>> a
// array([[-1,  1,  2,  3],
//
//	[-1, -1,  6,  7],
//	[-1, -1, -1, 11],
//	[-1, -1, -1, -1]])
//
// These cover almost the whole array (two diagonals right of the main one):
//
// >>> a[il2] = -10
// >>> a
// array([[-10, -10, -10,   3],
//
//	[-10, -10, -10, -10],
//	[-10, -10, -10, -10],
//	[-10, -10, -10, -10]])
//
//go:linkname TrilIndices py.tril_indices
func TrilIndices(n *py.Object, k *py.Object, m *py.Object) *py.Object

// Return the indices for the upper-triangle of an (n, m) array.
//
// Parameters
// ----------
// n : int
//
//	The size of the arrays for which the returned indices will
//	be valid.
//
// k : int, optional
//
//	Diagonal offset (see `triu` for details).
//
// m : int, optional
//
//	.. versionadded:: 1.9.0
//
//	The column dimension of the arrays for which the returned
//	arrays will be valid.
//	By default `m` is taken equal to `n`.
//
// Returns
// -------
// inds : tuple, shape(2) of ndarrays, shape(`n`)
//
//	The indices for the triangle. The returned tuple contains two arrays,
//	each with the indices along one dimension of the array.  Can be used
//	to slice a ndarray of shape(`n`, `n`).
//
// See also
// --------
// tril_indices : similar function, for lower-triangular.
// mask_indices : generic function accepting an arbitrary mask function.
// triu, tril
//
// Notes
// -----
// .. versionadded:: 1.4.0
//
// Examples
// --------
// Compute two different sets of indices to access 4x4 arrays, one for the
// upper triangular part starting at the main diagonal, and one starting two
// diagonals further right:
//
// >>> iu1 = np.triu_indices(4)
// >>> iu2 = np.triu_indices(4, 2)
//
// Here is how they can be used with a sample 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]])
//
// Both for indexing:
//
// >>> a[iu1]
// array([ 0,  1,  2, ..., 10, 11, 15])
//
// And for assigning values:
//
// >>> a[iu1] = -1
// >>> a
// array([[-1, -1, -1, -1],
//
//	[ 4, -1, -1, -1],
//	[ 8,  9, -1, -1],
//	[12, 13, 14, -1]])
//
// These cover only a small part of the whole array (two diagonals right
// of the main one):
//
// >>> a[iu2] = -10
// >>> a
// array([[ -1,  -1, -10, -10],
//
//	[  4,  -1,  -1, -10],
//	[  8,   9,  -1,  -1],
//	[ 12,  13,  14,  -1]])
//
//go:linkname TriuIndices py.triu_indices
func TriuIndices(n *py.Object, k *py.Object, m *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
//
//go:linkname Issubclass py.issubclass_
func Issubclass(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
//
//go:linkname Issubsctype py.issubsctype
func Issubsctype(arg1 *py.Object, arg2 *py.Object) *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
//
//go:linkname Deprecate py.deprecate
func Deprecate(args ...*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
//
//go:linkname DeprecateWithDoc py.deprecate_with_doc
func DeprecateWithDoc(msg *py.Object) *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()])
//	...
//
//go:linkname GetInclude py.get_include
func GetInclude() *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
//
//go:linkname Info py.info
func Info(object *py.Object, maxwidth *py.Object, output *py.Object, toplevel *py.Object) *py.Object

// Print the NumPy arrays in the given dictionary.
//
// If there is no dictionary passed in or `vardict` is None then returns
// NumPy arrays in the globals() dictionary (all NumPy arrays in the
// namespace).
//
// Parameters
// ----------
// vardict : dict, optional
//
//	A dictionary possibly containing ndarrays.  Default is globals().
//
// Returns
// -------
// out : None
//
//	Returns 'None'.
//
// Notes
// -----
// Prints out the name, shape, bytes and type of all of the ndarrays
// present in `vardict`.
//
// Examples
// --------
// >>> a = np.arange(10)
// >>> b = np.ones(20)
// >>> np.who()
// Name            Shape            Bytes            Type
// ===========================================================
// a               10               80               int64
// b               20               160              float64
// Upper bound on total bytes  =       240
//
// >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
// ... 'idx':5}
// >>> np.who(d)
// Name            Shape            Bytes            Type
// ===========================================================
// x               2                16               float64
// y               3                24               float64
// Upper bound on total bytes  =       40
//
//go:linkname Who py.who
func Who(vardict *py.Object) *py.Object

// Do a keyword search on docstrings.
//
// A list of objects that matched the search is displayed,
// sorted by relevance. All given keywords need to be found in the
// docstring for it to be returned as a result, but the order does
// not matter.
//
// Parameters
// ----------
// what : str
//
//	String containing words to look for.
//
// module : str or list, optional
//
//	Name of module(s) whose docstrings to go through.
//
// import_modules : bool, optional
//
//	Whether to import sub-modules in packages. Default is True.
//
// regenerate : bool, optional
//
//	Whether to re-generate the docstring cache. Default is False.
//
// output : file-like, optional
//
//	File-like object to write the output to. If omitted, use a pager.
//
// See Also
// --------
// source, info
//
// Notes
// -----
// Relevance is determined only roughly, by checking if the keywords occur
// in the function name, at the start of a docstring, etc.
//
// Examples
// --------
// >>> np.lookfor('binary representation') # doctest: +SKIP
// Search results for 'binary representation'
// ------------------------------------------
// numpy.binary_repr
//
//	Return the binary representation of the input number as a string.
//
// numpy.core.setup_common.long_double_representation
//
//	Given a binary dump as given by GNU od -b, look for long double
//
// numpy.base_repr
//
//	Return a string representation of a number in the given base system.
//
// ...
//
//go:linkname Lookfor py.lookfor
func Lookfor(what *py.Object, module *py.Object, importModules *py.Object, regenerate *py.Object, output *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
//
//go:linkname ByteBounds py.byte_bounds
func ByteBounds(a *py.Object) *py.Object

// Protected string evaluation.
//
// Evaluate a string containing a Python literal expression without
// allowing the execution of arbitrary non-literal code.
//
// .. warning::
//
//	This function is identical to :py:meth:`ast.literal_eval` and
//	has the same security implications.  It may not always be safe
//	to evaluate large input strings.
//
// Parameters
// ----------
// source : str
//
//	The string to evaluate.
//
// Returns
// -------
// obj : object
//
//	The result of evaluating `source`.
//
// Raises
// ------
// SyntaxError
//
//	If the code has invalid Python syntax, or if it contains
//	non-literal code.
//
// Examples
// --------
// >>> np.safe_eval('1')
// 1
// >>> np.safe_eval('[1, 2, 3]')
// [1, 2, 3]
// >>> np.safe_eval('{"foo": ("bar", 10.0)}')
// {'foo': ('bar', 10.0)}
//
// >>> np.safe_eval('import os')
// Traceback (most recent call last):
//
//	...
//
// SyntaxError: invalid syntax
//
// >>> np.safe_eval('open("/home/user/.ssh/id_dsa").read()')
// Traceback (most recent call last):
//
//	...
//
// ValueError: malformed node or string: <_ast.Call object at 0x...>
//
//go:linkname SafeEval py.safe_eval
func SafeEval(source *py.Object) *py.Object

// Print information about various resources in the system
// including available intrinsic support and BLAS/LAPACK library
// in use
//
// .. versionadded:: 1.24.0
//
// See Also
// --------
// show_config : Show libraries in the system on which NumPy was built.
//
// Notes
// -----
//  1. Information is derived with the help of `threadpoolctl <https://pypi.org/project/threadpoolctl/>`_
//     library if available.
//  2. SIMD related information is derived from “__cpu_features__“,
//     “__cpu_baseline__“ and “__cpu_dispatch__“
//
//go:linkname ShowRuntime py.show_runtime
func ShowRuntime() *py.Object

// Load ASCII data from a file and return it in a record array.
//
// If “usemask=False“ a standard `recarray` is returned,
// if “usemask=True“ a MaskedRecords array is returned.
//
// Parameters
// ----------
// fname, kwargs : For a description of input parameters, see `genfromtxt`.
//
// See Also
// --------
// numpy.genfromtxt : generic function
//
// Notes
// -----
// By default, `dtype` is None, which means that the data-type of the output
// array will be determined from the data.
//
//go:linkname Recfromtxt py.recfromtxt
func Recfromtxt(fname *py.Object) *py.Object

// Load ASCII data stored in a comma-separated file.
//
// The returned array is a record array (if “usemask=False“, see
// `recarray`) or a masked record array (if “usemask=True“,
// see `ma.mrecords.MaskedRecords`).
//
// Parameters
// ----------
// fname, kwargs : For a description of input parameters, see `genfromtxt`.
//
// See Also
// --------
// numpy.genfromtxt : generic function to load ASCII data.
//
// Notes
// -----
// By default, `dtype` is None, which means that the data-type of the output
// array will be determined from the data.
//
//go:linkname Recfromcsv py.recfromcsv
func Recfromcsv(fname *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
//
//	What encoding to use when reading Python 2 strings. Only useful when
//	loading Python 2 generated pickled files in Python 3, which includes
//	npy/npz files containing object arrays. Values other than 'latin1',
//	'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
//	data. Default: 'ASCII'
//
// max_header_size : int, optional
//
//	Maximum allowed size of the header.  Large headers may not be safe
//	to load securely and thus require explicitly passing a larger value.
//	See :py:func:`ast.literal_eval()` for details.
//	This option is ignored when `allow_pickle` is passed.  In that case
//	the file is by definition trusted and the limit is unnecessary.
//
// Returns
// -------
// result : array, tuple, dict, etc.
//
//	Data stored in the file. For ``.npz`` files, the returned instance
//	of NpzFile class must be closed to avoid leaking file descriptors.
//
// Raises
// ------
// OSError
//
//	If the input file does not exist or cannot be read.
//
// UnpicklingError
//
//	If ``allow_pickle=True``, but the file cannot be loaded as a pickle.
//
// ValueError
//
//	The file contains an object array, but ``allow_pickle=False`` given.
//
// EOFError
//
//	When calling ``np.load`` multiple times on the same file handle,
//	if all data has already been read
//
// See Also
// --------
// save, savez, savez_compressed, loadtxt
// memmap : Create a memory-map to an array stored in a file on disk.
// lib.format.open_memmap : Create or load a memory-mapped “.npy“ file.
//
// Notes
// -----
//
//   - If the file contains pickle data, then whatever object is stored
//     in the pickle is returned.
//
//   - If the file is a “.npy“ file, then a single array is returned.
//
//   - If the file is a “.npz“ file, then a dictionary-like object is
//     returned, containing “{filename: array}“ key-value pairs, one for
//     each file in the archive.
//
//   - If the file is a “.npz“ file, the returned value supports the
//     context manager protocol in a similar fashion to the open function::
//
//     with load('foo.npz') as data:
//     a = data['a']
//
//     The underlying file descriptor is closed when exiting the 'with'
//     block.
//
// Examples
// --------
// Store data to disk, and load it again:
//
// >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
// >>> np.load('/tmp/123.npy')
// array([[1, 2, 3],
//
//	[4, 5, 6]])
//
// Store compressed data to disk, and load it again:
//
// >>> a=np.array([[1, 2, 3], [4, 5, 6]])
// >>> b=np.array([1, 2])
// >>> np.savez('/tmp/123.npz', a=a, b=b)
// >>> data = np.load('/tmp/123.npz')
// >>> data['a']
// array([[1, 2, 3],
//
//	[4, 5, 6]])
//
// >>> data['b']
// array([1, 2])
// >>> data.close()
//
// Mem-map the stored array, and then access the second row
// directly from disk:
//
// >>> X = np.load('/tmp/123.npy', mmap_mode='r')
// >>> X[1, :]
// memmap([4, 5, 6])
//
//go:linkname Load py.load
func Load(file *py.Object, mmapMode *py.Object, allowPickle *py.Object, fixImports *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])
//
//go:linkname Fromregex py.fromregex
func Fromregex(file *py.Object, regexp *py.Object, dtype *py.Object, encoding *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]])
//
//go:linkname Bmat py.bmat
func Bmat(obj *py.Object, ldict *py.Object, gdict *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]])
//
//go:linkname Mat py.mat
func Mat(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]])
//
//go:linkname Asmatrix py.asmatrix
func Asmatrix(data *py.Object, dtype *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])
//
//go:linkname Abs py.abs
func Abs(args ...*py.Object) *py.Object