| Server IP : 192.158.238.246 / Your IP : 3.142.53.191 Web Server : LiteSpeed System : Linux uniform.iwebfusion.net 4.18.0-553.27.1.lve.1.el8.x86_64 #1 SMP Wed Nov 20 15:58:00 UTC 2024 x86_64 User : jenniferflocom ( 1321) PHP Version : 8.1.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : OFF | Pkexec : OFF Directory : /opt/cloudlinux/venv/lib/python3.11/site-packages/numpy/lib/__pycache__/ |
Upload File : |
�
��bg�� � �F � d Z ddlZddlZddlmZmZmZmZmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZ ddlmZmZ ddlmZ ddlmZ ddl m Z g d�Z ej ej d �
� � Z ee � � Z! ee
� � Z" ee� � Z#d � Z$d � Z% e e%� � d
� � � Z& e e%� � d� � � Z'e ed � � dde(dfdd�d�� � � � Z) e � � e)� � Z*d%d�Z+ e e+� � d&d�� � Z, e e+� � d&d�� � Z-e ed � � dde(fdd�d�� � � � Z. e � � e.� � Z/d%d�Z0 e e0� � d&d�� � Z1 e e0� � d&d�� � Z2d'd�Z3 e e3� � d(d�� � Z4 d)d �Z5 e e5� � d*d �� � Z6 ed � � d&d �� � Z7 ed � � d+d �� � Z8d%d!�Z9 e e9� � d&d"�� � Z: ed � � d+d#�� � Z; e e9� � d&d$�� � Z<dS ),z- Basic functions for manipulating 2d arrays
� N)�
asanyarray�arange�zeros�
greater_equal�multiply�ones�asarray�where�int8�int16�int32�int64�intp�empty�
promote_types�diagonal�nonzero�indices)�set_array_function_like_doc�
set_module)� overrides)�iinfo)� broadcast_to)�diag�diagflat�eye�fliplr�flipud�tri�triu�tril�vander� histogram2d� mask_indices� tril_indices�tril_indices_from� triu_indices�triu_indices_from�numpy)�modulec � � |t j k r| t j k rt S |t j k r| t j k rt
S |t j k r| t j k rt S t S )z# get small int that fits the range ) �i1�max�minr �i2r �i4r
r )�low�highs �L/opt/cloudlinux/venv/lib64/python3.11/site-packages/numpy/lib/twodim_base.py�_min_intr4 ! sU � � �r�v�~�~�#���-�-�� � �r�v�~�~�#���-�-�� � �r�v�~�~�#���-�-�� � �L� c � � | fS �N� ��ms r3 �_flip_dispatcherr; , � � �
�4�Kr5 c �r � t | � � } | j dk rt d� � �| dd�ddd�f S )ae
Reverse the order of elements along axis 1 (left/right).
For a 2-D array, this flips the entries in each row in the left/right
direction. Columns are preserved, but appear in a different order than
before.
Parameters
----------
m : array_like
Input array, must be at least 2-D.
Returns
-------
f : ndarray
A view of `m` with the columns reversed. Since a view
is returned, this operation is :math:`\mathcal O(1)`.
See Also
--------
flipud : Flip array in the up/down direction.
flip : Flip array in one or more dimensions.
rot90 : Rotate array counterclockwise.
Notes
-----
Equivalent to ``m[:,::-1]`` or ``np.flip(m, axis=1)``.
Requires the array to be at least 2-D.
Examples
--------
>>> A = np.diag([1.,2.,3.])
>>> A
array([[1., 0., 0.],
[0., 2., 0.],
[0., 0., 3.]])
>>> np.fliplr(A)
array([[0., 0., 1.],
[0., 2., 0.],
[3., 0., 0.]])
>>> A = np.random.randn(2,3,5)
>>> np.all(np.fliplr(A) == A[:,::-1,...])
True
� zInput must be >= 2-d.N����r �ndim�
ValueErrorr9 s r3 r r 0 sB � �` �1�
�
�A��v��z�z��0�1�1�1� �Q�Q�Q���"��W�:�r5 c �n � t | � � } | j dk rt d� � �| ddd�df S )ax
Reverse the order of elements along axis 0 (up/down).
For a 2-D array, this flips the entries in each column in the up/down
direction. Rows are preserved, but appear in a different order than before.
Parameters
----------
m : array_like
Input array.
Returns
-------
out : array_like
A view of `m` with the rows reversed. Since a view is
returned, this operation is :math:`\mathcal O(1)`.
See Also
--------
fliplr : Flip array in the left/right direction.
flip : Flip array in one or more dimensions.
rot90 : Rotate array counterclockwise.
Notes
-----
Equivalent to ``m[::-1, ...]`` or ``np.flip(m, axis=0)``.
Requires the array to be at least 1-D.
Examples
--------
>>> A = np.diag([1.0, 2, 3])
>>> A
array([[1., 0., 0.],
[0., 2., 0.],
[0., 0., 3.]])
>>> np.flipud(A)
array([[0., 0., 3.],
[0., 2., 0.],
[1., 0., 0.]])
>>> A = np.random.randn(2,3,5)
>>> np.all(np.flipud(A) == A[::-1,...])
True
>>> np.flipud([1,2])
array([2, 1])
� zInput must be >= 1-d.Nr? .r@ r9 s r3 r r f s> � �d �1�
�
�A��v��z�z��0�1�1�1� �T�T�r�T�3�Y�<�r5 �C)�likec � � |�t || ||||�� � S |�| }t | |f||�� � }||k r|S t j |� � }t j |� � }|dk r|}n| |z }d|d||z
� j |d|dz �< |S )a
Return a 2-D array with ones on the diagonal and zeros elsewhere.
Parameters
----------
N : int
Number of rows in the output.
M : int, optional
Number of columns in the output. If None, defaults to `N`.
k : int, optional
Index of the diagonal: 0 (the default) refers to the main diagonal,
a positive value refers to an upper diagonal, and a negative value
to a lower diagonal.
dtype : data-type, optional
Data-type of the returned array.
order : {'C', 'F'}, optional
Whether the output should be stored in row-major (C-style) or
column-major (Fortran-style) order in memory.
.. versionadded:: 1.14.0
${ARRAY_FUNCTION_LIKE}
.. versionadded:: 1.20.0
Returns
-------
I : ndarray of shape (N,M)
An array where all elements are equal to zero, except for the `k`-th
diagonal, whose values are equal to one.
See Also
--------
identity : (almost) equivalent function
diag : diagonal 2-D array from a 1-D array specified by the user.
Examples
--------
>>> np.eye(2, dtype=int)
array([[1, 0],
[0, 1]])
>>> np.eye(3, k=1)
array([[0., 1., 0.],
[0., 0., 1.],
[0., 0., 0.]])
N)�M�k�dtype�order)rJ rK r rD )�_eye_with_liker �operator�index�flat)�NrH rI rJ rK rF r: �is r3 r r � s� � �b �� �d�A��a�u�E�J�J�J�J��y�
��
�q�!�f�E��/�/�/�A��A�v�v��� ��q���A���q���A��A�v�v�
����R�1�H�� �A�d�q��s�d�G�L���A�a�C��� �Hr5 c � � | fS r7 r8 )�vrI s r3 �_diag_dispatcherrT � r< r5 c �n � t | � � } | j }t |� � dk r[|d t |� � z }t ||f| j � � }|dk r|}n| |z }| |d||z
� j |d|dz �< |S t |� � dk rt | |� � S t d� � �)a�
Extract a diagonal or construct a diagonal array.
See the more detailed documentation for ``numpy.diagonal`` if you use this
function to extract a diagonal and wish to write to the resulting array;
whether it returns a copy or a view depends on what version of numpy you
are using.
Parameters
----------
v : array_like
If `v` is a 2-D array, return a copy of its `k`-th diagonal.
If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
diagonal.
k : int, optional
Diagonal in question. The default is 0. Use `k>0` for diagonals
above the main diagonal, and `k<0` for diagonals below the main
diagonal.
Returns
-------
out : ndarray
The extracted diagonal or constructed diagonal array.
See Also
--------
diagonal : Return specified diagonals.
diagflat : Create a 2-D array with the flattened input as a diagonal.
trace : Sum along diagonals.
triu : Upper triangle of an array.
tril : Lower triangle of an array.
Examples
--------
>>> x = np.arange(9).reshape((3,3))
>>> x
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> np.diag(x)
array([0, 4, 8])
>>> np.diag(x, k=1)
array([1, 5])
>>> np.diag(x, k=-1)
array([3, 7])
>>> np.diag(np.diag(x))
array([[0, 0, 0],
[0, 4, 0],
[0, 0, 8]])
rD r Nr> zInput must be 1- or 2-d.) r �shape�len�absr rJ rO r rB )rS rI �s�n�resrQ s r3 r r � s� � �n �1�
�
�A� ��A�
�1�v�v��{�{�
�a�D��Q���K���Q��F�A�G�$�$�� ��6�6��A�A���q��A�!"��D�Q�q�S�D� ��q�v�!�A�#�v� ��
� �Q���1�����1�~�~� ��3�4�4�4r5 c � � | j }n# t $ r d}Y nw xY wt | � � � � � } t | � � }|t |� � z }t
||f| j � � }|dk r&t d||z
t �� � }||z ||z z }n%t d||z t �� � }|||z
|z z }| |j
|< |s|S ||� � S )a�
Create a two-dimensional array with the flattened input as a diagonal.
Parameters
----------
v : array_like
Input data, which is flattened and set as the `k`-th
diagonal of the output.
k : int, optional
Diagonal to set; 0, the default, corresponds to the "main" diagonal,
a positive (negative) `k` giving the number of the diagonal above
(below) the main.
Returns
-------
out : ndarray
The 2-D output array.
See Also
--------
diag : MATLAB work-alike for 1-D and 2-D arrays.
diagonal : Return specified diagonals.
trace : Sum along diagonals.
Examples
--------
>>> np.diagflat([[1,2], [3,4]])
array([[1, 0, 0, 0],
[0, 2, 0, 0],
[0, 0, 3, 0],
[0, 0, 0, 4]])
>>> np.diagflat([1,2], 1)
array([[0, 1, 0],
[0, 0, 2],
[0, 0, 0]])
Nr �rJ ) �__array_wrap__�AttributeErrorr �ravelrW rX r rJ r r rO )rS rI �wraprY rZ r[ rQ �fis r3 r r 2 s� � �P�� ���� � � � �����������
�
�����A� �A���A� �C��F�F�
�A�
��A����
�
�C� �Q��� �1�a��c�� &� &� &��
�q�S��1��W��� �1�a��c�� &� &� &��
��!��Q�w�Y���C�H�R�L� � ��
� �4��9�9�s �
� �c � � |�t || |||�� � S |�| }t j t | t d| � � �� � t | ||z
t | ||z
� � �� � � � }|� |d�� � }|S )a\
An array with ones at and below the given diagonal and zeros elsewhere.
Parameters
----------
N : int
Number of rows in the array.
M : int, optional
Number of columns in the array.
By default, `M` is taken equal to `N`.
k : int, optional
The sub-diagonal at and below which the array is filled.
`k` = 0 is the main diagonal, while `k` < 0 is below it,
and `k` > 0 is above. The default is 0.
dtype : dtype, optional
Data type of the returned array. The default is float.
${ARRAY_FUNCTION_LIKE}
.. versionadded:: 1.20.0
Returns
-------
tri : ndarray of shape (N, M)
Array with its lower triangle filled with ones and zero elsewhere;
in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.
Examples
--------
>>> np.tri(3, 5, 2, dtype=int)
array([[1, 1, 1, 0, 0],
[1, 1, 1, 1, 0],
[1, 1, 1, 1, 1]])
>>> np.tri(3, 5, -1)
array([[0., 0., 0., 0., 0.],
[1., 0., 0., 0., 0.],
[1., 1., 0., 0., 0.]])
N)rH rI rJ r r] F)�copy)�_tri_with_liker �outerr r4 �astype)rP rH rI rJ rF r: s r3 r r n s� � �T �� �d�A��a�u�=�=�=�=��y�
����F�1�H�Q��N�N� ;� ;� ;� "�A�2�q��s�(�A�2�q�1�u�2E�2E� F� F� F� H� H�A�
����U��#�#�A� �Hr5 c � � | fS r7 r8 )r: rI s r3 �_trilu_dispatcherri � r< r5 c � � t | � � } t | j dd� |t d��}t || t d| j � � � � S )a$
Lower triangle of an array.
Return a copy of an array with elements above the `k`-th diagonal zeroed.
For arrays with ``ndim`` exceeding 2, `tril` will apply to the final two
axes.
Parameters
----------
m : array_like, shape (..., M, N)
Input array.
k : int, optional
Diagonal above which to zero elements. `k = 0` (the default) is the
main diagonal, `k < 0` is below it and `k > 0` is above.
Returns
-------
tril : ndarray, shape (..., M, N)
Lower triangle of `m`, of same shape and data-type as `m`.
See Also
--------
triu : same thing, only for the upper triangle
Examples
--------
>>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 0, 0, 0],
[ 4, 0, 0],
[ 7, 8, 0],
[10, 11, 12]])
>>> np.tril(np.arange(3*4*5).reshape(3, 4, 5))
array([[[ 0, 0, 0, 0, 0],
[ 5, 6, 0, 0, 0],
[10, 11, 12, 0, 0],
[15, 16, 17, 18, 0]],
[[20, 0, 0, 0, 0],
[25, 26, 0, 0, 0],
[30, 31, 32, 0, 0],
[35, 36, 37, 38, 0]],
[[40, 0, 0, 0, 0],
[45, 46, 0, 0, 0],
[50, 51, 52, 0, 0],
[55, 56, 57, 58, 0]]])
���N�rI rJ rD �r r rV �boolr
r rJ �r: rI �masks r3 r! r! � sL � �b �1�
�
�A� ������ ��� .� .� .�D� ��q�%��1�7�+�+� ,� ,�,r5 c � � t | � � } t | j dd� |dz
t d��}t |t d| j � � | � � S )a�
Upper triangle of an array.
Return a copy of an array with the elements below the `k`-th diagonal
zeroed. For arrays with ``ndim`` exceeding 2, `triu` will apply to the
final two axes.
Please refer to the documentation for `tril` for further details.
See Also
--------
tril : lower triangle of an array
Examples
--------
>>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 0, 8, 9],
[ 0, 0, 12]])
>>> np.triu(np.arange(3*4*5).reshape(3, 4, 5))
array([[[ 0, 1, 2, 3, 4],
[ 0, 6, 7, 8, 9],
[ 0, 0, 12, 13, 14],
[ 0, 0, 0, 18, 19]],
[[20, 21, 22, 23, 24],
[ 0, 26, 27, 28, 29],
[ 0, 0, 32, 33, 34],
[ 0, 0, 0, 38, 39]],
[[40, 41, 42, 43, 44],
[ 0, 46, 47, 48, 49],
[ 0, 0, 52, 53, 54],
[ 0, 0, 0, 58, 59]]])
rk NrD rl rm ro s r3 r r � sP � �L �1�
�
�A� ������ ��!��4� 0� 0� 0�D� ��u�Q���(�(�!� ,� ,�,r5 c � � | fS r7 r8 )�xrP �
increasings r3 �_vander_dispatcherru r< r5 Fc �� � t | � � } | j dk rt d� � �|�t | � � }t t | � � |ft | j t � � �� � }|s|dd�ddd�f n|}|dk r d|dd�df< |dk rD| dd�df |dd�dd�f< t j |dd�dd�f |dd�dd�f d�� � |S )ar
Generate a Vandermonde matrix.
The columns of the output matrix are powers of the input vector. The
order of the powers is determined by the `increasing` boolean argument.
Specifically, when `increasing` is False, the `i`-th output column is
the input vector raised element-wise to the power of ``N - i - 1``. Such
a matrix with a geometric progression in each row is named for Alexandre-
Theophile Vandermonde.
Parameters
----------
x : array_like
1-D input array.
N : int, optional
Number of columns in the output. If `N` is not specified, a square
array is returned (``N = len(x)``).
increasing : bool, optional
Order of the powers of the columns. If True, the powers increase
from left to right, if False (the default) they are reversed.
.. versionadded:: 1.9.0
Returns
-------
out : ndarray
Vandermonde matrix. If `increasing` is False, the first column is
``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is
True, the columns are ``x^0, x^1, ..., x^(N-1)``.
See Also
--------
polynomial.polynomial.polyvander
Examples
--------
>>> x = np.array([1, 2, 3, 5])
>>> N = 3
>>> np.vander(x, N)
array([[ 1, 1, 1],
[ 4, 2, 1],
[ 9, 3, 1],
[25, 5, 1]])
>>> np.column_stack([x**(N-1-i) for i in range(N)])
array([[ 1, 1, 1],
[ 4, 2, 1],
[ 9, 3, 1],
[25, 5, 1]])
>>> x = np.array([1, 2, 3, 5])
>>> np.vander(x)
array([[ 1, 1, 1, 1],
[ 8, 4, 2, 1],
[ 27, 9, 3, 1],
[125, 25, 5, 1]])
>>> np.vander(x, increasing=True)
array([[ 1, 1, 1, 1],
[ 1, 2, 4, 8],
[ 1, 3, 9, 27],
[ 1, 5, 25, 125]])
The determinant of a square Vandermonde matrix is the product
of the differences between the values of the input vector:
>>> np.linalg.det(np.vander(x))
48.000000000000043 # may vary
>>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
48
rD z.x must be a one-dimensional array or sequence.Nr] r? r )�out�axis)
r rA rB rW r r rJ �intr �
accumulate)rs rP rt rS �tmps r3 r" r" s � �R ��
�
�A��v��{�{��I�J�J�J��y� ��F�F��
�s�1�v�v�q�k� �q�w��!<�!<�=�=�=�A� &�
-�!�A�A�A�t�t��t�G�*�*�A�C��1�u�u���A�A�A�q�D� ��1�u�u��q�q�q�$�w�Z��A�A�A�q�r�r�E�
���C����1�2�2��J�C����1�2�2��J�Q�?�?�?�?� �Hr5 c # � K � | V � |V � t |� � }n# t $ r d}Y nw xY w|dk r |E d {V �� n|V � |V � d S )NrD r> )rW � TypeError)rs �y�bins�range�density�weightsrP s r3 �_histogram2d_dispatcherr� q s� � � � �
�G�G�G�
�G�G�G�� ��I�I���� � � � �
���������A�v�v�����������
�
�
�
�M�M�M�M�Ms � � +�+�
c �> � ddl m} t | � � t |� � k rt d� � � t |� � }n# t $ r d}Y nw xY w|dk r|dk rt |� � x}} || g} || |g||||� � \ }
} |
| d | d fS )a#
Compute the bi-dimensional histogram of two data samples.
Parameters
----------
x : array_like, shape (N,)
An array containing the x coordinates of the points to be
histogrammed.
y : array_like, shape (N,)
An array containing the y coordinates of the points to be
histogrammed.
bins : int or array_like or [int, int] or [array, array], optional
The bin specification:
* If int, the number of bins for the two dimensions (nx=ny=bins).
* If array_like, the bin edges for the two dimensions
(x_edges=y_edges=bins).
* If [int, int], the number of bins in each dimension
(nx, ny = bins).
* If [array, array], the bin edges in each dimension
(x_edges, y_edges = bins).
* A combination [int, array] or [array, int], where int
is the number of bins and array is the bin edges.
range : array_like, shape(2,2), optional
The leftmost and rightmost edges of the bins along each dimension
(if not specified explicitly in the `bins` parameters):
``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
will be considered outliers and not tallied in the histogram.
density : bool, optional
If False, the default, returns the number of samples in each bin.
If True, returns the probability *density* function at the bin,
``bin_count / sample_count / bin_area``.
weights : array_like, shape(N,), optional
An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
Weights are normalized to 1 if `density` is True. If `density` is
False, the values of the returned histogram are equal to the sum of
the weights belonging to the samples falling into each bin.
Returns
-------
H : ndarray, shape(nx, ny)
The bi-dimensional histogram of samples `x` and `y`. Values in `x`
are histogrammed along the first dimension and values in `y` are
histogrammed along the second dimension.
xedges : ndarray, shape(nx+1,)
The bin edges along the first dimension.
yedges : ndarray, shape(ny+1,)
The bin edges along the second dimension.
See Also
--------
histogram : 1D histogram
histogramdd : Multidimensional histogram
Notes
-----
When `density` is True, then the returned histogram is the sample
density, defined such that the sum over bins of the product
``bin_value * bin_area`` is 1.
Please note that the histogram does not follow the Cartesian convention
where `x` values are on the abscissa and `y` values on the ordinate
axis. Rather, `x` is histogrammed along the first dimension of the
array (vertical), and `y` along the second dimension of the array
(horizontal). This ensures compatibility with `histogramdd`.
Examples
--------
>>> from matplotlib.image import NonUniformImage
>>> import matplotlib.pyplot as plt
Construct a 2-D histogram with variable bin width. First define the bin
edges:
>>> xedges = [0, 1, 3, 5]
>>> yedges = [0, 2, 3, 4, 6]
Next we create a histogram H with random bin content:
>>> x = np.random.normal(2, 1, 100)
>>> y = np.random.normal(1, 1, 100)
>>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
>>> # Histogram does not follow Cartesian convention (see Notes),
>>> # therefore transpose H for visualization purposes.
>>> H = H.T
:func:`imshow <matplotlib.pyplot.imshow>` can only display square bins:
>>> fig = plt.figure(figsize=(7, 3))
>>> ax = fig.add_subplot(131, title='imshow: square bins')
>>> plt.imshow(H, interpolation='nearest', origin='lower',
... extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
<matplotlib.image.AxesImage object at 0x...>
:func:`pcolormesh <matplotlib.pyplot.pcolormesh>` can display actual edges:
>>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
... aspect='equal')
>>> X, Y = np.meshgrid(xedges, yedges)
>>> ax.pcolormesh(X, Y, H)
<matplotlib.collections.QuadMesh object at 0x...>
:class:`NonUniformImage <matplotlib.image.NonUniformImage>` can be used to
display actual bin edges with interpolation:
>>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
>>> im = NonUniformImage(ax, interpolation='bilinear')
>>> xcenters = (xedges[:-1] + xedges[1:]) / 2
>>> ycenters = (yedges[:-1] + yedges[1:]) / 2
>>> im.set_data(xcenters, ycenters, H)
>>> ax.add_image(im)
>>> plt.show()
It is also possible to construct a 2-D histogram without specifying bin
edges:
>>> # Generate non-symmetric test data
>>> n = 10000
>>> x = np.linspace(1, 100, n)
>>> y = 2*np.log(x) + np.random.rand(n) - 0.5
>>> # Compute 2d histogram. Note the order of x/y and xedges/yedges
>>> H, yedges, xedges = np.histogram2d(y, x, bins=20)
Now we can plot the histogram using
:func:`pcolormesh <matplotlib.pyplot.pcolormesh>`, and a
:func:`hexbin <matplotlib.pyplot.hexbin>` for comparison.
>>> # Plot histogram using pcolormesh
>>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True)
>>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow')
>>> ax1.plot(x, 2*np.log(x), 'k-')
>>> ax1.set_xlim(x.min(), x.max())
>>> ax1.set_ylim(y.min(), y.max())
>>> ax1.set_xlabel('x')
>>> ax1.set_ylabel('y')
>>> ax1.set_title('histogram2d')
>>> ax1.grid()
>>> # Create hexbin plot for comparison
>>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow')
>>> ax2.plot(x, 2*np.log(x), 'k-')
>>> ax2.set_title('hexbin')
>>> ax2.set_xlim(x.min(), x.max())
>>> ax2.set_xlabel('x')
>>> ax2.grid()
>>> plt.show()
r )� histogramddz"x and y must have the same length.rD r> )r) r� rW rB r} r ) rs r~ r r� r� r� r� rP �xedges�yedges�hist�edgess r3 r# r# � s� � �p "�!�!�!�!�!�
�1�v�v��Q������=�>�>�>�� ��I�I���� � � � �
�������� �A�v�v�!�q�&�&�!�$�-�-�'����� �� �+�q�!�f�d�E�7�G�D�D�K�D�%� ��q��5��8� #�#s �A � A�Ac �n � t | | ft � � } |||� � }t |dk � � S )a�
Return the indices to access (n, n) arrays, given a masking function.
Assume `mask_func` is a function that, for a square array a of size
``(n, n)`` with a possible offset argument `k`, when called as
``mask_func(a, k)`` returns a new array with zeros in certain locations
(functions like `triu` or `tril` do precisely this). Then this function
returns the indices where the non-zero values would be located.
Parameters
----------
n : int
The returned indices will be valid to access arrays of shape (n, n).
mask_func : callable
A function whose call signature is similar to that of `triu`, `tril`.
That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`.
`k` is an optional argument to the function.
k : scalar
An optional argument which is passed through to `mask_func`. Functions
like `triu`, `tril` take a second argument that is interpreted as an
offset.
Returns
-------
indices : tuple of arrays.
The `n` arrays of indices corresponding to the locations where
``mask_func(np.ones((n, n)), k)`` is True.
See Also
--------
triu, tril, triu_indices, tril_indices
Notes
-----
.. versionadded:: 1.4.0
Examples
--------
These are the indices that would allow you to access the upper triangular
part of any 3x3 array:
>>> iu = np.mask_indices(3, np.triu)
For example, if `a` is a 3x3 array:
>>> a = np.arange(9).reshape(3, 3)
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> a[iu]
array([0, 1, 2, 4, 5, 8])
An offset can be passed also to the masking function. This gets us the
indices starting on the first diagonal right of the main one:
>>> iu1 = np.mask_indices(3, np.triu, 1)
with which we now extract only three elements:
>>> a[iu1]
array([1, 2, 5])
r )r ry r )rZ � mask_funcrI r: �as r3 r$ r$ , s7 � �D
�a��V�S���A�� �!�Q���A� �1��6�?�?�r5 c � �� t | ||t �� � �t �fd�t �j d�� � D � � � � S )ap
Return the indices for the lower-triangle of an (n, m) array.
Parameters
----------
n : int
The row dimension of the arrays for which the returned
indices will be valid.
k : int, optional
Diagonal offset (see `tril` for details).
m : int, optional
.. versionadded:: 1.9.0
The column dimension of the arrays for which the returned
arrays will be valid.
By default `m` is taken equal to `n`.
Returns
-------
inds : tuple of arrays
The indices for the triangle. The returned tuple contains two arrays,
each with the indices along one dimension of the array.
See also
--------
triu_indices : similar function, for upper-triangular.
mask_indices : generic function accepting an arbitrary mask function.
tril, triu
Notes
-----
.. versionadded:: 1.4.0
Examples
--------
Compute two different sets of indices to access 4x4 arrays, one for the
lower triangular part starting at the main diagonal, and one starting two
diagonals further right:
>>> il1 = np.tril_indices(4)
>>> il2 = np.tril_indices(4, 2)
Here is how they can be used with a sample array:
>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
Both for indexing:
>>> a[il1]
array([ 0, 4, 5, ..., 13, 14, 15])
And for assigning values:
>>> a[il1] = -1
>>> a
array([[-1, 1, 2, 3],
[-1, -1, 6, 7],
[-1, -1, -1, 11],
[-1, -1, -1, -1]])
These cover almost the whole array (two diagonals right of the main one):
>>> a[il2] = -10
>>> a
array([[-10, -10, -10, 3],
[-10, -10, -10, -10],
[-10, -10, -10, -10],
[-10, -10, -10, -10]])
rl c 3 �N �K � | ] }t |�j � � � V � � d S r7 �r rV ��.0�inds�tri_s �r3 � <genexpr>z tril_indices.<locals>.<genexpr>� �H �� � � � ?� ?�� �d�D�J�/�/��5� ?� ?� ?� ?� ?� ?r5 T��sparse�r rn �tupler rV �rZ rI r: r� s @r3 r% r% s sc �� �\ �q�!�q�� %� %� %�D� � ?� ?� ?� ?� $�T�Z�� =� =� =�?� ?� ?� ?� ?� ?r5 c � � | fS r7 r8 ��arrrI s r3 � _trilu_indices_form_dispatcherr� � s � � �6�Mr5 c � � | j dk rt d� � �t | j d || j d �� � S )aI
Return the indices for the lower-triangle of arr.
See `tril_indices` for full details.
Parameters
----------
arr : array_like
The indices will be valid for square arrays whose dimensions are
the same as arr.
k : int, optional
Diagonal offset (see `tril` for details).
Examples
--------
Create a 4 by 4 array.
>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
Pass the array to get the indices of the lower triangular elements.
>>> trili = np.tril_indices_from(a)
>>> trili
(array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3]))
>>> a[trili]
array([ 0, 4, 5, 8, 9, 10, 12, 13, 14, 15])
This is syntactic sugar for tril_indices().
>>> np.tril_indices(a.shape[0])
(array([0, 1, 1, 2, 2, 2, 3, 3, 3, 3]), array([0, 0, 1, 0, 1, 2, 0, 1, 2, 3]))
Use the `k` parameter to return the indices for the lower triangular array
up to the k-th diagonal.
>>> trili1 = np.tril_indices_from(a, k=1)
>>> a[trili1]
array([ 0, 1, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15])
See Also
--------
tril_indices, tril, triu_indices_from
Notes
-----
.. versionadded:: 1.4.0
r> �input array must be 2-drk r? �rI r: )rA rB r% rV r� s r3 r& r& � s@ � �r �x�1�}�}��2�3�3�3� �� �"�
��c�i��m� <� <� <�<r5 c � �� t | ||dz
t �� � �t �fd�t �j d�� � D � � � � S )a�
Return the indices for the upper-triangle of an (n, m) array.
Parameters
----------
n : int
The size of the arrays for which the returned indices will
be valid.
k : int, optional
Diagonal offset (see `triu` for details).
m : int, optional
.. versionadded:: 1.9.0
The column dimension of the arrays for which the returned
arrays will be valid.
By default `m` is taken equal to `n`.
Returns
-------
inds : tuple, shape(2) of ndarrays, shape(`n`)
The indices for the triangle. The returned tuple contains two arrays,
each with the indices along one dimension of the array. Can be used
to slice a ndarray of shape(`n`, `n`).
See also
--------
tril_indices : similar function, for lower-triangular.
mask_indices : generic function accepting an arbitrary mask function.
triu, tril
Notes
-----
.. versionadded:: 1.4.0
Examples
--------
Compute two different sets of indices to access 4x4 arrays, one for the
upper triangular part starting at the main diagonal, and one starting two
diagonals further right:
>>> iu1 = np.triu_indices(4)
>>> iu2 = np.triu_indices(4, 2)
Here is how they can be used with a sample array:
>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
Both for indexing:
>>> a[iu1]
array([ 0, 1, 2, ..., 10, 11, 15])
And for assigning values:
>>> a[iu1] = -1
>>> a
array([[-1, -1, -1, -1],
[ 4, -1, -1, -1],
[ 8, 9, -1, -1],
[12, 13, 14, -1]])
These cover only a small part of the whole array (two diagonals right
of the main one):
>>> a[iu2] = -10
>>> a
array([[ -1, -1, -10, -10],
[ 4, -1, -1, -10],
[ 8, 9, -1, -1],
[ 12, 13, 14, -1]])
rD rl c 3 �N �K � | ] }t |�j � � � V � � d S r7 r� r� s �r3 r� z triu_indices.<locals>.<genexpr>[ r� r5 Tr� r� r� s @r3 r' r' sj �� �`
��1��A��T� *� *� *� *�D� � ?� ?� ?� ?� $�T�Z�� =� =� =�?� ?� ?� ?� ?� ?r5 c � � | j dk rt d� � �t | j d || j d �� � S )a�
Return the indices for the upper-triangle of arr.
See `triu_indices` for full details.
Parameters
----------
arr : ndarray, shape(N, N)
The indices will be valid for square arrays.
k : int, optional
Diagonal offset (see `triu` for details).
Returns
-------
triu_indices_from : tuple, shape(2) of ndarray, shape(N)
Indices for the upper-triangle of `arr`.
Examples
--------
Create a 4 by 4 array.
>>> a = np.arange(16).reshape(4, 4)
>>> a
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
Pass the array to get the indices of the upper triangular elements.
>>> triui = np.triu_indices_from(a)
>>> triui
(array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3]))
>>> a[triui]
array([ 0, 1, 2, 3, 5, 6, 7, 10, 11, 15])
This is syntactic sugar for triu_indices().
>>> np.triu_indices(a.shape[0])
(array([0, 0, 0, 0, 1, 1, 1, 2, 2, 3]), array([0, 1, 2, 3, 1, 2, 3, 2, 3, 3]))
Use the `k` parameter to return the indices for the upper triangular array
from the k-th diagonal.
>>> triuim1 = np.triu_indices_from(a, k=1)
>>> a[triuim1]
array([ 1, 2, 3, 6, 7, 11])
See Also
--------
triu_indices, triu, tril_indices_from
Notes
-----
.. versionadded:: 1.4.0
r> r� rk r? r� )rA rB r' rV r� s r3 r( r( _ s@ � �| �x�1�}�}��2�3�3�3� �� �"�
��c�i��m� <� <� <�<r5 r7 )r )NN)NF)NNNN)r� NNN)r N)=�__doc__� functoolsrM �numpy.core.numericr r r r r r r r
r r r
r r r r r r r �numpy.core.overridesr r �
numpy.corer r �numpy.lib.stride_tricksr �__all__�partial�array_function_dispatchr, r/ r0 r4 r; r r �floatr rL rT r r r re ri r! r ru r" r� r# r$ r% r� r& r' r( r8 r5 r3 �<module>r� se ��� � � � � � ����� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �
I� H� H� H� H� H� H� H� � � � � � � � � � � � � 0� 0� 0� 0� 0� 0� @� @� @�� ,�)�+�
�%�g�7� 7� 7� � �U�4�[�[��
�U�5�\�\��
�U�5�\�\��� � �� � � ��)�*�*�2� 2� +�*�2�j ��)�*�*�4� 4� +�*�4�n � ��G���
�Q�e�3� @
�� @
� @
� @
� @
� �� � �@
�F +�(�(�*�*�3�/�/��� � � � ��)�*�*�D5� D5� D5� +�*�D5�N ��)�*�*�8� 8� 8� +�*�8�v � ��G���
�Q�e� 4
�T� 4
� 4
� 4
� 4
� �� � �4
�n +�(�(�*�*�3�/�/��� � � � ��*�+�+�3-� 3-� 3-� ,�+�3-�l ��*�+�+�(-� (-� (-� ,�+�(-�V� � � �
��+�,�,�W
� W
� W
� -�,�W
�t BF�$(�� � � �$ ��0�1�1�e$� e$� e$� 2�1�e$�P ��G���C� C� C� ��C�L ��G���P?� P?� P?� ��P?�f� � � � ��7�8�8�:=� :=� :=� 9�8�:=�z ��G���R?� R?� R?� ��R?�j ��7�8�8�?=� ?=� ?=� 9�8�?=� ?=� ?=r5