MLPY/Lib/site-packages/numpy/core/multiarray.py

"""

Create the numpy.core.multiarray namespace for backward compatibility. In v1.16

the multiarray and umath c-extension modules were merged into a single

_multiarray_umath extension module. So we replicate the old namespace

by importing from the extension module.



"""

import functools
import warnings

from . import overrides
from . import _multiarray_umath
from ._multiarray_umath import *  # noqa: F403
# These imports are needed for backward compatibility,
# do not change them. issue gh-15518
# _get_ndarray_c_version is semi-public, on purpose not added to __all__
from ._multiarray_umath import (
    _fastCopyAndTranspose, _flagdict, _insert, _reconstruct, _vec_string,
    _ARRAY_API, _monotonicity, _get_ndarray_c_version, _set_madvise_hugepage,
    )

__all__ = [
    '_ARRAY_API', 'ALLOW_THREADS', 'BUFSIZE', 'CLIP', 'DATETIMEUNITS',
    'ITEM_HASOBJECT', 'ITEM_IS_POINTER', 'LIST_PICKLE', 'MAXDIMS',
    'MAY_SHARE_BOUNDS', 'MAY_SHARE_EXACT', 'NEEDS_INIT', 'NEEDS_PYAPI',
    'RAISE', 'USE_GETITEM', 'USE_SETITEM', 'WRAP', '_fastCopyAndTranspose',
    '_flagdict', '_insert', '_reconstruct', '_vec_string', '_monotonicity',
    'add_docstring', 'arange', 'array', 'asarray', 'asanyarray',
    'ascontiguousarray', 'asfortranarray', 'bincount', 'broadcast',
    'busday_count', 'busday_offset', 'busdaycalendar', 'can_cast',
    'compare_chararrays', 'concatenate', 'copyto', 'correlate', 'correlate2',
    'count_nonzero', 'c_einsum', 'datetime_as_string', 'datetime_data',
    'digitize', 'dot', 'dragon4_positional', 'dragon4_scientific', 'dtype',
    'empty', 'empty_like', 'error', 'flagsobj', 'flatiter', 'format_longfloat',
    'frombuffer', 'fromfile', 'fromiter', 'fromstring', 'inner',
    'interp', 'interp_complex', 'is_busday', 'lexsort',
    'matmul', 'may_share_memory', 'min_scalar_type', 'ndarray', 'nditer',
    'nested_iters', 'normalize_axis_index', 'packbits',
    'promote_types', 'putmask', 'ravel_multi_index', 'result_type', 'scalar',
    'set_datetimeparse_function', 'set_legacy_print_mode', 'set_numeric_ops',
    'set_string_function', 'set_typeDict', 'shares_memory',
    'tracemalloc_domain', 'typeinfo', 'unpackbits', 'unravel_index', 'vdot',
    'where', 'zeros']

# For backward compatibility, make sure pickle imports these functions from here
_reconstruct.__module__ = 'numpy.core.multiarray'
scalar.__module__ = 'numpy.core.multiarray'


arange.__module__ = 'numpy'
array.__module__ = 'numpy'
asarray.__module__ = 'numpy'
asanyarray.__module__ = 'numpy'
ascontiguousarray.__module__ = 'numpy'
asfortranarray.__module__ = 'numpy'
datetime_data.__module__ = 'numpy'
empty.__module__ = 'numpy'
frombuffer.__module__ = 'numpy'
fromfile.__module__ = 'numpy'
fromiter.__module__ = 'numpy'
frompyfunc.__module__ = 'numpy'
fromstring.__module__ = 'numpy'
geterrobj.__module__ = 'numpy'
may_share_memory.__module__ = 'numpy'
nested_iters.__module__ = 'numpy'
promote_types.__module__ = 'numpy'
set_numeric_ops.__module__ = 'numpy'
seterrobj.__module__ = 'numpy'
zeros.__module__ = 'numpy'


# We can't verify dispatcher signatures because NumPy's C functions don't
# support introspection.
array_function_from_c_func_and_dispatcher = functools.partial(
    overrides.array_function_from_dispatcher,
    module='numpy', docs_from_dispatcher=True, verify=False)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.empty_like)
def empty_like(prototype, dtype=None, order=None, subok=None, shape=None):
    """

    empty_like(prototype, dtype=None, order='K', subok=True, shape=None)



    Return a new array with the same shape and type as a given array.



    Parameters

    ----------

    prototype : array_like

        The shape and data-type of `prototype` define these same attributes

        of the returned array.

    dtype : data-type, optional

        Overrides the data type of the result.



        .. versionadded:: 1.6.0

    order : {'C', 'F', 'A', or 'K'}, optional

        Overrides the memory layout of the result. 'C' means C-order,

        'F' means F-order, 'A' means 'F' if `prototype` is Fortran

        contiguous, 'C' otherwise. 'K' means match the layout of `prototype`

        as closely as possible.



        .. versionadded:: 1.6.0

    subok : bool, optional.

        If True, then the newly created array will use the sub-class

        type of `prototype`, otherwise it will be a base-class array. Defaults

        to True.

    shape : int or sequence of ints, optional.

        Overrides the shape of the result. If order='K' and the number of

        dimensions is unchanged, will try to keep order, otherwise,

        order='C' is implied.



        .. versionadded:: 1.17.0



    Returns

    -------

    out : ndarray

        Array of uninitialized (arbitrary) data with the same

        shape and type as `prototype`.



    See Also

    --------

    ones_like : Return an array of ones with shape and type of input.

    zeros_like : Return an array of zeros with shape and type of input.

    full_like : Return a new array with shape of input filled with value.

    empty : Return a new uninitialized array.



    Notes

    -----

    This function does *not* initialize the returned array; to do that use

    `zeros_like` or `ones_like` instead.  It may be marginally faster than

    the functions that do set the array values.



    Examples

    --------

    >>> a = ([1,2,3], [4,5,6])                         # a is array-like

    >>> np.empty_like(a)

    array([[-1073741821, -1073741821,           3],    # uninitialized

           [          0,           0, -1073741821]])

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

    >>> np.empty_like(a)

    array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized

           [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])



    """
    return (prototype,)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.concatenate)
def concatenate(arrays, axis=None, out=None, *, dtype=None, casting=None):
    """

    concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind")



    Join a sequence of arrays along an existing axis.



    Parameters

    ----------

    a1, a2, ... : sequence of array_like

        The arrays must have the same shape, except in the dimension

        corresponding to `axis` (the first, by default).

    axis : int, optional

        The axis along which the arrays will be joined.  If axis is None,

        arrays are flattened before use.  Default is 0.

    out : ndarray, optional

        If provided, the destination to place the result. The shape must be

        correct, matching that of what concatenate would have returned if no

        out argument were specified.

    dtype : str or dtype

        If provided, the destination array will have this dtype. Cannot be

        provided together with `out`.



        .. versionadded:: 1.20.0



    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

        Controls what kind of data casting may occur. Defaults to 'same_kind'.



        .. versionadded:: 1.20.0



    Returns

    -------

    res : ndarray

        The concatenated array.



    See Also

    --------

    ma.concatenate : Concatenate function that preserves input masks.

    array_split : Split an array into multiple sub-arrays of equal or

                  near-equal size.

    split : Split array into a list of multiple sub-arrays of equal size.

    hsplit : Split array into multiple sub-arrays horizontally (column wise).

    vsplit : Split array into multiple sub-arrays vertically (row wise).

    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).

    stack : Stack a sequence of arrays along a new axis.

    block : Assemble arrays from blocks.

    hstack : Stack arrays in sequence horizontally (column wise).

    vstack : Stack arrays in sequence vertically (row wise).

    dstack : Stack arrays in sequence depth wise (along third dimension).

    column_stack : Stack 1-D arrays as columns into a 2-D array.



    Notes

    -----

    When one or more of the arrays to be concatenated is a MaskedArray,

    this function will return a MaskedArray object instead of an ndarray,

    but the input masks are *not* preserved. In cases where a MaskedArray

    is expected as input, use the ma.concatenate function from the masked

    array module instead.



    Examples

    --------

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

    >>> b = np.array([[5, 6]])

    >>> np.concatenate((a, b), axis=0)

    array([[1, 2],

           [3, 4],

           [5, 6]])

    >>> np.concatenate((a, b.T), axis=1)

    array([[1, 2, 5],

           [3, 4, 6]])

    >>> np.concatenate((a, b), axis=None)

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



    This function will not preserve masking of MaskedArray inputs.



    >>> a = np.ma.arange(3)

    >>> a[1] = np.ma.masked

    >>> b = np.arange(2, 5)

    >>> a

    masked_array(data=[0, --, 2],

                 mask=[False,  True, False],

           fill_value=999999)

    >>> b

    array([2, 3, 4])

    >>> np.concatenate([a, b])

    masked_array(data=[0, 1, 2, 2, 3, 4],

                 mask=False,

           fill_value=999999)

    >>> np.ma.concatenate([a, b])

    masked_array(data=[0, --, 2, 2, 3, 4],

                 mask=[False,  True, False, False, False, False],

           fill_value=999999)



    """
    if out is not None:
        # optimize for the typical case where only arrays is provided
        arrays = list(arrays)
        arrays.append(out)
    return arrays


@array_function_from_c_func_and_dispatcher(_multiarray_umath.inner)
def inner(a, b):
    """

    inner(a, b)



    Inner product of two arrays.



    Ordinary inner product of vectors for 1-D arrays (without complex

    conjugation), in higher dimensions a sum product over the last axes.



    Parameters

    ----------

    a, b : array_like

        If `a` and `b` are nonscalar, their last dimensions must match.



    Returns

    -------

    out : ndarray

        If `a` and `b` are both

        scalars or both 1-D arrays then a scalar is returned; otherwise

        an array is returned.

        ``out.shape = (*a.shape[:-1], *b.shape[:-1])``



    Raises

    ------

    ValueError

        If both `a` and `b` are nonscalar and their last dimensions have

        different sizes.



    See Also

    --------

    tensordot : Sum products over arbitrary axes.

    dot : Generalised matrix product, using second last dimension of `b`.

    einsum : Einstein summation convention.



    Notes

    -----

    For vectors (1-D arrays) it computes the ordinary inner-product::



        np.inner(a, b) = sum(a[:]*b[:])



    More generally, if `ndim(a) = r > 0` and `ndim(b) = s > 0`::



        np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))



    or explicitly::



        np.inner(a, b)[i0,...,ir-2,j0,...,js-2]

             = sum(a[i0,...,ir-2,:]*b[j0,...,js-2,:])



    In addition `a` or `b` may be scalars, in which case::



       np.inner(a,b) = a*b



    Examples

    --------

    Ordinary inner product for vectors:



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

    >>> b = np.array([0,1,0])

    >>> np.inner(a, b)

    2



    Some multidimensional examples:



    >>> a = np.arange(24).reshape((2,3,4))

    >>> b = np.arange(4)

    >>> c = np.inner(a, b)

    >>> c.shape

    (2, 3)

    >>> c

    array([[ 14,  38,  62],

           [ 86, 110, 134]])



    >>> a = np.arange(2).reshape((1,1,2))

    >>> b = np.arange(6).reshape((3,2))

    >>> c = np.inner(a, b)

    >>> c.shape

    (1, 1, 3)

    >>> c

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



    An example where `b` is a scalar:



    >>> np.inner(np.eye(2), 7)

    array([[7., 0.],

           [0., 7.]])



    """
    return (a, b)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.where)
def where(condition, x=None, y=None):
    """

    where(condition, [x, y])



    Return elements chosen from `x` or `y` depending on `condition`.



    .. note::

        When only `condition` is provided, this function is a shorthand for

        ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be

        preferred, as it behaves correctly for subclasses. The rest of this

        documentation covers only the case where all three arguments are

        provided.



    Parameters

    ----------

    condition : array_like, bool

        Where True, yield `x`, otherwise yield `y`.

    x, y : array_like

        Values from which to choose. `x`, `y` and `condition` need to be

        broadcastable to some shape.



    Returns

    -------

    out : ndarray

        An array with elements from `x` where `condition` is True, and elements

        from `y` elsewhere.



    See Also

    --------

    choose

    nonzero : The function that is called when x and y are omitted



    Notes

    -----

    If all the arrays are 1-D, `where` is equivalent to::



        [xv if c else yv

         for c, xv, yv in zip(condition, x, y)]



    Examples

    --------

    >>> a = np.arange(10)

    >>> a

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

    >>> np.where(a < 5, a, 10*a)

    array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])



    This can be used on multidimensional arrays too:



    >>> np.where([[True, False], [True, True]],

    ...          [[1, 2], [3, 4]],

    ...          [[9, 8], [7, 6]])

    array([[1, 8],

           [3, 4]])



    The shapes of x, y, and the condition are broadcast together:



    >>> x, y = np.ogrid[:3, :4]

    >>> np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast

    array([[10,  0,  0,  0],

           [10, 11,  1,  1],

           [10, 11, 12,  2]])



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

    ...               [0, 2, 4],

    ...               [0, 3, 6]])

    >>> np.where(a < 4, a, -1)  # -1 is broadcast

    array([[ 0,  1,  2],

           [ 0,  2, -1],

           [ 0,  3, -1]])

    """
    return (condition, x, y)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.lexsort)
def lexsort(keys, axis=None):
    """

    lexsort(keys, axis=-1)



    Perform an indirect stable sort using a sequence of keys.



    Given multiple sorting keys, which can be interpreted as columns in a

    spreadsheet, lexsort returns an array of integer indices that describes

    the sort order by multiple columns. The last key in the sequence is used

    for the primary sort order, the second-to-last key for the secondary sort

    order, and so on. The keys argument must be a sequence of objects that

    can be converted to arrays of the same shape. If a 2D array is provided

    for the keys argument, its rows are interpreted as the sorting keys and

    sorting is according to the last row, second last row etc.



    Parameters

    ----------

    keys : (k, N) array or tuple containing k (N,)-shaped sequences

        The `k` different "columns" to be sorted.  The last column (or row if

        `keys` is a 2D array) is the primary sort key.

    axis : int, optional

        Axis to be indirectly sorted.  By default, sort over the last axis.



    Returns

    -------

    indices : (N,) ndarray of ints

        Array of indices that sort the keys along the specified axis.



    See Also

    --------

    argsort : Indirect sort.

    ndarray.sort : In-place sort.

    sort : Return a sorted copy of an array.



    Examples

    --------

    Sort names: first by surname, then by name.



    >>> surnames =    ('Hertz',    'Galilei', 'Hertz')

    >>> first_names = ('Heinrich', 'Galileo', 'Gustav')

    >>> ind = np.lexsort((first_names, surnames))

    >>> ind

    array([1, 2, 0])



    >>> [surnames[i] + ", " + first_names[i] for i in ind]

    ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']



    Sort two columns of numbers:



    >>> a = [1,5,1,4,3,4,4] # First column

    >>> b = [9,4,0,4,0,2,1] # Second column

    >>> ind = np.lexsort((b,a)) # Sort by a, then by b

    >>> ind

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



    >>> [(a[i],b[i]) for i in ind]

    [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]



    Note that sorting is first according to the elements of ``a``.

    Secondary sorting is according to the elements of ``b``.



    A normal ``argsort`` would have yielded:



    >>> [(a[i],b[i]) for i in np.argsort(a)]

    [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]



    Structured arrays are sorted lexically by ``argsort``:



    >>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],

    ...              dtype=np.dtype([('x', int), ('y', int)]))



    >>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))

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



    """
    if isinstance(keys, tuple):
        return keys
    else:
        return (keys,)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.can_cast)
def can_cast(from_, to, casting=None):
    """

    can_cast(from_, to, casting='safe')



    Returns True if cast between data types can occur according to the

    casting rule.  If from is a scalar or array scalar, also returns

    True if the scalar value can be cast without overflow or truncation

    to an integer.



    Parameters

    ----------

    from_ : dtype, dtype specifier, scalar, or array

        Data type, scalar, or array to cast from.

    to : dtype or dtype specifier

        Data type to cast to.

    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

        Controls what kind of data casting may occur.



          * 'no' means the data types should not be cast at all.

          * 'equiv' means only byte-order changes are allowed.

          * 'safe' means only casts which can preserve values are allowed.

          * 'same_kind' means only safe casts or casts within a kind,

            like float64 to float32, are allowed.

          * 'unsafe' means any data conversions may be done.



    Returns

    -------

    out : bool

        True if cast can occur according to the casting rule.



    Notes

    -----

    .. versionchanged:: 1.17.0

       Casting between a simple data type and a structured one is possible only

       for "unsafe" casting.  Casting to multiple fields is allowed, but

       casting from multiple fields is not.



    .. versionchanged:: 1.9.0

       Casting from numeric to string types in 'safe' casting mode requires

       that the string dtype length is long enough to store the maximum

       integer/float value converted.



    See also

    --------

    dtype, result_type



    Examples

    --------

    Basic examples



    >>> np.can_cast(np.int32, np.int64)

    True

    >>> np.can_cast(np.float64, complex)

    True

    >>> np.can_cast(complex, float)

    False



    >>> np.can_cast('i8', 'f8')

    True

    >>> np.can_cast('i8', 'f4')

    False

    >>> np.can_cast('i4', 'S4')

    False



    Casting scalars



    >>> np.can_cast(100, 'i1')

    True

    >>> np.can_cast(150, 'i1')

    False

    >>> np.can_cast(150, 'u1')

    True



    >>> np.can_cast(3.5e100, np.float32)

    False

    >>> np.can_cast(1000.0, np.float32)

    True



    Array scalar checks the value, array does not



    >>> np.can_cast(np.array(1000.0), np.float32)

    True

    >>> np.can_cast(np.array([1000.0]), np.float32)

    False



    Using the casting rules



    >>> np.can_cast('i8', 'i8', 'no')

    True

    >>> np.can_cast('<i8', '>i8', 'no')

    False



    >>> np.can_cast('<i8', '>i8', 'equiv')

    True

    >>> np.can_cast('<i4', '>i8', 'equiv')

    False



    >>> np.can_cast('<i4', '>i8', 'safe')

    True

    >>> np.can_cast('<i8', '>i4', 'safe')

    False



    >>> np.can_cast('<i8', '>i4', 'same_kind')

    True

    >>> np.can_cast('<i8', '>u4', 'same_kind')

    False



    >>> np.can_cast('<i8', '>u4', 'unsafe')

    True



    """
    return (from_,)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.min_scalar_type)
def min_scalar_type(a):
    """

    min_scalar_type(a)



    For scalar ``a``, returns the data type with the smallest size

    and smallest scalar kind which can hold its value.  For non-scalar

    array ``a``, returns the vector's dtype unmodified.



    Floating point values are not demoted to integers,

    and complex values are not demoted to floats.



    Parameters

    ----------

    a : scalar or array_like

        The value whose minimal data type is to be found.



    Returns

    -------

    out : dtype

        The minimal data type.



    Notes

    -----

    .. versionadded:: 1.6.0



    See Also

    --------

    result_type, promote_types, dtype, can_cast



    Examples

    --------

    >>> np.min_scalar_type(10)

    dtype('uint8')



    >>> np.min_scalar_type(-260)

    dtype('int16')



    >>> np.min_scalar_type(3.1)

    dtype('float16')



    >>> np.min_scalar_type(1e50)

    dtype('float64')



    >>> np.min_scalar_type(np.arange(4,dtype='f8'))

    dtype('float64')



    """
    return (a,)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.result_type)
def result_type(*arrays_and_dtypes):
    """

    result_type(*arrays_and_dtypes)



    Returns the type that results from applying the NumPy

    type promotion rules to the arguments.



    Type promotion in NumPy works similarly to the rules in languages

    like C++, with some slight differences.  When both scalars and

    arrays are used, the array's type takes precedence and the actual value

    of the scalar is taken into account.



    For example, calculating 3*a, where a is an array of 32-bit floats,

    intuitively should result in a 32-bit float output.  If the 3 is a

    32-bit integer, the NumPy rules indicate it can't convert losslessly

    into a 32-bit float, so a 64-bit float should be the result type.

    By examining the value of the constant, '3', we see that it fits in

    an 8-bit integer, which can be cast losslessly into the 32-bit float.



    Parameters

    ----------

    arrays_and_dtypes : list of arrays and dtypes

        The operands of some operation whose result type is needed.



    Returns

    -------

    out : dtype

        The result type.



    See also

    --------

    dtype, promote_types, min_scalar_type, can_cast



    Notes

    -----

    .. versionadded:: 1.6.0



    The specific algorithm used is as follows.



    Categories are determined by first checking which of boolean,

    integer (int/uint), or floating point (float/complex) the maximum

    kind of all the arrays and the scalars are.



    If there are only scalars or the maximum category of the scalars

    is higher than the maximum category of the arrays,

    the data types are combined with :func:`promote_types`

    to produce the return value.



    Otherwise, `min_scalar_type` is called on each array, and

    the resulting data types are all combined with :func:`promote_types`

    to produce the return value.



    The set of int values is not a subset of the uint values for types

    with the same number of bits, something not reflected in

    :func:`min_scalar_type`, but handled as a special case in `result_type`.



    Examples

    --------

    >>> np.result_type(3, np.arange(7, dtype='i1'))

    dtype('int8')



    >>> np.result_type('i4', 'c8')

    dtype('complex128')



    >>> np.result_type(3.0, -2)

    dtype('float64')



    """
    return arrays_and_dtypes


@array_function_from_c_func_and_dispatcher(_multiarray_umath.dot)
def dot(a, b, out=None):
    """

    dot(a, b, out=None)



    Dot product of two arrays. Specifically,



    - If both `a` and `b` are 1-D arrays, it is inner product of vectors

      (without complex conjugation).



    - If both `a` and `b` are 2-D arrays, it is matrix multiplication,

      but using :func:`matmul` or ``a @ b`` is preferred.



    - If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`

      and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.



    - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over

      the last axis of `a` and `b`.



    - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a

      sum product over the last axis of `a` and the second-to-last axis of `b`::



        dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])



    Parameters

    ----------

    a : array_like

        First argument.

    b : array_like

        Second argument.

    out : ndarray, optional

        Output argument. This must have the exact kind that would be returned

        if it was not used. In particular, it must have the right type, must be

        C-contiguous, and its dtype must be the dtype that would be returned

        for `dot(a,b)`. This is a performance feature. Therefore, if these

        conditions are not met, an exception is raised, instead of attempting

        to be flexible.



    Returns

    -------

    output : ndarray

        Returns the dot product of `a` and `b`.  If `a` and `b` are both

        scalars or both 1-D arrays then a scalar is returned; otherwise

        an array is returned.

        If `out` is given, then it is returned.



    Raises

    ------

    ValueError

        If the last dimension of `a` is not the same size as

        the second-to-last dimension of `b`.



    See Also

    --------

    vdot : Complex-conjugating dot product.

    tensordot : Sum products over arbitrary axes.

    einsum : Einstein summation convention.

    matmul : '@' operator as method with out parameter.

    linalg.multi_dot : Chained dot product.



    Examples

    --------

    >>> np.dot(3, 4)

    12



    Neither argument is complex-conjugated:



    >>> np.dot([2j, 3j], [2j, 3j])

    (-13+0j)



    For 2-D arrays it is the matrix product:



    >>> a = [[1, 0], [0, 1]]

    >>> b = [[4, 1], [2, 2]]

    >>> np.dot(a, b)

    array([[4, 1],

           [2, 2]])



    >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))

    >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))

    >>> np.dot(a, b)[2,3,2,1,2,2]

    499128

    >>> sum(a[2,3,2,:] * b[1,2,:,2])

    499128



    """
    return (a, b, out)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.vdot)
def vdot(a, b):
    """

    vdot(a, b)



    Return the dot product of two vectors.



    The vdot(`a`, `b`) function handles complex numbers differently than

    dot(`a`, `b`).  If the first argument is complex the complex conjugate

    of the first argument is used for the calculation of the dot product.



    Note that `vdot` handles multidimensional arrays differently than `dot`:

    it does *not* perform a matrix product, but flattens input arguments

    to 1-D vectors first. Consequently, it should only be used for vectors.



    Parameters

    ----------

    a : array_like

        If `a` is complex the complex conjugate is taken before calculation

        of the dot product.

    b : array_like

        Second argument to the dot product.



    Returns

    -------

    output : ndarray

        Dot product of `a` and `b`.  Can be an int, float, or

        complex depending on the types of `a` and `b`.



    See Also

    --------

    dot : Return the dot product without using the complex conjugate of the

          first argument.



    Examples

    --------

    >>> a = np.array([1+2j,3+4j])

    >>> b = np.array([5+6j,7+8j])

    >>> np.vdot(a, b)

    (70-8j)

    >>> np.vdot(b, a)

    (70+8j)



    Note that higher-dimensional arrays are flattened!



    >>> a = np.array([[1, 4], [5, 6]])

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

    >>> np.vdot(a, b)

    30

    >>> np.vdot(b, a)

    30

    >>> 1*4 + 4*1 + 5*2 + 6*2

    30



    """
    return (a, b)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.bincount)
def bincount(x, weights=None, minlength=None):
    """

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



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



    The number of bins (of size 1) is one larger than the largest value in

    `x`. If `minlength` is specified, there will be at least this number

    of bins in the output array (though it will be longer if necessary,

    depending on the contents of `x`).

    Each bin gives the number of occurrences of its index value in `x`.

    If `weights` is specified the input array is weighted by it, i.e. if a

    value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead

    of ``out[n] += 1``.



    Parameters

    ----------

    x : array_like, 1 dimension, nonnegative ints

        Input array.

    weights : array_like, optional

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

    minlength : int, optional

        A minimum number of bins for the output array.



        .. versionadded:: 1.6.0



    Returns

    -------

    out : ndarray of ints

        The result of binning the input array.

        The length of `out` is equal to ``np.amax(x)+1``.



    Raises

    ------

    ValueError

        If the input is not 1-dimensional, or contains elements with negative

        values, or if `minlength` is negative.

    TypeError

        If the type of the input is float or complex.



    See Also

    --------

    histogram, digitize, unique



    Examples

    --------

    >>> np.bincount(np.arange(5))

    array([1, 1, 1, 1, 1])

    >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))

    array([1, 3, 1, 1, 0, 0, 0, 1])



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

    >>> np.bincount(x).size == np.amax(x)+1

    True



    The input array needs to be of integer dtype, otherwise a

    TypeError is raised:



    >>> np.bincount(np.arange(5, dtype=float))

    Traceback (most recent call last):

      ...

    TypeError: Cannot cast array data from dtype('float64') to dtype('int64')

    according to the rule 'safe'



    A possible use of ``bincount`` is to perform sums over

    variable-size chunks of an array, using the ``weights`` keyword.



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

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

    >>> np.bincount(x,  weights=w)

    array([ 0.3,  0.7,  1.1])



    """
    return (x, weights)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.ravel_multi_index)
def ravel_multi_index(multi_index, dims, mode=None, order=None):
    """

    ravel_multi_index(multi_index, dims, mode='raise', order='C')



    Converts a tuple of index arrays into an array of flat

    indices, applying boundary modes to the multi-index.



    Parameters

    ----------

    multi_index : tuple of array_like

        A tuple of integer arrays, one array for each dimension.

    dims : tuple of ints

        The shape of array into which the indices from ``multi_index`` apply.

    mode : {'raise', 'wrap', 'clip'}, optional

        Specifies how out-of-bounds indices are handled.  Can specify

        either one mode or a tuple of modes, one mode per index.



        * 'raise' -- raise an error (default)

        * 'wrap' -- wrap around

        * 'clip' -- clip to the range



        In 'clip' mode, a negative index which would normally

        wrap will clip to 0 instead.

    order : {'C', 'F'}, optional

        Determines whether the multi-index should be viewed as

        indexing in row-major (C-style) or column-major

        (Fortran-style) order.



    Returns

    -------

    raveled_indices : ndarray

        An array of indices into the flattened version of an array

        of dimensions ``dims``.



    See Also

    --------

    unravel_index



    Notes

    -----

    .. versionadded:: 1.6.0



    Examples

    --------

    >>> arr = np.array([[3,6,6],[4,5,1]])

    >>> np.ravel_multi_index(arr, (7,6))

    array([22, 41, 37])

    >>> np.ravel_multi_index(arr, (7,6), order='F')

    array([31, 41, 13])

    >>> np.ravel_multi_index(arr, (4,6), mode='clip')

    array([22, 23, 19])

    >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))

    array([12, 13, 13])



    >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))

    1621

    """
    return multi_index


@array_function_from_c_func_and_dispatcher(_multiarray_umath.unravel_index)
def unravel_index(indices, shape=None, order=None):
    """

    unravel_index(indices, shape, order='C')



    Converts a flat index or array of flat indices into a tuple

    of coordinate arrays.



    Parameters

    ----------

    indices : array_like

        An integer array whose elements are indices into the flattened

        version of an array of dimensions ``shape``. Before version 1.6.0,

        this function accepted just one index value.

    shape : tuple of ints

        The shape of the array to use for unraveling ``indices``.



        .. versionchanged:: 1.16.0

            Renamed from ``dims`` to ``shape``.



    order : {'C', 'F'}, optional

        Determines whether the indices should be viewed as indexing in

        row-major (C-style) or column-major (Fortran-style) order.



        .. versionadded:: 1.6.0



    Returns

    -------

    unraveled_coords : tuple of ndarray

        Each array in the tuple has the same shape as the ``indices``

        array.



    See Also

    --------

    ravel_multi_index



    Examples

    --------

    >>> np.unravel_index([22, 41, 37], (7,6))

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

    >>> np.unravel_index([31, 41, 13], (7,6), order='F')

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



    >>> np.unravel_index(1621, (6,7,8,9))

    (3, 1, 4, 1)



    """
    return (indices,)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.copyto)
def copyto(dst, src, casting=None, where=None):
    """

    copyto(dst, src, casting='same_kind', where=True)



    Copies values from one array to another, broadcasting as necessary.



    Raises a TypeError if the `casting` rule is violated, and if

    `where` is provided, it selects which elements to copy.



    .. versionadded:: 1.7.0



    Parameters

    ----------

    dst : ndarray

        The array into which values are copied.

    src : array_like

        The array from which values are copied.

    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional

        Controls what kind of data casting may occur when copying.



          * 'no' means the data types should not be cast at all.

          * 'equiv' means only byte-order changes are allowed.

          * 'safe' means only casts which can preserve values are allowed.

          * 'same_kind' means only safe casts or casts within a kind,

            like float64 to float32, are allowed.

          * 'unsafe' means any data conversions may be done.

    where : array_like of bool, optional

        A boolean array which is broadcasted to match the dimensions

        of `dst`, and selects elements to copy from `src` to `dst`

        wherever it contains the value True.

    """
    return (dst, src, where)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.putmask)
def putmask(a, mask, values):
    """

    putmask(a, mask, values)



    Changes elements of an array based on conditional and input values.



    Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``.



    If `values` is not the same size as `a` and `mask` then it will repeat.

    This gives behavior different from ``a[mask] = values``.



    Parameters

    ----------

    a : ndarray

        Target array.

    mask : array_like

        Boolean mask array. It has to be the same shape as `a`.

    values : array_like

        Values to put into `a` where `mask` is True. If `values` is smaller

        than `a` it will be repeated.



    See Also

    --------

    place, put, take, copyto



    Examples

    --------

    >>> x = np.arange(6).reshape(2, 3)

    >>> np.putmask(x, x>2, x**2)

    >>> x

    array([[ 0,  1,  2],

           [ 9, 16, 25]])



    If `values` is smaller than `a` it is repeated:



    >>> x = np.arange(5)

    >>> np.putmask(x, x>1, [-33, -44])

    >>> x

    array([  0,   1, -33, -44, -33])



    """
    return (a, mask, values)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.packbits)
def packbits(a, axis=None, bitorder='big'):
    """

    packbits(a, axis=None, bitorder='big')



    Packs the elements of a binary-valued array into bits in a uint8 array.



    The result is padded to full bytes by inserting zero bits at the end.



    Parameters

    ----------

    a : array_like

        An array of integers or booleans whose elements should be packed to

        bits.

    axis : int, optional

        The dimension over which bit-packing is done.

        ``None`` implies packing the flattened array.

    bitorder : {'big', 'little'}, optional

        The order of the input bits. 'big' will mimic bin(val),

        ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will

        reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``.

        Defaults to 'big'.



        .. versionadded:: 1.17.0



    Returns

    -------

    packed : ndarray

        Array of type uint8 whose elements represent bits corresponding to the

        logical (0 or nonzero) value of the input elements. The shape of

        `packed` has the same number of dimensions as the input (unless `axis`

        is None, in which case the output is 1-D).



    See Also

    --------

    unpackbits: Unpacks elements of a uint8 array into a binary-valued output

                array.



    Examples

    --------

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

    ...                [0,1,0]],

    ...               [[1,1,0],

    ...                [0,0,1]]])

    >>> b = np.packbits(a, axis=-1)

    >>> b

    array([[[160],

            [ 64]],

           [[192],

            [ 32]]], dtype=uint8)



    Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000,

    and 32 = 0010 0000.



    """
    return (a,)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.unpackbits)
def unpackbits(a, axis=None, count=None, bitorder='big'):
    """

    unpackbits(a, axis=None, count=None, bitorder='big')



    Unpacks elements of a uint8 array into a binary-valued output array.



    Each element of `a` represents a bit-field that should be unpacked

    into a binary-valued output array. The shape of the output array is

    either 1-D (if `axis` is ``None``) or the same shape as the input

    array with unpacking done along the axis specified.



    Parameters

    ----------

    a : ndarray, uint8 type

       Input array.

    axis : int, optional

        The dimension over which bit-unpacking is done.

        ``None`` implies unpacking the flattened array.

    count : int or None, optional

        The number of elements to unpack along `axis`, provided as a way

        of undoing the effect of packing a size that is not a multiple

        of eight. A non-negative number means to only unpack `count`

        bits. A negative number means to trim off that many bits from

        the end. ``None`` means to unpack the entire array (the

        default). Counts larger than the available number of bits will

        add zero padding to the output. Negative counts must not

        exceed the available number of bits.



        .. versionadded:: 1.17.0



    bitorder : {'big', 'little'}, optional

        The order of the returned bits. 'big' will mimic bin(val),

        ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse

        the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``.

        Defaults to 'big'.



        .. versionadded:: 1.17.0



    Returns

    -------

    unpacked : ndarray, uint8 type

       The elements are binary-valued (0 or 1).



    See Also

    --------

    packbits : Packs the elements of a binary-valued array into bits in

               a uint8 array.



    Examples

    --------

    >>> a = np.array([[2], [7], [23]], dtype=np.uint8)

    >>> a

    array([[ 2],

           [ 7],

           [23]], dtype=uint8)

    >>> b = np.unpackbits(a, axis=1)

    >>> b

    array([[0, 0, 0, 0, 0, 0, 1, 0],

           [0, 0, 0, 0, 0, 1, 1, 1],

           [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)

    >>> c = np.unpackbits(a, axis=1, count=-3)

    >>> c

    array([[0, 0, 0, 0, 0],

           [0, 0, 0, 0, 0],

           [0, 0, 0, 1, 0]], dtype=uint8)



    >>> p = np.packbits(b, axis=0)

    >>> np.unpackbits(p, axis=0)

    array([[0, 0, 0, 0, 0, 0, 1, 0],

           [0, 0, 0, 0, 0, 1, 1, 1],

           [0, 0, 0, 1, 0, 1, 1, 1],

           [0, 0, 0, 0, 0, 0, 0, 0],

           [0, 0, 0, 0, 0, 0, 0, 0],

           [0, 0, 0, 0, 0, 0, 0, 0],

           [0, 0, 0, 0, 0, 0, 0, 0],

           [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)

    >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0]))

    True



    """
    return (a,)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.shares_memory)
def shares_memory(a, b, max_work=None):
    """

    shares_memory(a, b, max_work=None)



    Determine if two arrays share memory.



    .. warning::



       This function can be exponentially slow for some inputs, unless

       `max_work` is set to a finite number or ``MAY_SHARE_BOUNDS``.

       If in doubt, use `numpy.may_share_memory` instead.



    Parameters

    ----------

    a, b : ndarray

        Input arrays

    max_work : int, optional

        Effort to spend on solving the overlap problem (maximum number

        of candidate solutions to consider). The following special

        values are recognized:



        max_work=MAY_SHARE_EXACT  (default)

            The problem is solved exactly. In this case, the function returns

            True only if there is an element shared between the arrays. Finding

            the exact solution may take extremely long in some cases.

        max_work=MAY_SHARE_BOUNDS

            Only the memory bounds of a and b are checked.



    Raises

    ------

    numpy.TooHardError

        Exceeded max_work.



    Returns

    -------

    out : bool



    See Also

    --------

    may_share_memory



    Examples

    --------

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

    >>> np.shares_memory(x, np.array([5, 6, 7]))

    False

    >>> np.shares_memory(x[::2], x)

    True

    >>> np.shares_memory(x[::2], x[1::2])

    False



    Checking whether two arrays share memory is NP-complete, and

    runtime may increase exponentially in the number of

    dimensions. Hence, `max_work` should generally be set to a finite

    number, as it is possible to construct examples that take

    extremely long to run:



    >>> from numpy.lib.stride_tricks import as_strided

    >>> x = np.zeros([192163377], dtype=np.int8)

    >>> x1 = as_strided(x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049))

    >>> x2 = as_strided(x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1))

    >>> np.shares_memory(x1, x2, max_work=1000)

    Traceback (most recent call last):

    ...

    numpy.TooHardError: Exceeded max_work



    Running ``np.shares_memory(x1, x2)`` without `max_work` set takes

    around 1 minute for this case. It is possible to find problems

    that take still significantly longer.



    """
    return (a, b)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.may_share_memory)
def may_share_memory(a, b, max_work=None):
    """

    may_share_memory(a, b, max_work=None)



    Determine if two arrays might share memory



    A return of True does not necessarily mean that the two arrays

    share any element.  It just means that they *might*.



    Only the memory bounds of a and b are checked by default.



    Parameters

    ----------

    a, b : ndarray

        Input arrays

    max_work : int, optional

        Effort to spend on solving the overlap problem.  See

        `shares_memory` for details.  Default for ``may_share_memory``

        is to do a bounds check.



    Returns

    -------

    out : bool



    See Also

    --------

    shares_memory



    Examples

    --------

    >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))

    False

    >>> x = np.zeros([3, 4])

    >>> np.may_share_memory(x[:,0], x[:,1])

    True



    """
    return (a, b)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.is_busday)
def is_busday(dates, weekmask=None, holidays=None, busdaycal=None, out=None):
    """

    is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)



    Calculates which of the given dates are valid days, and which are not.



    .. versionadded:: 1.7.0



    Parameters

    ----------

    dates : array_like of datetime64[D]

        The array of dates to process.

    weekmask : str or array_like of bool, optional

        A seven-element array indicating which of Monday through Sunday are

        valid days. May be specified as a length-seven list or array, like

        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string

        like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for

        weekdays, optionally separated by white space. Valid abbreviations

        are: Mon Tue Wed Thu Fri Sat Sun

    holidays : array_like of datetime64[D], optional

        An array of dates to consider as invalid dates.  They may be

        specified in any order, and NaT (not-a-time) dates are ignored.

        This list is saved in a normalized form that is suited for

        fast calculations of valid days.

    busdaycal : busdaycalendar, optional

        A `busdaycalendar` object which specifies the valid days. If this

        parameter is provided, neither weekmask nor holidays may be

        provided.

    out : array of bool, optional

        If provided, this array is filled with the result.



    Returns

    -------

    out : array of bool

        An array with the same shape as ``dates``, containing True for

        each valid day, and False for each invalid day.



    See Also

    --------

    busdaycalendar : An object that specifies a custom set of valid days.

    busday_offset : Applies an offset counted in valid days.

    busday_count : Counts how many valid days are in a half-open date range.



    Examples

    --------

    >>> # The weekdays are Friday, Saturday, and Monday

    ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'],

    ...                 holidays=['2011-07-01', '2011-07-04', '2011-07-17'])

    array([False, False,  True])

    """
    return (dates, weekmask, holidays, out)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.busday_offset)
def busday_offset(dates, offsets, roll=None, weekmask=None, holidays=None,

                  busdaycal=None, out=None):
    """

    busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)



    First adjusts the date to fall on a valid day according to

    the ``roll`` rule, then applies offsets to the given dates

    counted in valid days.



    .. versionadded:: 1.7.0



    Parameters

    ----------

    dates : array_like of datetime64[D]

        The array of dates to process.

    offsets : array_like of int

        The array of offsets, which is broadcast with ``dates``.

    roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional

        How to treat dates that do not fall on a valid day. The default

        is 'raise'.



          * 'raise' means to raise an exception for an invalid day.

          * 'nat' means to return a NaT (not-a-time) for an invalid day.

          * 'forward' and 'following' mean to take the first valid day

            later in time.

          * 'backward' and 'preceding' mean to take the first valid day

            earlier in time.

          * 'modifiedfollowing' means to take the first valid day

            later in time unless it is across a Month boundary, in which

            case to take the first valid day earlier in time.

          * 'modifiedpreceding' means to take the first valid day

            earlier in time unless it is across a Month boundary, in which

            case to take the first valid day later in time.

    weekmask : str or array_like of bool, optional

        A seven-element array indicating which of Monday through Sunday are

        valid days. May be specified as a length-seven list or array, like

        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string

        like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for

        weekdays, optionally separated by white space. Valid abbreviations

        are: Mon Tue Wed Thu Fri Sat Sun

    holidays : array_like of datetime64[D], optional

        An array of dates to consider as invalid dates.  They may be

        specified in any order, and NaT (not-a-time) dates are ignored.

        This list is saved in a normalized form that is suited for

        fast calculations of valid days.

    busdaycal : busdaycalendar, optional

        A `busdaycalendar` object which specifies the valid days. If this

        parameter is provided, neither weekmask nor holidays may be

        provided.

    out : array of datetime64[D], optional

        If provided, this array is filled with the result.



    Returns

    -------

    out : array of datetime64[D]

        An array with a shape from broadcasting ``dates`` and ``offsets``

        together, containing the dates with offsets applied.



    See Also

    --------

    busdaycalendar : An object that specifies a custom set of valid days.

    is_busday : Returns a boolean array indicating valid days.

    busday_count : Counts how many valid days are in a half-open date range.



    Examples

    --------

    >>> # First business day in October 2011 (not accounting for holidays)

    ... np.busday_offset('2011-10', 0, roll='forward')

    numpy.datetime64('2011-10-03')

    >>> # Last business day in February 2012 (not accounting for holidays)

    ... np.busday_offset('2012-03', -1, roll='forward')

    numpy.datetime64('2012-02-29')

    >>> # Third Wednesday in January 2011

    ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed')

    numpy.datetime64('2011-01-19')

    >>> # 2012 Mother's Day in Canada and the U.S.

    ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')

    numpy.datetime64('2012-05-13')



    >>> # First business day on or after a date

    ... np.busday_offset('2011-03-20', 0, roll='forward')

    numpy.datetime64('2011-03-21')

    >>> np.busday_offset('2011-03-22', 0, roll='forward')

    numpy.datetime64('2011-03-22')

    >>> # First business day after a date

    ... np.busday_offset('2011-03-20', 1, roll='backward')

    numpy.datetime64('2011-03-21')

    >>> np.busday_offset('2011-03-22', 1, roll='backward')

    numpy.datetime64('2011-03-23')

    """
    return (dates, offsets, weekmask, holidays, out)


@array_function_from_c_func_and_dispatcher(_multiarray_umath.busday_count)
def busday_count(begindates, enddates, weekmask=None, holidays=None,

                 busdaycal=None, out=None):
    """

    busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)



    Counts the number of valid days between `begindates` and

    `enddates`, not including the day of `enddates`.



    If ``enddates`` specifies a date value that is earlier than the

    corresponding ``begindates`` date value, the count will be negative.



    .. versionadded:: 1.7.0



    Parameters

    ----------

    begindates : array_like of datetime64[D]

        The array of the first dates for counting.

    enddates : array_like of datetime64[D]

        The array of the end dates for counting, which are excluded

        from the count themselves.

    weekmask : str or array_like of bool, optional

        A seven-element array indicating which of Monday through Sunday are

        valid days. May be specified as a length-seven list or array, like

        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string

        like "Mon Tue Wed Thu Fri", made up of 3-character abbreviations for

        weekdays, optionally separated by white space. Valid abbreviations

        are: Mon Tue Wed Thu Fri Sat Sun

    holidays : array_like of datetime64[D], optional

        An array of dates to consider as invalid dates.  They may be

        specified in any order, and NaT (not-a-time) dates are ignored.

        This list is saved in a normalized form that is suited for

        fast calculations of valid days.

    busdaycal : busdaycalendar, optional

        A `busdaycalendar` object which specifies the valid days. If this

        parameter is provided, neither weekmask nor holidays may be

        provided.

    out : array of int, optional

        If provided, this array is filled with the result.



    Returns

    -------

    out : array of int

        An array with a shape from broadcasting ``begindates`` and ``enddates``

        together, containing the number of valid days between

        the begin and end dates.



    See Also

    --------

    busdaycalendar : An object that specifies a custom set of valid days.

    is_busday : Returns a boolean array indicating valid days.

    busday_offset : Applies an offset counted in valid days.



    Examples

    --------

    >>> # Number of weekdays in January 2011

    ... np.busday_count('2011-01', '2011-02')

    21

    >>> # Number of weekdays in 2011

    >>> np.busday_count('2011', '2012')

    260

    >>> # Number of Saturdays in 2011

    ... np.busday_count('2011', '2012', weekmask='Sat')

    53

    """
    return (begindates, enddates, weekmask, holidays, out)


@array_function_from_c_func_and_dispatcher(

    _multiarray_umath.datetime_as_string)
def datetime_as_string(arr, unit=None, timezone=None, casting=None):
    """

    datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind')



    Convert an array of datetimes into an array of strings.



    Parameters

    ----------

    arr : array_like of datetime64

        The array of UTC timestamps to format.

    unit : str

        One of None, 'auto', or a :ref:`datetime unit <arrays.dtypes.dateunits>`.

    timezone : {'naive', 'UTC', 'local'} or tzinfo

        Timezone information to use when displaying the datetime. If 'UTC', end

        with a Z to indicate UTC time. If 'local', convert to the local timezone

        first, and suffix with a +-#### timezone offset. If a tzinfo object,

        then do as with 'local', but use the specified timezone.

    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}

        Casting to allow when changing between datetime units.



    Returns

    -------

    str_arr : ndarray

        An array of strings the same shape as `arr`.



    Examples

    --------

    >>> import pytz

    >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]')

    >>> d

    array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',

           '2002-10-27T07:30'], dtype='datetime64[m]')



    Setting the timezone to UTC shows the same information, but with a Z suffix



    >>> np.datetime_as_string(d, timezone='UTC')

    array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',

           '2002-10-27T07:30Z'], dtype='<U35')



    Note that we picked datetimes that cross a DST boundary. Passing in a

    ``pytz`` timezone object will print the appropriate offset



    >>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern'))

    array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',

           '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39')



    Passing in a unit will change the precision



    >>> np.datetime_as_string(d, unit='h')

    array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],

          dtype='<U32')

    >>> np.datetime_as_string(d, unit='s')

    array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',

           '2002-10-27T07:30:00'], dtype='<U38')



    'casting' can be used to specify whether precision can be changed



    >>> np.datetime_as_string(d, unit='h', casting='safe')

    Traceback (most recent call last):

        ...

    TypeError: Cannot create a datetime string as units 'h' from a NumPy

    datetime with units 'm' according to the rule 'safe'

    """
    return (arr,)