403Webshell
Server IP : 93.86.61.54  /  Your IP : 216.73.216.156
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/scipy/sparse/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/scipy/sparse/__pycache__/_base.cpython-310.pyc
o

��EbF��@s�dZddlmZddlZddlmZmZmZm	Z	m
Z
mZmZm
Z
mZgd�ZGdd�de�ZGd	d
�d
e�ZGdd�de�Zid
ddg�dddg�dddg�dddg�dddg�dddg�dddg�d d!d"g�d#d$d%g�d&d'd(g�d)d*d+g�d,d-d.g�d/d0d1g�d2d3d4g�d5d6d7g�d8d9d:g�d;d<d=g�d>d?gd@dAgdBdCgdD��Zeejejejejejejejejejejej ej!ej"ej#ej$ej%ej&ej'g�Z(dEZ)GdFdG�dG�Z*dHdI�Z+e+Z,dS)JzBase class for sparse matrices�)�warnN�)	�asmatrix�check_reshape_kwargs�check_shape�
get_sum_dtype�isdense�	isintlike�isscalarlike�matrix�validateaxis)�spmatrix�
isspmatrix�issparse�
SparseWarning�SparseEfficiencyWarningc@�eZdZdS)rN��__name__�
__module__�__qualname__�rr�4/usr/lib/python3/dist-packages/scipy/sparse/_base.pyr�rc@r)�SparseFormatWarningNrrrrrrrrc@r)rNrrrrrrrr�csczCompressed Sparse Column�csrzCompressed Sparse Row�dok�zDictionary Of Keys�lil�z
List of Lists�dod�zDictionary of Dictionaries�sss�zSymmetric Sparse Skyline�coo��
COOrdinate�lba�zLinpack BAnded�egd�z#Ellpack-itpack Generalized Diagonal�dia�	�DIAgonal�bsr�
zBlock Sparse Row�msr�zModified compressed Sparse Row�bsc�zBlock Sparse Column�msc�
z!Modified compressed Sparse Column�ssk�zSymmetric SKyline�nsk�zNonsymmetric SKyline�jad�zJAgged Diagonal�zUnsymmetric Sparse Skyline�zVariable Block Row��	Undefined)�uss�vbr�und�2c@s�eZdZdZdZdZedd��Zedd��Zedd	��Z	ed
d��Z
edd
��Zedd��Zedd��Z
dZefdd�Zdd�Zdd�Zeeed�Zdd�Zdd�Zd�d d!�Zed"d#��Zed$d%��Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd�d/d0�Zed1d2��Zd3d4�Z d5d6�Z!d7d8�Z"d9d:�Z#e#Z$d;d<�Z%d�d=d>�Z&d?d@�Z'dAdB�Z(dCdD�Z)dEdF�Z*d�dGdH�Z+dIdJ�Z,dKdL�Z-dMdN�Z.dOdP�Z/dQdR�Z0dSdT�Z1dUdV�Z2d�dXdY�Z3dZd[�Z4d\d]�Z5d^d_�Z6d`da�Z7dbdc�Z8ddde�Z9dfdg�Z:dhdi�Z;djdk�Z<dldm�Z=dndo�Z>dpdq�Z?drds�Z@dtdu�ZAdvdw�ZBdxdy�ZCdzd{�ZDd|d}�ZEd~d�ZFd�d�d��ZGd�d��ZHd�d��ZId�d��ZJd�d��ZKd�d��ZLd�d��ZMd�d��ZNd�d��ZOd�d��ZPd�d��ZQd�d��ZRd�d��ZSd�d�d��ZTd�d�d��ZUd�d�d��ZVeUjeV_d�d��ZWd�d��ZXd�d��ZYd�d��ZZd�d��Z[d�d��Z\d�d�d��Z]d�d�d��Z^d�d�d��Z_d�d�d��Z`d�d�d��Zad�d�d��Zbd�d�d��Zcd�d�d��Zdd�d�d��Zed�d��Zfd�d�d��Zgd�d�dÄZhd�d�dńZid�d�dDŽZjd�d�dɄZkd�d˄Zld�d̈́Zmd.S)�r
z� This class provides a base class for all sparse matrices.  It
    cannot be instantiated.  Most of the work is provided by subclasses.
    g333333$@rcC�ddlm}|S)Nr)�
bsr_matrix)�_bsrrF)�selfrFrrr�_bsr_containerD�zspmatrix._bsr_containercCrE)Nr)�
coo_matrix)�_coorK)rHrKrrr�_coo_containerIrJzspmatrix._coo_containercCrE)Nr)�
csc_matrix)�_cscrN)rHrNrrr�_csc_containerNrJzspmatrix._csc_containercCrE)Nr)�
csr_matrix)�_csrrQ)rHrQrrr�_csr_containerSrJzspmatrix._csr_containercCrE)Nr)�
dia_matrix)�_diarT)rHrTrrr�_dia_containerXrJzspmatrix._dia_containercCrE)Nr)�
dok_matrix)�_dokrW)rHrWrrr�_dok_container]rJzspmatrix._dok_containercCrE)Nr)�
lil_matrix)�_lilrZ)rHrZrrr�_lil_containerbrJzspmatrix._lil_containerFcCs$d|_|jjdkr
td��||_dS)Nr
z7This class is not intended to be instantiated directly.)�_shape�	__class__r�
ValueError�maxprint)rHr`rrr�__init__is
zspmatrix.__init__cCs"|j|dd��|j�}|j|_dS)zSee `reshape`.F��copyN)�reshape�asformat�format�__dict__)rH�shape�
new_matrixrrr�	set_shapepszspmatrix.set_shapecC�|jS)zGet shape of a matrix.)r]�rHrrr�	get_shapew�zspmatrix.get_shape)�fget�fsetcOsJt||j�}t|�\}}||jkr|r|��S|S|j|d�j||dd�S)a�reshape(self, shape, order='C', copy=False)

        Gives a new shape to a sparse matrix without changing its data.

        Parameters
        ----------
        shape : length-2 tuple of ints
            The new shape should be compatible with the original shape.
        order : {'C', 'F'}, optional
            Read the elements using this index order. 'C' means to read and
            write the elements using C-like index order; e.g., read entire first
            row, then second row, etc. 'F' means to read and write the elements
            using Fortran-like index order; e.g., read entire first column, then
            second column, etc.
        copy : bool, optional
            Indicates whether or not attributes of self should be copied
            whenever possible. The degree to which attributes are copied varies
            depending on the type of sparse matrix being used.

        Returns
        -------
        reshaped_matrix : sparse matrix
            A sparse matrix with the given `shape`, not necessarily of the same
            format as the current object.

        See Also
        --------
        numpy.matrix.reshape : NumPy's implementation of 'reshape' for
                               matrices
        rbF)�orderrc)rrhrrc�tocoord)rH�args�kwargsrhrqrcrrrrd}s!
zspmatrix.reshapecCstd�t|�j���)a�Resize the matrix in-place to dimensions given by ``shape``

        Any elements that lie within the new shape will remain at the same
        indices, while non-zero elements lying outside the new shape are
        removed.

        Parameters
        ----------
        shape : (int, int)
            number of rows and columns in the new matrix

        Notes
        -----
        The semantics are not identical to `numpy.ndarray.resize` or
        `numpy.resize`. Here, the same data will be maintained at each index
        before and after reshape, if that index is within the new bounds. In
        numpy, resizing maintains contiguity of the array, moving elements
        around in the logical matrix but not within a flattened representation.

        We give no guarantees about whether the underlying data attributes
        (arrays, etc.) will be modified in place or replaced with new objects.
        z{}.resize is not implemented)�NotImplementedErrorrf�typer)rHrhrrr�resize�s�zspmatrix.resize�unsafeTcCs@t�|�}|j|kr|��j|||d��|j�S|r|��S|S)a�Cast the matrix elements to a specified type.

        Parameters
        ----------
        dtype : string or numpy dtype
            Typecode or data-type to which to cast the data.
        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
            Controls what kind of data casting may occur.
            Defaults to 'unsafe' for backwards compatibility.
            '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.
        copy : bool, optional
            If `copy` is `False`, the result might share some memory with this
            matrix. If `copy` is `True`, it is guaranteed that the result and
            this matrix do not share any memory.
        )�castingrc)�np�dtype�tocsr�astypererfrc)rHr{ryrcrrrr}�s

��zspmatrix.astypecK�(|jrtj|fi|��St|fi|��S�N)�	_is_arrayrz�asarrayr��cls�Xrtrrr�_ascontainer��zspmatrix._ascontainercKr~r)r�rz�arrayrr�rrr�
_container�r�zspmatrix._containercCsPgd�}|jj|vr|S|D]}|jt�|�kr|�|�Sqtd|jj��)z7Upcast matrix to a floating point format (if necessary))�f�d�F�Dz-cannot upcast [%s] to a floating point format)r{�charrzr}�	TypeError�name)rH�fp_types�fp_typerrr�asfptype�s��zspmatrix.asfptypeccs,�t|jd�D]}||dd�fVqdS�Nr)�rangerh)rH�rrrr�__iter__�s��zspmatrix.__iter__cCrk)z3Maximum number of elements to display when printed.)r`rlrrr�getmaxprintrnzspmatrix.getmaxprintcC�td|jj��)a(Number of non-zero entries, equivalent to

        np.count_nonzero(a.toarray())

        Unlike getnnz() and the nnz property, which return the number of stored
        entries (the length of the data attribute), this method counts the
        actual number of non-zero entries in data.
        z%count_nonzero not implemented for %s.�rur^rrlrrr�
count_nonzeros	�zspmatrix.count_nonzeroNcCr�)aJNumber of stored values, including explicit zeros.

        Parameters
        ----------
        axis : None, 0, or 1
            Select between the number of values across the whole matrix, in
            each column, or in each row.

        See also
        --------
        count_nonzero : Number of non-zero entries
        zgetnnz not implemented for %s.r�)rH�axisrrr�getnnzs
�zspmatrix.getnnzcCs|��S)z�Number of stored values, including explicit zeros.

        See also
        --------
        count_nonzero : Number of non-zero entries
        )r�rlrrr�nnz#szspmatrix.nnzcCst|dd�S)z.Format of a matrix representation as a string.rfrC)�getattrrlrrr�	getformat-�zspmatrix.getformatcCs@t|��\}}|jr
dnd}d|�d�|j|jj|j|fS)Nr�rz<%dx%d sparse z4 of type '%s'
	with %d stored elements in %s format>)�_formatsr�r�rhr{rvr�)rH�_�format_name�
sparse_clsrrr�__repr__1s

�zspmatrix.__repr__cCs�|��}|��}dd�}|j|krP|d}||jd|�|jd|�|jd|��}|d7}||d}|||j|d�|j|d�|j|d��7}|S||j|j|j�}|S)NcSs(ttt||��|�}d�dd�|D��S)N�
cSsg|]}d|�qS)z  %s	%sr)�.0�trrr�
<listcomp>@sz3spmatrix.__str__.<locals>.tostr.<locals>.<listcomp>)�zip�list�join)�row�col�data�triplesrrr�tostr>szspmatrix.__str__.<locals>.tostrrz
  :	:
)r�rrr�r�r�r�)rHr`�Ar��half�outrrr�__str__8s
*4�zspmatrix.__str__cCs|jdkr
|jdkStd��)N)rrrz\The truth value of an array with more than one element is ambiguous. Use a.any() or a.all().)rhr�r_rlrrr�__bool__Ms

zspmatrix.__bool__cCstd��)Nz;sparse matrix length is ambiguous; use getnnz() or shape[0])r�rlrrr�__len__Xszspmatrix.__len__c
Cs�|dus	||jkr|r|��S|Sz	t|d|�}Wnty.}ztd�|��|�d}~wwz||d�WStyA|�YSw)a�Return this matrix in the passed format.

        Parameters
        ----------
        format : {str, None}
            The desired matrix format ("csr", "csc", "lil", "dok", "array", ...)
            or None for no conversion.
        copy : bool, optional
            If True, the result is guaranteed to not share data with self.

        Returns
        -------
        A : This matrix in the passed format.
        N�tozFormat {} is unknown.rb)rfrcr��AttributeErrorr_r�)rHrfrc�convert_method�errrre\s��
�zspmatrix.asformatcC�|���|�S)z4Point-wise multiplication by another matrix
        )r|�multiply�rH�otherrrrr��szspmatrix.multiplycCr�)z5Element-wise maximum between this and another matrix.)r|�maximumr�rrrr���zspmatrix.maximumcCr�)z5Element-wise minimum between this and another matrix.)r|�minimumr�rrrr��r�zspmatrix.minimumcCs||S)a1Ordinary dot product

        Examples
        --------
        >>> import numpy as np
        >>> from scipy.sparse import csr_matrix
        >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
        >>> v = np.array([1, 0, -1])
        >>> A.dot(v)
        array([ 1, -3, -1], dtype=int64)

        rr�rrr�dot�s
zspmatrix.dotcCs|��j||d�S)zElement-wise power.�r{)r|�power)rH�nr{rrrr��szspmatrix.powercCr�r)r|�__eq__r�rrrr���zspmatrix.__eq__cCr�r)r|�__ne__r�rrrr��r�zspmatrix.__ne__cCr�r)r|�__lt__r�rrrr��r�zspmatrix.__lt__cCr�r)r|�__gt__r�rrrr��r�zspmatrix.__gt__cCr�r)r|�__le__r�rrrr��r�zspmatrix.__le__cCr�r)r|�__ge__r�rrrr��r�zspmatrix.__ge__cCst|���Sr)�absr|rlrrr�__abs__��zspmatrix.__abs__rcCst|��|d�S)N)�ndigits)�roundr|)rHr�rrr�	__round__�szspmatrix.__round__cCr�r)r|�_add_sparser�rrrr��r�zspmatrix._add_sparsecCr�r)rr�
_add_denser�rrrr��r�zspmatrix._add_densecCr�r)r|�_sub_sparser�rrrr��r�zspmatrix._sub_sparsecCs|��|Sr��todenser�rrr�
_sub_dense�r�zspmatrix._sub_densecCs||��Srr�r�rrr�_rsub_dense�r�zspmatrix._rsub_densecC�jt|�r|dkr|��Std��t|�r#|j|jkrtd��|�|�St|�r3t�	||j�}|�
|�StS)Nrz;adding a nonzero scalar to a sparse matrix is not supported�inconsistent shapes)r
rcrurrhr_r�rrz�broadcast_tor��NotImplementedr�rrr�__add__�s

zspmatrix.__add__cC�
|�|�Sr)r�r�rrr�__radd__��
zspmatrix.__radd__cCr�)NrzBsubtracting a nonzero scalar from a sparse matrix is not supportedr�)r
rcrurrhr_r�rrzr�r�r�r�rrr�__sub__�s

zspmatrix.__sub__cCsFt|�r|dkr
|��Std��t|�r!t�||j�}|�|�StS)NrzBsubtracting a sparse matrix from a nonzero scalar is not supported)	r
rcrurrzr�rhr�r�r�rrr�__rsub__�s

zspmatrix.__rsub__cCs�|j\}}|jtjur9|j|fkr|�|�S|j|dfkr(|�|����|d�S|jdkr9|jd|kr9|�|�St	|�rB|�
|�St|�rY|jd|jdkrTtd��|�
|�St�|�}|jdkrk|jtjkrktSz|jWnty{|}Ynw|jdks�|jdkr�|jddkr�|j|fkr�|j|dfkr�td��|�t�|��}t|tj�r�|�|�}|jdkr�|jddkr�|�dd�}|S|jdkr�|jd|jdkr�td��|�t�|��}t|tj�r�|�|�}|Std��)z�interpret other and call one of the following

        self._mul_scalar()
        self._mul_vector()
        self._mul_multivector()
        self._mul_sparse_matrix()
        rrrzdimension mismatch���zcould not interpret dimensions)rhr^rz�ndarray�_mul_vector�ravelrd�ndim�_mul_multivectorr
�_mul_scalarrr_�_mul_sparse_matrix�
asanyarrayr{�object_r�r��
isinstancerr�r�)rHr��M�N�other_a�resultrrr�
_mul_dispatch�sN
	





�"


zspmatrix._mul_dispatchcCr�r)r�r�rrr�__mul__Fr�zspmatrix.__mul__cCr�r)r|r�r�rrrr�Jr�zspmatrix._mul_scalarcCr�r)r|r�r�rrrr�Mr�zspmatrix._mul_vectorcCr�r)r|r�r�rrrr�Pr�zspmatrix._mul_multivectorcCr�r)r|r�r�rrrr�Sr�zspmatrix._mul_sparse_matrixcCsPt|�r	|�|�Sz|��}Wntyt�|���}Ynw|��|��Sr)r
r��	transposer�rzr�)rHr��trrrr�_rmul_dispatchVs
�zspmatrix._rmul_dispatchcCr�r)r�r�rrr�__rmul__ar�zspmatrix.__rmul__cC�t|�rtd��|�|�S�Nz0Scalar operands are not allowed, use '*' instead)r
r_r�r�rrr�
__matmul__h�
zspmatrix.__matmul__cCr�r�)r
r_r�r�rrr�__rmatmul__nr�zspmatrix.__rmatmul__cCsNt|�rQ|r|rt�||���St�||���S|r-t�|jtj�r-|�tj��	d|�S|�	d|�}t�
|�j}t�|jtj�rOt�|tj�rO|�|j�S|St
|�r{|si|rat�|��|�St�|��|�S|rst�||���St�||���St|�r�|r�|j||dd�S|��}|r�t�|jtj�r�|�tj��|�S|�|�StS)N��?F)�rdivide)r
rz�true_divider��divide�can_castr{�float_r}r�r��
issubdtype�integerrr�_divider|�_divide_sparser�)rHr�rrr��scalar_dtype�self_csrrrrrxs<�
zspmatrix._dividecC�|j|dd�S�NT)r�rr�rrr�__truediv__�r�zspmatrix.__truediv__cCrrr
r�rrr�__div__�r�zspmatrix.__div__cC�tSr�r�r�rrr�__rtruediv__��zspmatrix.__rtruediv__cCrrrr�rrr�__rdiv__�rzspmatrix.__rdiv__cCs
|��Sr)r|rlrrr�__neg__�r�zspmatrix.__neg__cCrrrr�rrr�__iadd__��zspmatrix.__iadd__cCrrrr�rrr�__isub__�rzspmatrix.__isub__cCrrrr�rrr�__imul__�rzspmatrix.__imul__cCr�r)�__itruediv__r�rrr�__idiv__�r�zspmatrix.__idiv__cCrrrr�rrrr�rzspmatrix.__itruediv__cCs�|jd|jd}}||krtd��t|�r`t|�}|dkr#td��|dkrCddlm}|||jd�}|jrAddl	m
}||�}|S|dkrK|��S|�|d�}|dr\|||S||St
|�rhtd	��tS)
Nrrzmatrix is not squarezexponent must be >= 0)�eyer�)�	dia_arrayrzexponent must be an integer)rhr�r	�intr_�
_constructrr{r��_arraysrrc�__pow__r
r�)rHr�r�r�r�Er�tmprrrr!�s.zspmatrix.__pow__cCs�|dkr|jrtt�d��|��S|dkr|��S|dkr,|jr(tt�d��|��S|dkr4|��S|dkr<|��S|dkrD|�	�St
|d	��)
Nr�zPlease use `.todense()` instead�T�HzPlease use `.conj().T` instead�real�imag�sizez
 not found)r�rrz�VisibleDeprecationWarning�toarrayr��getH�_real�_imagr�r�)rH�attrrrr�__getattr__�s*��zspmatrix.__getattr__cCs|j|d�j|dd�S)a
        Reverses the dimensions of the sparse matrix.

        Parameters
        ----------
        axes : None, optional
            This argument is in the signature *solely* for NumPy
            compatibility reasons. Do not pass in anything except
            for the default value.
        copy : bool, optional
            Indicates whether or not attributes of `self` should be
            copied whenever possible. The degree to which attributes
            are copied varies depending on the type of sparse matrix
            being used.

        Returns
        -------
        p : `self` with the dimensions reversed.

        See Also
        --------
        numpy.matrix.transpose : NumPy's implementation of 'transpose'
                                 for matrices
        rbF)�axesrc)r|r�)rHr0rcrrrr��szspmatrix.transposecCs4t�|jtj�r|j|d�jdd�S|r|��S|S)a�Element-wise complex conjugation.

        If the matrix is of non-complex data type and `copy` is False,
        this method does nothing and the data is not copied.

        Parameters
        ----------
        copy : bool, optional
            If True, the result is guaranteed to not share data with self.

        Returns
        -------
        A : The element-wise complex conjugate.

        rbF)rzrr{�complexfloatingr|�conjrc�rHrcrrrr2s
z
spmatrix.conjcCs|j|d�S)Nrb)r2r3rrr�	conjugate-r�zspmatrix.conjugatecC�|����S)z�Return the Hermitian transpose of this matrix.

        See Also
        --------
        numpy.matrix.getH : NumPy's implementation of `getH` for matrices
        )r�r2rlrrrr+3sz
spmatrix.getHcCr5r)r|r,rlrrrr,<r�zspmatrix._realcCr5r)r|r-rlrrrr-?r�zspmatrix._imagcCs&|��}|jdk}|j||j|fS)agnonzero indices

        Returns a tuple of arrays (row,col) containing the indices
        of the non-zero elements of the matrix.

        Examples
        --------
        >>> from scipy.sparse import csr_matrix
        >>> A = csr_matrix([[1,2,0],[0,0,3],[4,0,5]])
        >>> A.nonzero()
        (array([0, 0, 1, 2, 2]), array([0, 1, 2, 0, 2]))

        r)rrr�r�r�)rHr��nz_maskrrr�nonzeroBs
zspmatrix.nonzerocCs^|jd}|dkr
||7}|dks||krtd��|jdg|gdggf|df|jd�}||S)zgReturns a copy of column j of the matrix, as an (m x 1) sparse
        matrix (column vector).
        rr�index out of bounds�rhr{)rh�
IndexErrorrPr{)rH�jr��col_selectorrrr�getcolV�

�zspmatrix.getcolcCs^|jd}|dkr
||7}|dks||krtd��|jdgdg|ggfd|f|jd�}||S)z`Returns a copy of row i of the matrix, as a (1 x n) sparse
        matrix (row vector).
        rr8rr9)rhr:rSr{)rH�i�m�row_selectorrrr�getrowfr>zspmatrix.getrowcCs|�|j||d��S)a�
        Return a dense matrix representation of this matrix.

        Parameters
        ----------
        order : {'C', 'F'}, optional
            Whether to store multi-dimensional data in C (row-major)
            or Fortran (column-major) order in memory. The default
            is 'None', which provides no ordering guarantees.
            Cannot be specified in conjunction with the `out`
            argument.

        out : ndarray, 2-D, optional
            If specified, uses this array (or `numpy.matrix`) as the
            output buffer instead of allocating a new array to
            return. The provided array must have the same shape and
            dtype as the sparse matrix on which you are calling the
            method.

        Returns
        -------
        arr : numpy.matrix, 2-D
            A NumPy matrix object with the same shape and containing
            the same data represented by the sparse matrix, with the
            requested memory order. If `out` was passed and was an
            array (rather than a `numpy.matrix`), it will be filled
            with the appropriate values and returned wrapped in a
            `numpy.matrix` object that shares the same memory.
        �rqr�)r�r*�rHrqr�rrrr��szspmatrix.todensecC�|jdd�j||d�S)a�
        Return a dense ndarray representation of this matrix.

        Parameters
        ----------
        order : {'C', 'F'}, optional
            Whether to store multidimensional data in C (row-major)
            or Fortran (column-major) order in memory. The default
            is 'None', which provides no ordering guarantees.
            Cannot be specified in conjunction with the `out`
            argument.

        out : ndarray, 2-D, optional
            If specified, uses this array as the output buffer
            instead of allocating a new array to return. The provided
            array must have the same shape and dtype as the sparse
            matrix on which you are calling the method. For most
            sparse types, `out` is required to be memory contiguous
            (either C or Fortran ordered).

        Returns
        -------
        arr : ndarray, 2-D
            An array with the same shape and containing the same
            data represented by the sparse matrix, with the requested
            memory order. If `out` was passed, the same object is
            returned after being modified in-place to contain the
            appropriate values.
        FrbrC)rrr*rDrrrr*�szspmatrix.toarraycC�|j|d�jdd�S)z�Convert this matrix to Compressed Sparse Row format.

        With copy=False, the data/indices may be shared between this matrix and
        the resultant csr_matrix.
        rbF)rrr|r3rrrr|��zspmatrix.tocsrcCrF)z�Convert this matrix to Dictionary Of Keys format.

        With copy=False, the data/indices may be shared between this matrix and
        the resultant dok_matrix.
        rbF)rr�todokr3rrrrH�rGzspmatrix.todokcC�|jdd�j|d�S)z�Convert this matrix to COOrdinate format.

        With copy=False, the data/indices may be shared between this matrix and
        the resultant coo_matrix.
        Frb)r|rrr3rrrrr�rGzspmatrix.tocoocCrI)z�Convert this matrix to List of Lists format.

        With copy=False, the data/indices may be shared between this matrix and
        the resultant lil_matrix.
        Frb)r|�tolilr3rrrrJ�rGzspmatrix.tolilcCrF)z�Convert this matrix to sparse DIAgonal format.

        With copy=False, the data/indices may be shared between this matrix and
        the resultant dia_matrix.
        rbF)rr�todiar3rrrrK�rGzspmatrix.todiacCrE)aConvert this matrix to Block Sparse Row format.

        With copy=False, the data/indices may be shared between this matrix and
        the resultant bsr_matrix.

        When blocksize=(R, C) is provided, it will be used for construction of
        the bsr_matrix.
        Frb)�	blocksizerc)r|�tobsr)rHrLrcrrrrM�s	zspmatrix.tobsrcCrF)z�Convert this matrix to Compressed Sparse Column format.

        With copy=False, the data/indices may be shared between this matrix and
        the resultant csc_matrix.
        rbF)r|�tocscr3rrrrNrGzspmatrix.tocsccCs|j|dd�S)z�Returns a copy of this matrix.

        No data/indices will be shared between the returned value and current
        matrix.
        Trb)r^rlrrrrcsz
spmatrix.copycCs�t|�|j\}}t|j�}|dur%||�tj|df|d��j||d�S|dkr-|d7}|dkr@|�tjd|f|d��|}n||�tj|df|d��}|dur\|j|jkr\td��|j|||d�S)	aw
        Sum the matrix elements over a given axis.

        Parameters
        ----------
        axis : {-2, -1, 0, 1, None} optional
            Axis along which the sum is computed. The default is to
            compute the sum of all the matrix elements, returning a scalar
            (i.e., `axis` = `None`).
        dtype : dtype, optional
            The type of the returned matrix and of the accumulator in which
            the elements are summed.  The dtype of `a` is used by default
            unless `a` has an integer dtype of less precision than the default
            platform integer.  In that case, if `a` is signed then the platform
            integer is used while if `a` is unsigned then an unsigned integer
            of the same precision as the platform integer is used.

            .. versionadded:: 0.18.0

        out : np.matrix, optional
            Alternative output matrix in which to place the result. It must
            have the same shape as the expected output, but the type of the
            output values will be cast if necessary.

            .. versionadded:: 0.18.0

        Returns
        -------
        sum_along_axis : np.matrix
            A matrix with the same shape as `self`, with the specified
            axis removed.

        See Also
        --------
        numpy.matrix.sum : NumPy's implementation of 'sum' for matrices

        Nrr��r{r�rrzdimensions do not match�r�r{r�)	rrhrr{r�rz�ones�sumr_)rHr�r{r�r@r��	res_dtype�retrrrrRs*&

����zspmatrix.sumc	Cs�dd�}t|�|jj}||j�}|dur|rtj}nt�|�j}|r&tjn|}|�|�}|durE|t�|jd|jd�j||d�S|dkrM|d7}|dkr`|d|jdjd||d	�S|d|jdjd||d	�S)
a�
        Compute the arithmetic mean along the specified axis.

        Returns the average of the matrix elements. The average is taken
        over all elements in the matrix by default, otherwise over the
        specified axis. `float64` intermediate and return values are used
        for integer inputs.

        Parameters
        ----------
        axis : {-2, -1, 0, 1, None} optional
            Axis along which the mean is computed. The default is to compute
            the mean of all elements in the matrix (i.e., `axis` = `None`).
        dtype : data-type, optional
            Type to use in computing the mean. For integer inputs, the default
            is `float64`; for floating point inputs, it is the same as the
            input dtype.

            .. versionadded:: 0.18.0

        out : np.matrix, optional
            Alternative output matrix in which to place the result. It must
            have the same shape as the expected output, but the type of the
            output values will be cast if necessary.

            .. versionadded:: 0.18.0

        Returns
        -------
        m : np.matrix

        See Also
        --------
        numpy.matrix.mean : NumPy's implementation of 'mean' for matrices

        cSst�|tj�p
t�|tj�Sr)rzrr�bool_r�rrr�_is_integrals�z#spmatrix.mean.<locals>._is_integralNrrrOrr�rP)	rr{rvrz�float64r}r�rhrR)	rHr�r{r�rVrS�integral�inter_dtype�
inter_selfrrr�meanZs4%
�
����z
spmatrix.meancCs|��j|d�S)aTReturns the kth diagonal of the matrix.

        Parameters
        ----------
        k : int, optional
            Which diagonal to get, corresponding to elements a[i, i+k].
            Default: 0 (the main diagonal).

            .. versionadded:: 1.0

        See also
        --------
        numpy.diagonal : Equivalent numpy function.

        Examples
        --------
        >>> from scipy.sparse import csr_matrix
        >>> A = csr_matrix([[1, 2, 0], [0, 0, 3], [4, 0, 5]])
        >>> A.diagonal()
        array([1, 0, 5])
        >>> A.diagonal(k=1)
        array([2, 3])
        ��k)r|�diagonal)rHr]rrrr^�szspmatrix.diagonalcCs|j|d���S)z�Returns the sum along diagonals of the sparse matrix.

        Parameters
        ----------
        offset : int, optional
            Which diagonal to get, corresponding to elements a[i, i+offset].
            Default: 0 (the main diagonal).

        r\)r^rR)rH�offsetrrr�trace�s
zspmatrix.tracecCsJ|j\}}|dkr
||ks|dkr||krtd��|�t�|�|�dS)a�
        Set diagonal or off-diagonal elements of the array.

        Parameters
        ----------
        values : array_like
            New values of the diagonal elements.

            Values may have any length. If the diagonal is longer than values,
            then the remaining diagonal entries will not be set. If values are
            longer than the diagonal, then the remaining values are ignored.

            If a scalar value is given, all of the diagonal is set to it.

        k : int, optional
            Which off-diagonal to set, corresponding to elements a[i,i+k].
            Default: 0 (the main diagonal).

        rzk exceeds matrix dimensionsN)rhr_�_setdiagrzr�)rH�valuesr]r�r�rrr�setdiag�s
"zspmatrix.setdiagcCs"|j\}}|dkrM|jdkr&t|||�}t|�D]
}|||||f<qdSt|||t|��}|dkr6dSt|d|��D]\}}|||||f<q>dS|jdkrjt|||�}t|�D]
}|||||f<q]dSt|||t|��}|dkrzdSt|d|��D]\}}|||||f<q�dSr�)rhr��minr��len�	enumerate)rHrbr]r�r��	max_indexr?�vrrrra�s0

��
��zspmatrix._setdiagcCsX|dur"|durtd��|j|jks|j|jkrtd��d|d<|Stj|j|j|d�S)Nz,order cannot be specified if out is not Nonez7out array must be same dtype and shape as sparse matrixg.)r{rq)r_rhr{rz�zerosrDrrr�_process_toarray_args�szspmatrix._process_toarray_args)rxTr)F)r)FF)NF)T)NN)NNN)nrrr�__doc__�__array_priority__r��propertyrIrMrPrSrVrYr\r��MAXPRINTrarjrmrhrdrwr}�classmethodr�r�r�r�r�r�r�r�r�r�r�r��__nonzero__r�rer�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrrrrrrrrrr!r/r�r2r4r+r,r-r7r=rBr�r*r|rHrrrJrKrMrNrcrRr[r^r`rcrarjrrrrr
<s�






+




	
'

K

+


	
$
 
#







J
I

r
cCs
t|t�S)a�Is x of a sparse matrix type?

    Parameters
    ----------
    x
        object to check for being a sparse matrix

    Returns
    -------
    bool
        True if x is a sparse matrix, False otherwise

    Notes
    -----
    issparse and isspmatrix are aliases for the same function.

    Examples
    --------
    >>> from scipy.sparse import csr_matrix, isspmatrix
    >>> isspmatrix(csr_matrix([[5]]))
    True

    >>> from scipy.sparse import isspmatrix
    >>> isspmatrix(5)
    False
    )r�r
)�xrrrrs
r)-rk�warningsr�numpyrz�_sputilsrrrrrr	r
rr�__all__�Warningrrrr��	frozenset�sin�tan�arcsin�arctan�sinh�tanh�arcsinh�arctanh�rint�sign�expm1�log1p�deg2rad�rad2deg�floor�ceil�trunc�sqrt� _ufuncs_with_fixed_point_at_zerornr
rrrrrr�<module>s~,��������	�
���
������X

Youez - 2016 - github.com/yon3zu
LinuXploit