403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/scipy/sparse/linalg/_dsolve/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/scipy/sparse/linalg/_dsolve/__pycache__/linsolve.cpython-311.pyc
�

d�c�b���ddlmZddlZddlmZddlmZmZmZm	Z	m
Z
mZddlm
Z
ddlmZddlZddlmZd	Z	ddlmZn
#e$rd
ZYnwxYweZgd�ZGd�d
e��Zd�Zd�Zdd�Zdddde��fd�Z		dd�Z d�Z!		dd�Z"dS)�)�warnN)�asarray)�isspmatrix_csc�isspmatrix_csr�
isspmatrix�SparseEfficiencyWarning�
csc_matrix�
csr_matrix)�is_pydata_spmatrix)�LinAlgError�)�_superluFT)�
use_solver�spsolve�splu�spilu�
factorized�MatrixRankWarning�spsolve_triangularc��eZdZdS)rN)�__name__�
__module__�__qualname__���F/usr/lib/python3/dist-packages/scipy/sparse/linalg/_dsolve/linsolve.pyrrs�������Drrc��d|vr|dt��d<tr!d|vrtj|d���dSdSdS)as	
    Select default sparse direct solver to be used.

    Parameters
    ----------
    useUmfpack : bool, optional
        Use UMFPACK [1]_, [2]_, [3]_, [4]_. over SuperLU. Has effect only
        if ``scikits.umfpack`` is installed. Default: True
    assumeSortedIndices : bool, optional
        Allow UMFPACK to skip the step of sorting indices for a CSR/CSC matrix.
        Has effect only if useUmfpack is True and ``scikits.umfpack`` is
        installed. Default: False

    Notes
    -----
    The default sparse solver is UMFPACK when available
    (``scikits.umfpack`` is installed). This can be changed by passing
    useUmfpack = False, which then causes the always present SuperLU
    based solver to be used.

    UMFPACK requires a CSR/CSC matrix to have sorted column/row indices. If
    sure that the matrix fulfills this, pass ``assumeSortedIndices=True``
    to gain some speed.

    References
    ----------
    .. [1] T. A. Davis, Algorithm 832:  UMFPACK - an unsymmetric-pattern
           multifrontal method with a column pre-ordering strategy, ACM
           Trans. on Mathematical Software, 30(2), 2004, pp. 196--199.
           https://dl.acm.org/doi/abs/10.1145/992200.992206

    .. [2] T. A. Davis, A column pre-ordering strategy for the
           unsymmetric-pattern multifrontal method, ACM Trans.
           on Mathematical Software, 30(2), 2004, pp. 165--195.
           https://dl.acm.org/doi/abs/10.1145/992200.992205

    .. [3] T. A. Davis and I. S. Duff, A combined unifrontal/multifrontal
           method for unsymmetric sparse matrices, ACM Trans. on
           Mathematical Software, 25(1), 1999, pp. 1--19.
           https://doi.org/10.1145/305658.287640

    .. [4] T. A. Davis and I. S. Duff, An unsymmetric-pattern multifrontal
           method for sparse LU factorization, SIAM J. Matrix Analysis and
           Computations, 18(1), 1997, pp. 140--158.
           https://doi.org/10.1137/S0895479894246905T.

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.sparse.linalg import use_solver, spsolve
    >>> from scipy.sparse import csc_matrix
    >>> R = np.random.randn(5, 5)
    >>> A = csc_matrix(R)
    >>> b = np.random.randn(5)
    >>> use_solver(useUmfpack=False) # enforce superLU over UMFPACK
    >>> x = spsolve(A, b)
    >>> np.allclose(A.dot(x), b)
    True
    >>> use_solver(useUmfpack=True) # reset umfPack usage to default
    �
useUmfpack�assumeSortedIndices)rN)�globalsr�umfpack�	configure)�kwargss rrrsi��z�v���"(��"6��	�	�,���M�+�v�5�5���f�5J�.K�L�L�L�L�L�L�M�M�5�5rc��tjtjfdtjtjfdtjtjfdtjtjfdi}tj|jj}tj|jjj}	|||f}n+#t$r}d|�d|�d�}t|��|�d}~wwxYw|d	d
z}tj|��}tj|j
dtj���|_
tj|jdtj���|_||fS)
z8Get umfpack family string given the sparse matrix dtype.�di�zi�dl�zlz]only float64 or complex128 matrices with int32 or int64 indices are supported! (got: matrix: z, indices: �)Nr�lF)�copy�dtype)�np�float64�int32�
complex128�int64�
sctypeDictr,�name�indices�KeyError�
ValueErrorr+�array�indptr)�A�	_families�f_type�i_type�family�e�msg�A_news        r�_get_umf_familyrA_s&��
��R�X���	����!�4�	��R�X���	����!�4�	�I��]�1�7�<�
(�F�
�]�1�9�?�/�
0�F�%��F�F�+�,�����%�%�%�%��v�v�v�v�v�����o�o�1�$�����	%�����A�Y��_�F��I�a�L�L�E��8�A�H�5���A�A�A�E�L��H�Q�Y�U�"�(�C�C�C�E�M��5�=�s�!
B,�,
C�6C�Cc
�&
�t|��r&|������}t|��s3t	|��s$t|��}t
dt��t|��pt|��}|st|��}|j
dkp|j
dko|jddk}|���|�
��}tj|j|j��}|j|kr|�|��}|j|kr|�|��}|j\}}||krt%d||f�d����||jdkr&t%d|j�d|jd�d����|ot&}|r�|r�|r|���}	n|}	t|	|j�	�����}	t,rt/d
���|jjdvrt%d���t3|��\}
}t5j|
��}|�t4j||	d
���}�n�|r|r|���}d}|s�t|��rd}
nd}
t=|���}t?j ||j!|j"|j#|j$||
|���\}}|dkr4t
dtJ��|�&tj'��|r|���}�n�tQ|��}t|��s3t|��s$t
dt��t|��}g}g}g}tS|jd��D]�}|dd�|gf������}||��}tj*|��}|jd}|�+|��|�+tj,||tZ�	����|�+tj	|||j�	������tj.|��}tj.|��}tj.|��}|�/|||ff|j|j���}t|��r|�/|��}|S)a�
Solve the sparse linear system Ax=b, where b may be a vector or a matrix.

    Parameters
    ----------
    A : ndarray or sparse matrix
        The square matrix A will be converted into CSC or CSR form
    b : ndarray or sparse matrix
        The matrix or vector representing the right hand side of the equation.
        If a vector, b.shape must be (n,) or (n, 1).
    permc_spec : str, optional
        How to permute the columns of the matrix for sparsity preservation.
        (default: 'COLAMD')

        - ``NATURAL``: natural ordering.
        - ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
        - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
        - ``COLAMD``: approximate minimum degree column ordering [1]_, [2]_.

    use_umfpack : bool, optional
        if True (default) then use UMFPACK for the solution [3]_, [4]_, [5]_,
        [6]_ . This is only referenced if b is a vector and
        ``scikits.umfpack`` is installed.

    Returns
    -------
    x : ndarray or sparse matrix
        the solution of the sparse linear equation.
        If b is a vector, then x is a vector of size A.shape[1]
        If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])

    Notes
    -----
    For solving the matrix expression AX = B, this solver assumes the resulting
    matrix X is sparse, as is often the case for very sparse inputs.  If the
    resulting X is dense, the construction of this sparse result will be
    relatively expensive.  In that case, consider converting A to a dense
    matrix and using scipy.linalg.solve or its variants.

    References
    ----------
    .. [1] T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, Algorithm 836:
           COLAMD, an approximate column minimum degree ordering algorithm,
           ACM Trans. on Mathematical Software, 30(3), 2004, pp. 377--380.
           :doi:`10.1145/1024074.1024080`

    .. [2] T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, A column approximate
           minimum degree ordering algorithm, ACM Trans. on Mathematical
           Software, 30(3), 2004, pp. 353--376. :doi:`10.1145/1024074.1024079`

    .. [3] T. A. Davis, Algorithm 832:  UMFPACK - an unsymmetric-pattern
           multifrontal method with a column pre-ordering strategy, ACM
           Trans. on Mathematical Software, 30(2), 2004, pp. 196--199.
           https://dl.acm.org/doi/abs/10.1145/992200.992206

    .. [4] T. A. Davis, A column pre-ordering strategy for the
           unsymmetric-pattern multifrontal method, ACM Trans.
           on Mathematical Software, 30(2), 2004, pp. 165--195.
           https://dl.acm.org/doi/abs/10.1145/992200.992205

    .. [5] T. A. Davis and I. S. Duff, A combined unifrontal/multifrontal
           method for unsymmetric sparse matrices, ACM Trans. on
           Mathematical Software, 25(1), 1999, pp. 1--19.
           https://doi.org/10.1145/305658.287640

    .. [6] T. A. Davis and I. S. Duff, An unsymmetric-pattern multifrontal
           method for sparse LU factorization, SIAM J. Matrix Analysis and
           Computations, 18(1), 1997, pp. 140--158.
           https://doi.org/10.1137/S0895479894246905T.


    Examples
    --------
    >>> import numpy as np
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import spsolve
    >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float)
    >>> B = csc_matrix([[2, 0], [-1, 0], [2, 0]], dtype=float)
    >>> x = spsolve(A, B)
    >>> np.allclose(A.dot(x).toarray(), B.toarray())
    True
    z.spsolve requires A be CSC or CSR matrix formatr
�z!matrix must be square (has shape r)rz!matrix - rhs dimension mismatch (z - )r,�Scikits.umfpack not installed.�dD�Zconvert matrix data to double, please, using .astype(), or set linsolve.useUmfpack = FalseT��
autoTransposeF)�ColPerm)�optionszMatrix is exactly singularzCspsolve is more efficient when sparse b is in the CSC matrix formatN)�shaper,)0r�to_scipy_sparse�tocscrrr	rrrr�ndimrK�sum_duplicates�asfptyper-�
promote_typesr,�astyper6r�toarray�ravel�noScikit�RuntimeError�charrAr!�UmfpackContext�linsolve�	UMFPACK_A�dictr�gssv�nnz�datar4r8r�fill�nanr�range�flatnonzero�append�full�int�concatenate�	__class__)r9�b�
permc_spec�use_umfpack�b_is_sparse�b_is_vector�result_dtype�M�N�b_vec�
umf_family�umf�x�flagrJ�info�
Afactsolve�	data_segs�row_segs�col_segs�j�bj�xj�w�segment_length�sparse_data�
sparse_row�
sparse_cols                            rrr~s��f�!���(�
�����%�%�'�'���1���)���!2�!2�)��q�M�M���
=�'�	)�	)�	)��Q�-�-�8�#5�a�#8�#8�K����A�J�J���F�a�K�E�Q�V�q�[�%D�Q�W�Q�Z�1�_�K�������	�
�
���A��#�A�G�Q�W�5�5�L��w�,���
�H�H�\�"�"���w�,���
�H�H�\�"�"��
�7�D�A�q�	�Q����j�A�q�6�6�6�K�L�L�L��A�G�A�J����j��G�G�G�Q�W�Q�Z�Z�Z�1�2�2�	2��,�*�K��F#�{�F#��	��I�I�K�K�E�E��E���Q�W�-�-�-�3�3�5�5���	A��?�@�@�@��7�<�t�#�#��C�D�D�
D�(��*�*�
�
�A��$�Z�0�0���L�L��*�A�u�'+�
�
-�
-����	 �;�	 ��	�	���A��K��/	#��a� � �
�������:�.�.�.�G��m�A�q�u�a�f�a�i���$%�t�W�>�>�>�G�A�t��q�y�y��1�3D�E�E�E����r�v�����
��G�G�I�I���$�A���J�"�1�%�%�
"�);�A�)>�)>�
"��3�4K�M�M�M��q�M�M���I��H��H��1�7�1�:�&�&�
C�
C��
�q�q�q�1�#�v�Y�&�&�(�(�.�.�0�0���Z��^�^���N�2�&�&��!"���������"�"�"��������� E� E� E�F�F�F�� � ���B�q�E���!A�!A�!A�B�B�B�B��.��3�3�K����1�1�J����1�1�J����[�:�z�*B�C�!"�����9�9�A�"�!�$�$�
#��K�K��N�N���Hrc
�l�t|��r:t|��d�d�}|������}nt}t|��s$t	|��}t
dt��|���|�	��}|j
\}}||krtd���t||||���}	|�|	�
|��|	ddkrd	|	d
<tj||j|j|j|j|d|	���S)
a�
    Compute the LU decomposition of a sparse, square matrix.

    Parameters
    ----------
    A : sparse matrix
        Sparse matrix to factorize. Most efficient when provided in CSC
        format. Other formats will be converted to CSC before factorization.
    permc_spec : str, optional
        How to permute the columns of the matrix for sparsity preservation.
        (default: 'COLAMD')

        - ``NATURAL``: natural ordering.
        - ``MMD_ATA``: minimum degree ordering on the structure of A^T A.
        - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A.
        - ``COLAMD``: approximate minimum degree column ordering

    diag_pivot_thresh : float, optional
        Threshold used for a diagonal entry to be an acceptable pivot.
        See SuperLU user's guide for details [1]_
    relax : int, optional
        Expert option for customizing the degree of relaxing supernodes.
        See SuperLU user's guide for details [1]_
    panel_size : int, optional
        Expert option for customizing the panel size.
        See SuperLU user's guide for details [1]_
    options : dict, optional
        Dictionary containing additional expert options to SuperLU.
        See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument)
        for more details. For example, you can specify
        ``options=dict(Equil=False, IterRefine='SINGLE'))``
        to turn equilibration off and perform a single iterative refinement.

    Returns
    -------
    invA : scipy.sparse.linalg.SuperLU
        Object, which has a ``solve`` method.

    See also
    --------
    spilu : incomplete LU decomposition

    Notes
    -----
    This function uses the SuperLU library.

    References
    ----------
    .. [1] SuperLU https://portal.nersc.gov/project/sparse/superlu/

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import splu
    >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
    >>> B = splu(A)
    >>> x = np.array([1., 2., 3.], dtype=float)
    >>> B.solve(x)
    array([ 1. , -3. , -1.5])
    >>> A.dot(B.solve(x))
    array([ 1.,  2.,  3.])
    >>> B.solve(A.dot(x))
    array([ 1.,  2.,  3.])
    ��clsc�&�|t|���S�N�r	�r��as  r�<lambda>zsplu.<locals>.<lambda>����S�S��Q��5H�5H�r�&splu converted its input to CSC format�can only factor square matrices)�DiagPivotThreshrI�	PanelSize�RelaxNrI�NATURALT�
SymmetricModeF��csc_construct_func�ilurJ�r�typerLrMr	rrrrOrPrKr6r[�updater�gstrfr]r^r4r8)
r9ri�diag_pivot_thresh�relax�
panel_sizerJr�rnro�_optionss
          rrr>sI��H�!���(�,0��G�G�H�H�H�H��
�����%�%�'�'���'���!���P��q�M�M���
5�7N�O�O�O�������	�
�
���A��7�D�A�q�	�Q����:�;�;�;��$5�z�(��7�7�7�H������� � � �	���y�(�(�$(���!��>�!�Q�U�A�F�A�I�q�x�-?�#�X�7�7�7�7rc	
�r�t|��r:t|��d�d�}	|������}nt}	t|��s$t	|��}t
dt��|���|�	��}|j
\}
}|
|krtd���t|||||||���}|�|�
|��|ddkrd	|d
<tj||j|j|j|j|	d	|���S)a�
    Compute an incomplete LU decomposition for a sparse, square matrix.

    The resulting object is an approximation to the inverse of `A`.

    Parameters
    ----------
    A : (N, N) array_like
        Sparse matrix to factorize. Most efficient when provided in CSC format.
        Other formats will be converted to CSC before factorization.
    drop_tol : float, optional
        Drop tolerance (0 <= tol <= 1) for an incomplete LU decomposition.
        (default: 1e-4)
    fill_factor : float, optional
        Specifies the fill ratio upper bound (>= 1.0) for ILU. (default: 10)
    drop_rule : str, optional
        Comma-separated string of drop rules to use.
        Available rules: ``basic``, ``prows``, ``column``, ``area``,
        ``secondary``, ``dynamic``, ``interp``. (Default: ``basic,area``)

        See SuperLU documentation for details.

    Remaining other options
        Same as for `splu`

    Returns
    -------
    invA_approx : scipy.sparse.linalg.SuperLU
        Object, which has a ``solve`` method.

    See also
    --------
    splu : complete LU decomposition

    Notes
    -----
    To improve the better approximation to the inverse, you may need to
    increase `fill_factor` AND decrease `drop_tol`.

    This function uses the SuperLU library.

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.sparse import csc_matrix
    >>> from scipy.sparse.linalg import spilu
    >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
    >>> B = spilu(A)
    >>> x = np.array([1., 2., 3.], dtype=float)
    >>> B.solve(x)
    array([ 1. , -3. , -1.5])
    >>> A.dot(B.solve(x))
    array([ 1.,  2.,  3.])
    >>> B.solve(A.dot(x))
    array([ 1.,  2.,  3.])
    r�c�&�|t|���Sr�r�r�s  rr�zspilu.<locals>.<lambda>�r�rz'spilu converted its input to CSC formatr�)�ILU_DropRule�ILU_DropTol�ILU_FillFactorr�rIr�r�NrIr�Tr�r�r�)
r9�drop_tol�fill_factor�	drop_rulerir�r�r�rJr�rnror�s
             rrr�sW��v�!���(�,0��G�G�H�H�H�H��
�����%�%�'�'���'���!���&��q�M�M���
6�
$�	&�	&�	&�������	�
�
���A��7�D�A�q�	�Q����:�;�;�;����#.�$5�z�(��7�7�7�H������� � � �	���y�(�(�$(���!��>�!�Q�U�A�F�A�I�q�x�-?�"�H�6�6�6�6rc� ���t���r&��������tr�trtd���t
���s$t����tdt����
����jjdvrtd���t���\}�tj|����������fd�}|St%���jS)aK
    Return a function for solving a sparse linear system, with A pre-factorized.

    Parameters
    ----------
    A : (N, N) array_like
        Input. A in CSC format is most efficient. A CSR format matrix will
        be converted to CSC before factorization.

    Returns
    -------
    solve : callable
        To solve the linear system of equations given in `A`, the `solve`
        callable should be passed an ndarray of shape (N,).

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.sparse.linalg import factorized
    >>> A = np.array([[ 3. ,  2. , -1. ],
    ...               [ 2. , -2. ,  4. ],
    ...               [-1. ,  0.5, -1. ]])
    >>> solve = factorized(A) # Makes LU decomposition.
    >>> rhs1 = np.array([1, -2, 0])
    >>> solve(rhs1) # Uses the LU factors.
    array([ 1., -2., -2.])

    rDr�rErFc���tjdd���5��tj�|d���}ddd��n#1swxYwY|S)N�ignore)�divide�invalidTrG)r-�errstate�solver!rZ)rh�resultr9rrs  ��rr�zfactorized.<locals>.solve5s������H�h�?�?�?�
P�
P����7�#4�a��$��O�O��
P�
P�
P�
P�
P�
P�
P�
P�
P�
P�
P����
P�
P�
P�
P��Ms�$A�A�A)rrLrMrrUrVrr	rrrPr,rWr6rAr!rX�numericrr�)r9rqr�rrs`  @rrrs&����:�!���(�
�����%�%�'�'�����	A��?�@�@�@��a� � �	*��1�
�
�A��9�(�
*�
*�
*�
�J�J�L�L���7�<�t�#�#��C�D�D�
D�(��*�*�
�
�A��$�Z�0�0��	���A����	�	�	�	�	�	����A�w�w�}�rc��t|��r&|������}t|��s%t	dt
��t
|��}n|s|���}|jd|jdkr'td�
|j�����|���tj
|��}|jdvr'td�
|j�����|jd|jdkr-td�
|j|j�����tj|j|tj��}|rGtj|j|d�	��r|}n?td
�
|j|�����|�|d���}|rt+t-|����}n!t+t-|��dz
d
d
��}|D�]1}	|j|	}
|j|	dz}|r|dz
}t1|
|dz
��}
n|
}t1|
dz|��}
|s9||
ks|j||	kr"t5d�
|	�����|s?|j||	kr.t5d�
|	|j|�����|j|
}|j|
}||	xxtj||j|��zcc<|s||	xx|j|zcc<��3|S)a
    Solve the equation ``A x = b`` for `x`, assuming A is a triangular matrix.

    Parameters
    ----------
    A : (M, M) sparse matrix
        A sparse square triangular matrix. Should be in CSR format.
    b : (M,) or (M, N) array_like
        Right-hand side matrix in ``A x = b``
    lower : bool, optional
        Whether `A` is a lower or upper triangular matrix.
        Default is lower triangular matrix.
    overwrite_A : bool, optional
        Allow changing `A`. The indices of `A` are going to be sorted and zero
        entries are going to be removed.
        Enabling gives a performance gain. Default is False.
    overwrite_b : bool, optional
        Allow overwriting data in `b`.
        Enabling gives a performance gain. Default is False.
        If `overwrite_b` is True, it should be ensured that
        `b` has an appropriate dtype to be able to store the result.
    unit_diagonal : bool, optional
        If True, diagonal elements of `a` are assumed to be 1 and will not be
        referenced.

        .. versionadded:: 1.4.0

    Returns
    -------
    x : (M,) or (M, N) ndarray
        Solution to the system ``A x = b``. Shape of return matches shape
        of `b`.

    Raises
    ------
    LinAlgError
        If `A` is singular or not triangular.
    ValueError
        If shape of `A` or shape of `b` do not match the requirements.

    Notes
    -----
    .. versionadded:: 0.19.0

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.sparse import csr_matrix
    >>> from scipy.sparse.linalg import spsolve_triangular
    >>> A = csr_matrix([[3, 0, 0], [1, -1, 0], [2, 0, 1]], dtype=float)
    >>> B = np.array([[2, 0], [-1, 0], [2, 0]], dtype=float)
    >>> x = spsolve_triangular(A, B)
    >>> np.allclose(A.dot(x), B)
    True
    z8CSR matrix format is required. Converting to CSR matrix.rr
z.A must be a square matrix but its shape is {}.)r
rCz,b must have 1 or 2 dims but its shape is {}.z�The size of the dimensions of A must be equal to the size of the first dimension of b but the shape of A is {} and the shape of b is {}.�	same_kind)�castingz5Cannot overwrite b (dtype {}) with result of type {}.T)r+���z#A is singular: diagonal {} is zero.z*A is not triangular: A[{}, {}] is nonzero.)rrL�tocsrrrrr
r+rKr6�formatrOr-�
asanyarrayrN�result_typer^r.�can_castr,rRra�lenr8�slicer4r�dot�T)r9rh�lower�overwrite_A�overwrite_b�
unit_diagonal�x_dtypers�row_indices�i�indptr_start�indptr_stop�A_diagonal_index_row_i�A_off_diagonal_indices_row_i�A_column_indices_in_row_i�A_values_in_row_is                rrrAs���t�!���(�
�����%�%�'�'���!�����
G�
$�	&�	&�	&��q�M�M���
��
�F�F�H�H���w�q�z�Q�W�Q�Z����<�C�C�A�G�L�L�N�N�	N�������
�
�a���A��v�V����:�A�A�!�'�J�J�L�L�	L��w�q�z�Q�W�Q�Z����
+�+1�6�!�'�1�7�+C�+C�E�E�	E��n�Q�V�Q��
�3�3�G��)�
�;�q�w���=�=�=�	8��A�A���$�f�Q�W�g�6�6�8�8�
8�
�H�H�W�4�H�(�(��
�0��C��F�F�m�m����C��F�F�Q�J��B�/�/���3�3���x��{���h�q�1�u�o���	P�%0�1�_�"�+0��{�Q��+O�+O�(�(�%1�"�+0���1A�;�+O�+O�(��	A�+��"=�"=�%&�Y�/E�%F��%J�%J��5�<�<�Q�?�?�A�A�
A��	A���+A�!B�Q�!F�!F����6�!�Q�Y�'=�>�?�?�A�A�
A�
%&�I�.J�$K�!��F�#?�@��	�!������q�2�3�5�7H�I�I�I�����	3�
�a�D�D�D�A�F�1�2�2�D�D�D���Hr)NT)NNNNNNNN)TFFF)#�warningsr�numpyr-r�scipy.sparserrrrr	r
�scipy.sparse._sputilsr�scipy.linalgrr+�rrU�scikits.umfpackr!�ImportErrorr�__all__�UserWarningrrrArr[rrrrrrr�<module>r�s'������������������K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�K�4�4�4�4�4�4�$�$�$�$�$�$��������������%�%�%�%�%�%�%�������H�H�H������\�
�6�6�6��	�	�	�	�	��	�	�	�@M�@M�@M�D���>}
�}
�}
�}
�@�t���d�d�f�f�a7�a7�a7�a7�HJN�GK�[6�[6�[6�[6�|>�>�>�BIN�%*�J
�J
�J
�J
�J
�J
s�A�A�
A

Youez - 2016 - github.com/yon3zu
LinuXploit