a
    CCCfV                     @   s   d Z dZg dZddlZddlZddlmZ ddlm	Z	m
Z
mZ ddlmZ dd	lmZmZmZmZmZmZmZmZ G d
d de	eeZdd ZG dd dee
ZG dd deeZdS )zDictionary Of Keys based matrixzrestructuredtext en)	dok_array
dok_matrixisspmatrix_dok    N   )spmatrix)_spbasesparrayissparse)
IndexMixin)isdensegetdtypeisshape	isintlikeisscalarlikeupcastupcast_scalarcheck_shapec                       sD  e Zd ZdZdwddZdd Zdxdd	Zd
d Zejj	e_	ejj	e_	dd Z
dd ZdyddZdd Zdd ZdzddZdd Zdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd{d)d*Z fd+d,Zd-d. Zd/d0 Zd1d2 Zd3d4 Zd5d6 Zd7d8 Zd9d: Z d;d< Z!d=d> Z"d?d@ Z#dAdB Z$ fdCdDZ%dEdF Z&dGdH Z'dIdJ Z(dKdL Z)dMdN Z*dOdP Z+dQdR Z,dSdT Z-dUdV Z.dWdX Z/dYdZ Z0d[d\ Z1d]d^ Z2d| fd`da	Z3d}dbdcZ4ej4j	e4_	ddde Z5dfdg Z6ej6j	e6_	e7d~didjZ8ddkdlZ9ej9j	e9_	ddmdnZ:ej:j	e:_	ddodpZ;ej;j	e;_	dqdr Z<ej<j	e<_	ddudvZ=  Z>S )	_dok_basedokNFc              
   C   s|  t |  t| t}t|trPt||drPt||d| _i | _t	|t
d| _n(t|r|j| jkrv|rp| n|}n| }|d ur|j|dd}|j| _t|j|d| _|j| _nzt|}W n. ty } ztd|W Y d }~n
d }~0 0 |jdkrtd|jdkrF|d ur(||}d	d
 t|D | _|j| _n"| j||d }|j| _|j| _t|j|d| _d S )NZallow_1d)defaultFcopyzInvalid input format.   z(Expected rank <=2 dense array or matrix.r   c                 S   s   i | ]\}}|d kr||qS )r    ).0ivr   r   M/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/sparse/_dok.py
<dictcomp>4       z&_dok_base.__init__.<locals>.<dictcomp>dtype)r   __init__
isinstancer   tupler   r   _shape_dictr   floatr"   r	   formatr   todokastypeshapenpZasarray	Exception	TypeErrorndim	enumerate_coo_container)selfZarg1r,   r"   r   is_arrayedr   r   r   r#      s<    


 


z_dok_base.__init__c                 C   s   t dd S )Nz2Direct update to DOK sparse format is not allowed.)NotImplementedError)r3   valr   r   r   update<   s    z_dok_base.updatec                 C   s   |d urt dt| jS )Nz7_getnnz over an axis is not implemented for DOK format.)r7   lenr'   )r3   Zaxisr   r   r   _getnnz@   s
    z_dok_base._getnnzc                 C   s   t dd |  D S )Nc                 s   s   | ]}|d kV  qdS r   Nr   )r   xr   r   r   	<genexpr>H   r    z*_dok_base.count_nonzero.<locals>.<genexpr>)sumvaluesr3   r   r   r   count_nonzeroG   s    z_dok_base.count_nonzeroc                 C   s
   t | jS N)r:   r'   rA   r   r   r   __len__M   s    z_dok_base.__len__c                 C   s
   || j v S rC   r'   r3   keyr   r   r   __contains__P   s    z_dok_base.__contains__c                C   s   | j ||S rC   )r'   
setdefaultr3   rG   r   r   r   r   rI   S   s    z_dok_base.setdefaultc                C   s   | j |= d S rC   rE   rF   r   r   r   __delitem__V   s    z_dok_base.__delitem__c                 C   s
   | j  S rC   )r'   clearrA   r   r   r   rL   Y   s    z_dok_base.clearc                C   s   | j ||S rC   )r'   poprJ   r   r   r   rM   \   s    z_dok_base.popc                 C   s   t dd S )Nz*reversed is not defined for dok_array type)r/   rA   r   r   r   __reversed___   s    z_dok_base.__reversed__c                 C   s,   t | j dt |j }td| d S Nz and z unsupported operand type for |: type__name__r/   r3   otherZ
type_namesr   r   r   __or__b   s    z_dok_base.__or__c                 C   s,   t | j dt |j }td| d S rO   rP   rS   r   r   r   __ror__f   s    z_dok_base.__ror__c                 C   s,   t | j dt |j }td| d S rO   rP   rS   r   r   r   __ior__j   s    z_dok_base.__ior__c                 C   s
   | j  S rC   )r'   popitemrA   r   r   r   rX   n   s    z_dok_base.popitemc                 C   s
   | j  S rC   )r'   itemsrA   r   r   r   rY   q   s    z_dok_base.itemsc                 C   s
   | j  S rC   )r'   keysrA   r   r   r   rZ   t   s    z_dok_base.keysc                 C   s
   | j  S rC   )r'   r@   rA   r   r   r   r@   w   s    z_dok_base.values        c              
   C   s   || j v r| j | S t|r,| jdkr,|f}| jt|krJtd| dz|D ]}t|sPJ qPW n4 tttfy } ztd|W Y d}~n
d}~0 0 tdd t	|| j
D }tdd t	|| j
D rtd	| jdkr|d
 }| j ||S )z>This provides dict.get method functionality with type checkingr   zIndex z! length needs to match self.shapez%Index must be or consist of integers.Nc                 s   s&   | ]\}}|d k r|| n|V  qdS r<   r   r   r   Mr   r   r   r>      r    z _dok_base.get.<locals>.<genexpr>c                 s   s"   | ]\}}|d k p||kV  qdS r<   r   r\   r   r   r   r>      r    zIndex out of bounds.r   )r'   r   r0   r:   
IndexErrorAssertionErrorr/   
ValueErrorr%   zipr,   anyget)r3   rG   r   r   r5   r   r   r   rc   z   s"    

 
z_dok_base.getc                    s   | j dkrt |S t|tr4t|dkr4|d }ttjf}t||r|dk r^|| j	d 7 }|dk st|| j	d kr|t
d| |S t
dd S )Nr   r   r   index value out of boundsz4array/slice index for 1d dok_array not yet supported)r0   super__getitem__r$   r%   r:   intr-   integerr,   r^   _get_int)r3   rG   	INT_TYPES	__class__r   r   rg      s    



z_dok_base.__getitem__c                 C   s   | j || jdS Nr   r'   rc   r"   rQ   )r3   idxr   r   r   rj      s    z_dok_base._get_intc                 C   s   | j ||f| jdS rn   ro   r3   rowcolr   r   r   _get_intXint   s    z_dok_base._get_intXintc                 C   s   |  t||d |S Nr   _get_sliceXsliceslicerq   r   r   r   _get_intXslice   s    z_dok_base._get_intXslicec                 C   s   |  |t||d S ru   rv   rq   r   r   r   _get_sliceXint   s    z_dok_base._get_sliceXintc                 C   s$  | | jd \}}}| | jd \}}}t|||}	t|||}
t|	t|
f}t| d|d  |d  kr|| |	|
S | j|| jd}|  D ]}tt	|d | |\}}|dks|dk s||d krqtt	|d | |\}}|dks|dk s||d kr
q| j
| |j
||f< q|S )Nr   r   r   r!   )indicesr,   ranger:   _get_columnXarray_dok_containerr"   rZ   divmodrh   r'   )r3   rr   rs   Z	row_startZrow_stopZrow_stepZ	col_startZcol_stopZcol_stepZ	row_rangeZ	col_ranger,   newdokrG   r   rijZrjr   r   r   rw      s"    z_dok_base._get_sliceXslicec                 C   s   |  }| |g|S rC   Zsqueezer}   rq   r   r   r   _get_intXarray   s    z_dok_base._get_intXarrayc                 C   s   |  }| ||gS rC   r   rq   r   r   r   _get_arrayXint   s    z_dok_base._get_arrayXintc                 C   s$   t t|| jd  }| ||S rn   listr|   r{   r,   r}   rq   r   r   r   _get_sliceXarray   s    z_dok_base._get_sliceXarrayc                 C   s$   t t|| jd  }| ||S ru   r   rq   r   r   r   _get_arrayXslice   s    z_dok_base._get_arrayXslicec           	      C   sh   | j t|t|f| jd}t|D ]>\}}t|D ],\}}| j||fd}|r4||j||f< q4q$|S )Nr!   r   )r~   r:   r"   r1   r'   rc   )	r3   rr   rs   r   r   rr   cr   r   r   r   r}      s    z_dok_base._get_columnXarrayc                 C   s|   t tjt||\}}| j|j| jd}tt	|jd t	|jd D ],}| j
|| || fd}|rJ||j
|< qJ|S )Nr!   r   r   )mapr-   Z
atleast_2dZbroadcast_arraysr~   r,   r"   	itertoolsproductr|   r'   rc   )r3   rr   rs   r   r   r   rG   r   r   r   r   _get_arrayXarray   s    $z_dok_base._get_arrayXarrayc                    s   | j dkrt ||S t|tr6t|dkr6|d }ttjf}t||r|dk r`|| j	d 7 }|dk sv|| j	d kr~t
d| ||S t
dd S )Nr   r   r   rd   re   z-array index for 1d dok_array not yet provided)r0   rf   __setitem__r$   r%   r:   rh   r-   ri   r,   r^   _set_int)r3   rG   valuerk   rl   r   r   r      s    


z_dok_base.__setitem__c                 C   s&   |r|| j |< n|| j v r"| j |= d S rC   rE   )r3   rp   r=   r   r   r   r      s    
z_dok_base._set_intc                 C   s.   ||f}|r|| j |< n|| j v r*| j |= d S rC   rE   )r3   rr   rs   r=   rG   r   r   r   _set_intXint  s
    
z_dok_base._set_intXintc                 C   s   t tt| }t tt| }| }| jtt||| t|dkd D ]*}|| || f}| j| dkrV| j|= qVd S rn   )	r   r   rh   Zravelr'   r9   ra   r-   Znonzero)r3   rr   rs   r=   r   rG   r   r   r   _set_arrayXarray
  s    z_dok_base._set_arrayXarrayc                    s^  t |r`t| j|}| j| j|d tjdd | jD  D ]"}| j|d| }|r:| |< q:nt	|r>|j| jkr~t
dt| j|j}| j| j|d | j  _|jdkr| }n8| }| jdkrt|jd |j}ntt|j |j}tjdd	*  j fd
d|D  W d    n1 s20    Y  nt|rV|  |  ntS  S )Nr!   c                 S   s   g | ]}t |qS r   )r|   )r   r6   r   r   r   
<listcomp>  r    z%_dok_base.__add__.<locals>.<listcomp>r   z Matrix dimensions are not equal.r   r   ignore)Zoverc                 3   s"   | ]\}}| | | fV  qd S rC   r   r   kr   newr   r   r>   .  r    z$_dok_base.__add__.<locals>.<genexpr>)r   r   r"   r~   r,   r   r   r'   rc   r	   r`   r   r   r)   rY   tocoor0   ra   coordsdatar-   Zerrstater9   r   ZtodenseNotImplemented)r3   rT   	res_dtyperG   ZaijZo_itemsr   r   r   __add__  s2    



<
z_dok_base.__add__c                 C   s   | | S rC   r   r3   rT   r   r   r   __radd__5  s    z_dok_base.__radd__c                 C   sD   | j jdkrtd| j| j| j d}|jdd |  D  |S )Nbz2Negating a sparse boolean matrix is not supported.r!   c                 s   s   | ]\}}|| fV  qd S rC   r   r   r   r   r   r>   >  r    z$_dok_base.__neg__.<locals>.<genexpr>)r"   kindr7   r~   r,   r'   r9   rY   r3   r   r   r   r   __neg__8  s    z_dok_base.__neg__c                    s>   t | j }| j| j|d}|j fdd|  D  |S )Nr!   c                 3   s   | ]\}}||  fV  qd S rC   r   r   rT   r   r   r>   E  r    z(_dok_base._mul_scalar.<locals>.<genexpr>)r   r"   r~   r,   r'   r9   rY   r3   rT   r   r   r   r   r   _mul_scalarA  s    z_dok_base._mul_scalarc                    s   t j j}jdkrt rn jdkr<   @ }n   jd @ }|t fdd|D S t	 r|t fdd
 D S tS tjjd |d}
 D ]$\\}}}||  | |  7  < q|S )Nr   r   r   c                 3   s"   | ]}j |  j |  V  qd S rC   rE   )r   r   rT   r3   r   r   r>   R  r    z+_dok_base._matmul_vector.<locals>.<genexpr>c                 3   s   | ]\}} | | V  qd S rC   r   r   r   r   r   r>   T  r    r!   )r   r"   r0   r	   r)   rZ   r   r   r?   r   rY   r   r-   zerosr,   )r3   rT   r   rZ   resultr   r   r   r   r   r   _matmul_vectorH  s    

z_dok_base._matmul_vectorc           	         s   t | j j}| jdkr4t fdd| j D S | jd } jdkrN|fn| jd f}tj||d}|  D ]$\\}}}||  | |  7  < qr|S )Nr   c                 3   s   | ]\}}| |  V  qd S rC   r   )r   r   r   r   r   r   r>   c  r    z0_dok_base._matmul_multivector.<locals>.<genexpr>r   r!   )	r   r"   r0   r?   r'   rY   r,   r-   r   )	r3   rT   Zresult_dtyper]   Z	new_shaper   r   r   r   r   r   r   _matmul_multivector^  s    

z_dok_base._matmul_multivectorc                    s.   t  r*| j fdd|  D  | S tS )Nc                 3   s   | ]\}}||  fV  qd S rC   r   r   r   r   r   r>   o  r    z%_dok_base.__imul__.<locals>.<genexpr>r   r'   r9   rY   r   r   r   r   r   __imul__m  s    z_dok_base.__imul__c                    sR   t  rFt| j }| j| j|d}|j fdd|  D  |S |    S )Nr!   c                 3   s   | ]\}}||  fV  qd S rC   r   r   r   r   r   r>   w  r    z(_dok_base.__truediv__.<locals>.<genexpr>)	r   r   r"   r~   r,   r'   r9   rY   Ztocsrr   r   r   r   __truediv__s  s    z_dok_base.__truediv__c                    s.   t  r*| j fdd|  D  | S tS )Nc                 3   s   | ]\}}||  fV  qd S rC   r   r   r   r   r   r>   }  r    z)_dok_base.__itruediv__.<locals>.<genexpr>r   r   r   r   r   __itruediv__{  s    z_dok_base.__itruediv__c                 C   s
   t | S rC   )dict
__reduce__rA   r   r   r   r     s    z_dok_base.__reduce__r   c                    s"   | j dkrt |S tdd S )Nr   z diagonal requires two dimensions)r0   rf   diagonalr`   )r3   r   rl   r   r   r     s    
z_dok_base.diagonalc                 C   sh   | j dkr|  S |d ur*|dkr*td| j\}}| j||f| j|d}|jdd |  D  |S )Nr   )r   r   zvSparse arrays/matrices do not support an 'axes' parameter because swapping dimensions is the only logical permutation.)r"   r   c                 s   s"   | ]\\}}}||f|fV  qd S rC   r   r   leftrightr8   r   r   r   r>     r    z&_dok_base.transpose.<locals>.<genexpr>)	r0   r   r`   r,   r~   r"   r'   r9   rY   )r3   Zaxesr   r]   Nr   r   r   r   	transpose  s    

z_dok_base.transposec                 C   sX   | j dkr"|  }|j |_|S | j\}}| j||f| jd}dd |  D |_|S )zReturn the conjugate transpose.r   r!   c                 S   s$   i | ]\\}}}||ft |qS r   )r-   Zconjr   r   r   r   r     r    z(_dok_base.conjtransp.<locals>.<dictcomp>)	r0   r   r   	conjugater,   r~   r"   rY   r'   )r3   r   r]   r   r   r   r   
conjtransp  s    

z_dok_base.conjtranspc                 C   s$   | j | j| jd}|j| j |S Nr!   )r~   r,   r"   r'   r9   r   r   r   r   r     s    z_dok_base.copyr   c                C   s^   t ||}ttt|tr6tdd t| D }nt|d f}| |t|d}||_	|S )Nc                 s   s   | ]}t |d  V  qdS )r   N)max)r   rp   r   r   r   r>     r    z%_dok_base.fromkeys.<locals>.<genexpr>r   r!   )
r   fromkeysr$   nextiterr%   ra   r   rQ   r'   )clsiterabler   tmpr,   r   r   r   r   r     s    z_dok_base.fromkeysc                    s   | j dkr | j| j| jdS | jt| jd tj|  | jd}| j	dkr^t
|   n|  f}t fdd|D }| j||f| j| jd}d	|_|S )
Nr   r!   )maxvalr"   countr   c                 3   s   | ]}t j| d V  qdS )r   N)r-   fromiter)r   ZixZ	idx_dtypennzr   r   r>     r    z"_dok_base.tocoo.<locals>.<genexpr>)r,   r"   T)r   r2   r,   r"   Z_get_index_dtyper   r-   r   r@   r0   ra   rZ   r%   Zhas_canonical_format)r3   r   r   Zindsr   Ar   r   r   r     s     z_dok_base.tocooc                 C   s   |r|   S | S rC   r   r3   r   r   r   r   r*     s    z_dok_base.todokc                 C   s&   | j dkrtd| jddj|dS )Nr   z%tocsr() not valid for 1d sparse arrayFr   )r0   r7   r   tocscr   r   r   r   r     s    
z_dok_base.tocscc           	      G   s   t | t}t||d}t|t| jkr,t| jdkrh|d }t| jD ]}||krH| j|= qH|| _	d S |\}}| j\}}||k s||k rt| 
 D ]$\}}||ks||kr| j||f= q|| _	d S )Nr   r   rd   )r$   r   r   r:   r,   r7   r0   r   r'   r&   rZ   )	r3   r,   r4   ZnewNr   ZnewMr]   r   r   r   r   r   resize  s$    



z_dok_base.resizeunsafeTc                 C   sb   t |}| j|krR| j| j|d}t jt| j |d}tt	| j||_|S |r^| 
 S | S r   )r-   r"   r~   r,   arrayr   r'   r@   r   ra   r   )r3   r"   Zcastingr   r   r   r   r   r   r+     s    

z_dok_base.astype)NNF)N)N)N)r[   )r   )NF)r   )F)F)F)r   T)?rR   
__module____qualname___formatr#   r9   r;   rB   r   __doc__rD   rH   rI   rK   rL   rM   rN   rU   rV   rW   rX   rY   rZ   r@   rc   rg   rj   rt   ry   rz   rw   r   r   r   r   r}   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   classmethodr   r   r*   r   r   r+   __classcell__r   r   rl   r   r      s   
(





	










r   c                 C   s
   t | tS )a  Is `x` of dok_array type?

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

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

    Examples
    --------
    >>> from scipy.sparse import dok_array, dok_matrix, coo_matrix, isspmatrix_dok
    >>> isspmatrix_dok(dok_matrix([[5]]))
    True
    >>> isspmatrix_dok(dok_array([[5]]))
    False
    >>> isspmatrix_dok(coo_matrix([[5]]))
    False
    )r$   r   )r=   r   r   r   r      s    r   c                   @   s   e Zd ZdZdS )r   a!  
    Dictionary Of Keys based sparse array.

    This is an efficient structure for constructing sparse
    arrays incrementally.

    This can be instantiated in several ways:
        dok_array(D)
            where D is a 2-D ndarray

        dok_array(S)
            with another sparse array or matrix S (equivalent to S.todok())

        dok_array((M,N), [dtype])
            create the array with initial shape (M,N)
            dtype is optional, defaulting to dtype='d'

    Attributes
    ----------
    dtype : dtype
        Data type of the array
    shape : 2-tuple
        Shape of the array
    ndim : int
        Number of dimensions (this is always 2)
    nnz
        Number of nonzero elements
    size
    T

    Notes
    -----

    Sparse arrays can be used in arithmetic operations: they support
    addition, subtraction, multiplication, division, and matrix power.

    - Allows for efficient O(1) access of individual elements.
    - Duplicates are not allowed.
    - Can be efficiently converted to a coo_array once constructed.

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.sparse import dok_array
    >>> S = dok_array((5, 5), dtype=np.float32)
    >>> for i in range(5):
    ...     for j in range(5):
    ...         S[i, j] = i + j    # Update element

    N)rR   r   r   r   r   r   r   r   r     s   r   c                   @   sL   e Zd ZdZdd Zdd ZeeedZdd Zd	d
 Z	dd Z
dd ZdS )r   a/  
    Dictionary Of Keys based sparse matrix.

    This is an efficient structure for constructing sparse
    matrices incrementally.

    This can be instantiated in several ways:
        dok_matrix(D)
            where D is a 2-D ndarray

        dok_matrix(S)
            with another sparse array or matrix S (equivalent to S.todok())

        dok_matrix((M,N), [dtype])
            create the matrix with initial shape (M,N)
            dtype is optional, defaulting to dtype='d'

    Attributes
    ----------
    dtype : dtype
        Data type of the matrix
    shape : 2-tuple
        Shape of the matrix
    ndim : int
        Number of dimensions (this is always 2)
    nnz
        Number of nonzero elements
    size
    T

    Notes
    -----

    Sparse matrices can be used in arithmetic operations: they support
    addition, subtraction, multiplication, division, and matrix power.

    - Allows for efficient O(1) access of individual elements.
    - Duplicates are not allowed.
    - Can be efficiently converted to a coo_matrix once constructed.

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.sparse import dok_matrix
    >>> S = dok_matrix((5, 5), dtype=np.float32)
    >>> for i in range(5):
    ...     for j in range(5):
    ...         S[i, j] = i + j    # Update element

    c                 C   s"   | j |dd| j}|j| _d S )NFr   )ZreshapeZasformatr)   __dict__)r3   r,   Z
new_matrixr   r   r   	set_shape  s    zdok_matrix.set_shapec                 C   s   | j S )zGet shape of a sparse matrix.)r&   rA   r   r   r   	get_shape  s    zdok_matrix.get_shape)fgetfsetc                 C   s
   | j  S rC   )r'   rN   rA   r   r   r   rN     s    zdok_matrix.__reversed__c                 C   s    t |tr| j|jB S | j|B S rC   r$   r   r'   r   r   r   r   rU     s    
zdok_matrix.__or__c                 C   s    t |tr| j|jB S | j|B S rC   r   r   r   r   r   rV     s    
zdok_matrix.__ror__c                 C   s.   t |tr|  j|jO  _n|  j|O  _| S rC   r   r   r   r   r   rW     s    
zdok_matrix.__ior__N)rR   r   r   r   r   r   propertyr,   rN   rU   rV   rW   r   r   r   r   r   P  s   3r   )r   __docformat____all__r   numpyr-   Z_matrixr   _baser   r   r	   _indexr
   Z_sputilsr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   <module>   s   (   r5