byp4a55 professor6T9

Linux premium264.web-hosting.com 4.18.0-553.45.1.lve.el8.x86_64 #1 SMP Wed Mar 26 12:08:09 UTC 2025 x86_64
LiteSpeed
69.57.162.12

multiarray.cpython-311.pyc

�

������h!�����������������������������d�Z�ddlZddlmZ�ddlmZ�ddlT�ddlmZmZmZmZm	Z	m
Z
mZmZm
Z
mZmZmZmZmZ�g�d�Zd	e	_��������d	e_��������d
e_��������d
e_��������d
e_��������d
e_��������d
e_��������d
e_��������d
e_��������d
e_��������d
e_��������d
e_��������d
e_��������d
e _��������d
e!_��������d
e"_��������d
e#_��������d
e$_��������d
e%_��������d
e&_��������d
e'_��������d
e(_��������d
e)_��������d
e_��������d
e_��������d
e_���������ej*��������ej+��������d
dd�
������������Z,�e,ej-��������������������d'd���������������Z-�e,ej.��������������������d(ddd�d���������������Z.�e,ej/��������������������d����������������Z/�e,ej0��������������������d(d���������������Z0�e,ej1��������������������d)d���������������Z1�e,ej2��������������������d)d���������������Z2�e,ej3��������������������d����������������Z3�e,ej4��������������������d����������������Z4�e,ej5��������������������d)d���������������Z5�e,ej6��������������������d����������������Z6�e,ej7��������������������d(d���������������Z7�e,ej8��������������������d(d���������������Z8�e,ej9��������������������d(d���������������Z9�e,ej:��������������������d(d���������������Z:�e,ej;��������������������d����������������Z;�e,ej<��������������������d*d���������������Z<�e,ej=��������������������d+d ���������������Z=�e,ej>��������������������d)d!���������������Z>�e,ej$��������������������d)d"���������������Z$�e,ej?��������������������d'd#���������������Z?�e,ej@��������������������	�	�d,d$���������������Z@�e,ejA��������������������	�	�d'd%���������������ZA�e,ejB��������������������d-d&���������������ZBdS�).a��
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.

�����N����)�	overrides)�_multiarray_umath)�*)�fastCopyAndTranspose�	_flagdict�from_dlpack�_place�_reconstruct�_vec_string�
_ARRAY_API�
_monotonicity�_get_ndarray_c_version�_get_madvise_hugepage�_set_madvise_hugepage�_get_promotion_state�_set_promotion_state�_using_numpy2_behavior)_r
����
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�WRAPr���r	���r
���r���r���r����
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�dot�dragon4_positional�dragon4_scientific�dtype�empty�
empty_like�error�flagsobj�flatiter�format_longfloat�
frombuffer�fromfile�fromiter�
fromstring�get_handler_name�get_handler_version�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�zerosr���r���r���znumpy.core.multiarray�numpyTF)�module�docs_from_dispatcher�verifyc�����������������������|�fS�)a	��
    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]])

��)�	prototyper>����order�subok�shapes���     �L/opt/cloudlinux/venv/lib64/python3.11/site-packages/numpy/core/multiarray.pyr@���r@���U���s
������B�
�<������)r>����castingc�����������������R�����|�$t����������|�������������}�|����������������������|�������������|�S�)a���
    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)

)�list�append)�arrays�axis�outr>���rv���s���     rt���r3���r3�������s,������|����f�����
�
�c�����Mru���c������������������
�����|�|fS�)a���
    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.]])

ro�����a�bs���  rt���rK���rK�������s������r�
�q�6�Mru���c�����������������������|�||fS�)a���
    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]])
    ro���)�	condition�x�ys���   rt���rh���rh���Z��s������P�
�q�!��ru���c������������������6�����t����������|�t����������������������r|�S�|�fS�)a
��
    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])

)�
isinstance�tuple)�keysr{���s���  rt���rO���rO������s#������X��$���������w�ru���c�����������������������|�fS�)a��
    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.

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

ro���)�from_�torv���s���   rt���r1���r1������s������`�
�8�Oru���c�����������������������|�fS�)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')

ro���)r���s��� rt���rR���rR���j��s������`�
�4�Kru���c������������������������|�S�)a���
    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 scalar, 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')

ro���)�arrays_and_dtypess��� rt���r[���r[������s������J��ru���c�����������������������|�||fS�)aK
��
    dot(a, b, out=None)

Dot product of two arrays. Specifically,

- If both `a` and `b` are 1-D arrays, it is inner product of vectors
      (without complex conjugation).

- If both `a` and `b` are 2-D arrays, it is matrix multiplication,
      but using :func:`matmul` or ``a @ b`` is preferred.

- If either `a` or `b` is 0-D (scalar), it is equivalent to
      :func:`multiply` and using ``numpy.multiply(a, b)`` or ``a * b`` is
      preferred.

- If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
      the last axis of `a` and `b`.

- If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a
      sum product over the last axis of `a` and the second-to-last axis of
      `b`::

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

It uses an optimized BLAS library when possible (see `numpy.linalg`).

Parameters
    ----------
    a : array_like
        First argument.
    b : array_like
        Second argument.
    out : ndarray, optional
        Output argument. This must have the exact kind that would be returned
        if it was not used. In particular, it must have the right type, must be
        C-contiguous, and its dtype must be the dtype that would be returned
        for `dot(a,b)`. This is a performance feature. Therefore, if these
        conditions are not met, an exception is raised, instead of attempting
        to be flexible.

Returns
    -------
    output : ndarray
        Returns the dot product of `a` and `b`.  If `a` and `b` are both
        scalars or both 1-D arrays then a scalar is returned; otherwise
        an array is returned.
        If `out` is given, then it is returned.

Raises
    ------
    ValueError
        If the last dimension of `a` is not the same size as
        the second-to-last dimension of `b`.

See Also
    --------
    vdot : Complex-conjugating dot product.
    tensordot : Sum products over arbitrary axes.
    einsum : Einstein summation convention.
    matmul : '@' operator as method with out parameter.
    linalg.multi_dot : Chained dot product.

Examples
    --------
    >>> np.dot(3, 4)
    12

Neither argument is complex-conjugated:

>>> np.dot([2j, 3j], [2j, 3j])
    (-13+0j)

For 2-D arrays it is the matrix product:

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

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

ro���)r���r����r|���s���   rt���r;���r;������s������t�
�q�#�;�ru���c������������������
�����|�|fS�)a���
    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

ro���r~���s���  rt���rg���rg���B��s������n�
�q�6�Mru���c������������������
�����|�|fS�)a���
    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])

ro���)r�����weights�	minlengths���   rt���r,���r,���|��s������T�
�w�<�ru���c�����������������������|�S�)a���
    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
    --------
    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

ro���r����s���   rt���rQ���rQ���q��s������L�
�q�6�Mru���c�����������������������|�|||fS�)a���
    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])
    ro���)�dates�weekmask�holidays�	busdaycalr|���s���     rt���rN���rN������s������f�
�8�X�s�+�+ru���c�����������������������|�||||fS�)a
��
    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')
    ro���)r�����offsets�rollr����r����r����r|���s���       rt���r/���r/������s������v�
�7�H�h��4�4ru���c�����������������������|�||||fS�)a�	��
    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
    ro���)�
begindates�enddatesr����r����r����r|���s���      rt���r.���r.���.��s������B�
��(�H�c�:�:ru���c�����������������������|�fS�)a�	��
    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'
    ro���)�arr�unit�timezonerv���s���    rt���r9���r9���r��s������B�
�6�Mru���)NNNN)NN)N)Nr����)NNr����)NNNNN)NNN)C�__doc__�	functools��r���r���r���r���r	���r
���r���r���r
���r���r���r���r���r���r���r����__all__�
__module__r\���r&���r'���r(���r)���r*���r+���r:���r?���rE���rF���rG����
frompyfuncrH����	geterrobjrQ���rU���rX���r_����	seterrobjri����partial�array_function_from_dispatcher�)array_function_from_c_func_and_dispatcherr@���r3���rK���rh���rO���r1���rR���r[���r;���rg���r,���rZ���rf���r4���rY���rW���re���rb���rN���r/���r.���r9���ro���ru���rt����<module>r�������s����������������������������������������� �� �� �� ����������������������������������������������������������������N��N��N��2�2����+�����!�����������������
���&�����#����"�
��������
������������
����
����	���%�����!����"�
���$�����	�������")�����")�����$+����!�
�->�I�,=�
�,���e�-=��-=��-=��)�
�+�*�+<�+G�H�H�@��@��@��I�H�@�F�+�*�+<�+H�I�I�a�d�D��a��a��a��a��J�I�a�H�+�*�+<�+B�C�C�X��X��D�C�X�v�+�*�+<�+B�C�C�G��G��G��D�C�G�T�+�*�+<�+D�E�E�N��N��N��F�E�N�b�+�*�+<�+E�F�F�o��o��o��G�F�o�d�+�*�+<�+L�M�M�/��/��N�M�/�d�+�*�+<�+H�I�I�D��D��J�I�D�N�+�*�+<�+@�A�A�Y��Y��Y��B�A�Y�x�+�*�+<�+A�B�B�6��6��C�B�6�r�+�*�+<�+E�F�F�I��I��I��G�F�I�X�+�*�+<�+N�O�O�9��9��9��P�O�9�x�+�*�+<�+J�K�K�.��.��.��L�K�.�b�+�*�+<�+C�D�D�/��/��/��E�D�/�d�+�*�+<�+D�E�E�)��)��F�E�)�X�+�*�+<�+E�F�F�6��6��6��G�F�6�r�+�*�+<�+G�H�H�P��P��P��I�H�P�f�+�*�+<�+J�K�K�G��G��G��L�K�G�T�+�*�+<�+M�N�N�%��%��%��O�N�%�P�+�*�+<�+F�G�G�2,��2,��2,��H�G�2,�j�+�*�+<�+J�K�K�EI�&*�Z5��Z5��Z5��L�K�Z5�z�+�*�+<�+I�J�J�?C�%)�@;��@;��@;��K�J�@;�F�+�*��(�*��*�?��?��?�*��*�?��?��?ru���

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	0755	2025-05-15 05:02:35
..	dir	-	root/root	0755	2025-05-15 05:01:00
__init__.cpython-311.pyc	application/octet-stream	5.76 KB	root/root	0644	2025-05-15 05:02:35
_add_newdocs.cpython-311.pyc	application/octet-stream	201.15 KB	root/root	0644	2025-05-15 05:02:35
_add_newdocs_scalars.cpython-311.pyc	application/octet-stream	13.57 KB	root/root	0644	2025-05-15 05:02:35
_asarray.cpython-311.pyc	application/octet-stream	4.55 KB	root/root	0644	2025-05-15 05:02:35
_dtype.cpython-311.pyc	application/octet-stream	13.5 KB	root/root	0644	2025-05-15 05:02:35
_dtype_ctypes.cpython-311.pyc	application/octet-stream	5.17 KB	root/root	0644	2025-05-15 05:02:35
_exceptions.cpython-311.pyc	application/octet-stream	9.2 KB	root/root	0644	2025-05-15 05:02:35
_internal.cpython-311.pyc	application/octet-stream	37.17 KB	root/root	0644	2025-05-15 05:02:35
_machar.cpython-311.pyc	application/octet-stream	12.41 KB	root/root	0644	2025-05-15 05:02:35
_methods.cpython-311.pyc	application/octet-stream	11.42 KB	root/root	0644	2025-05-15 05:02:35
_string_helpers.cpython-311.pyc	application/octet-stream	3.5 KB	root/root	0644	2025-05-15 05:02:35
_type_aliases.cpython-311.pyc	application/octet-stream	8.97 KB	root/root	0644	2025-05-15 05:02:35
_ufunc_config.cpython-311.pyc	application/octet-stream	17.08 KB	root/root	0644	2025-05-15 05:02:35
arrayprint.cpython-311.pyc	application/octet-stream	74.87 KB	root/root	0644	2025-05-15 05:02:35
cversions.cpython-311.pyc	application/octet-stream	747 B	root/root	0644	2025-04-17 01:10:58
defchararray.cpython-311.pyc	application/octet-stream	86.34 KB	root/root	0644	2025-05-15 05:02:35
einsumfunc.cpython-311.pyc	application/octet-stream	53.66 KB	root/root	0644	2025-05-15 05:02:35
fromnumeric.cpython-311.pyc	application/octet-stream	135.15 KB	root/root	0644	2025-05-15 05:02:35
function_base.cpython-311.pyc	application/octet-stream	21.75 KB	root/root	0644	2025-05-15 05:02:35
generate_numpy_api.cpython-311.pyc	application/octet-stream	9.25 KB	root/root	0644	2025-04-17 01:10:58
getlimits.cpython-311.pyc	application/octet-stream	29.3 KB	root/root	0644	2025-05-15 05:02:35
memmap.cpython-311.pyc	application/octet-stream	13.2 KB	root/root	0644	2025-05-15 05:02:35
multiarray.cpython-311.pyc	application/octet-stream	56.09 KB	root/root	0644	2025-05-15 05:02:35
numeric.cpython-311.pyc	application/octet-stream	88.53 KB	root/root	0644	2025-05-15 05:02:35
numerictypes.cpython-311.pyc	application/octet-stream	21.38 KB	root/root	0644	2025-05-15 05:02:35
overrides.cpython-311.pyc	application/octet-stream	7.78 KB	root/root	0644	2025-05-15 05:02:35
records.cpython-311.pyc	application/octet-stream	43.07 KB	root/root	0644	2025-05-15 05:02:35
setup.cpython-311.pyc	application/octet-stream	56.76 KB	root/root	0644	2025-04-17 01:10:58
setup_common.cpython-311.pyc	application/octet-stream	15.61 KB	root/root	0644	2025-04-17 01:10:58
shape_base.cpython-311.pyc	application/octet-stream	33.27 KB	root/root	0644	2025-05-15 05:02:35
umath.cpython-311.pyc	application/octet-stream	1.77 KB	root/root	0644	2025-05-15 05:02:35
umath_tests.cpython-311.pyc	application/octet-stream	644 B	root/root	0644	2025-04-17 01:10:58

Team Anon Force

https://t.me/Professor6T9x