U
    9%ebw                    @   s  d dl Z d dlZd dlmZmZ d dlZd dlZd dlmZm	Z	 d dl
Z
d dl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 ddlmZ d dlZd	d
 Zdd Zdd ZG dd deeZdd Z dd Z!dd Z"dd Z#dd Z$dd Z%ddddZ&dd  Z'ded"d#Z(d$d% Z)dfd'd(Z*d)d* Z+d+d, Z,dgd-d.Z-dhd/d0Z.did1d2Z/d3d4 Z0djd5d6Z1d7d8 Z2dkd9d:Z3d;d< Z4G d=d> d>eeZ5G d?d@ d@eZ6G dAdB dBe5Z7G dCdD dDe5Z8G dEdF dFe5Z9G dGdH dHe5Z:G dIdJ dJe5Z;G dKdL dLe5Z<G dMdN dNe<Z=G dOdP dPe<Z>G dQdR dRe5Z?G dSdT dTe5Z@G dUdV dVe<ZAG dWdX dXe5ZBG dYdZ dZe<ZCG d[d\ d\e5ZDG d]d^ d^e5ZEG d_d` d`e<ZFG dadb dbeZGeHdckreI  dS )l    N)productcycle)NumberIntegral)jitnjittypeof)errors)TestCasetagneeds_lapack
needs_blas
_is_armv7lEnableNRTStatsMixin   )matmul_usecasec                 C   s   t | |S Nnpdotab r   V/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/numba/tests/test_linalg.pydot2   s    r   c                 C   s   t j| ||dS Noutr   r   r   r   r   r   r   dot3   s    r    c                 C   s   t | |S r   )r   vdotr   r   r   r   r!      s    r!   c                       s   e Zd ZdZejejejejfZ	 fddZ
dd Zdd Zejdd	 Zd
d Zdd Zdd Zd,ddZd-ddZdd Zedd Zedd Zdd Zedd Zd d! Zed"d# Zed$d% Zed&d' Zed(d) Zed*d+ Z   Z!S ).TestProductz!
    Tests for dot products.
    c                    s   t   tt|   d S r   )gccollectsuperr"   setUpself	__class__r   r   r&   &   s    zTestProduct.setUpc                 C   s>   t |}t|t jr(|d d |S |d d |S d S Ny      ?      y               @g      ?r   r   arange
issubclassZcomplexfloatingastyper(   ndtypebaser   r   r   sample_vector+   s    
zTestProduct.sample_vectorc                 C   s   |  || |||fS r   )r4   reshape)r(   mr1   r2   r   r   r   sample_matrix4   s    zTestProduct.sample_matrixc              	   c   s   t jdd}t dtj dV  W 5 Q R X | t|d | |d jtj | 	dt
|d j | |d j|jj | |d j|jjd  dS )zB
        Check performance warning(s) for non-contiguity.
        T)recordalwaysNr   r   zfaster on contiguous arrays)warningscatch_warningssimplefilterr	   ZNumbaPerformanceWarningZassertGreaterEquallenassertIscategoryassertInstrmessageassertEqualfilename__code__co_filenamelinenoco_firstlineno)r(   pyfuncwr   r   r   check_contiguity_warning7   s    z$TestProduct.check_contiguity_warningc              	   C   s<   |   * || }|| }| j||dd ~~W 5 Q R X d S )NTZignore_sign_on_zero)assertNoNRTLeakassertPreciseEqual)r(   rI   cfuncargsexpectedgotr   r   r   
check_funcF   s
    
zTestProduct.check_funcc                 C   s   |j d |j d }|j |j }tj|tjd}t|jd D ]*}||||  j|jd}|jj	r> qrq>t
d|jjrtj||jdd}ntj||jdd}|d d  |d d < |jj	st|S )Nr   r2   zCould not obtain aligned arrayCorderF)sizeitemsizer   emptyZuint8rangeviewr2   flagsZaligned	Exceptionc_contiguousr5   shapeAssertionError)r(   ZarrrY   Zdatasizetmpinewr   r   r   _aligned_copyN   s    zTestProduct._aligned_copyc              	   C   sx   t r
| jntj}|  V ||}||}| ||d|i| | ||d|i| | j||dd ~~W 5 Q R X d S )Nr   TrL   )r   rf   r   copyrM   r>   rN   )r(   rI   rO   rP   r   copierrQ   rR   r   r   r   check_func_outc   s    
zTestProduct.check_func_outFc              	   C   s@   |  t}||  W 5 Q R X |r&dnd}| |t|j d S )Nzincompatible output array sizezincompatible array sizes)assertRaises
ValueErrorr@   rA   	exception)r(   rO   rP   is_outraisesmsgr   r   r   assert_mismatching_sizesm   s    z$TestProduct.assert_mismatching_sizesnp.dot()c              	   C   s<   |  tj}||  W 5 Q R X | d|f t|j d S )Nz)%s arguments must all have the same dtype)rj   r	   TypingErrorr@   rA   rl   )r(   rO   rP   	func_namern   r   r   r   assert_mismatching_dtypest   s    z%TestProduct.assert_mismatching_dtypesc              
   C   s   d}t dd|}| jD ]T}| ||}| ||}| ||||f | |||d d d |d d d f q| |d tj}| |tj}| |||f | |tj}| |tj}| j|||f|d d S )N   TZnopythonr   )rs   )	r   dtypesr4   rS   r   float64rp   float32rt   )r(   rI   rs   r1   rO   r2   r   r   r   r   r   check_dot_vv{   s    
(zTestProduct.check_dot_vvc                 C   s   |  td dS )z/
        Test vector * vector np.dot()
        rq   N)r{   r   r'   r   r   r   test_dot_vv   s    zTestProduct.test_dot_vvc                 C   s   |  td dS )z 
        Test np.vdot()
        z	np.vdot()N)r{   r!   r'   r   r   r   	test_vdot   s    zTestProduct.test_vdotc                    s4   fdd}t dd|}|d k	r0t dd|}dD ]\}}|||D ].\}	}
 |||	|
f  |||
|	jf qF|d k	r4|||D ]B\}	}
tj||	jd} |||	|
f|  |||
|	jf| qq4d\}} ||d tj}	 	|tj}
 
||	|
f  
||
|	jf |d k	rt|tj} 
||	|
|f  
||
|	j|f  ||tj}	 	|tj}
t|d tj} j
||	|
|fdd	  j
||
|	j|fdd	  ||tj}	 	|tj}
 ||	|
f| |d k	r0 ||tj}	 	|tj}
t|tj} ||	|
|f| d S )
Nc                 3   s   dD ]4}  | |tjj|d} |tj}||fV  q jD ](}  | ||} ||}||fV  q@|d d d |d d d fV  d S NCFrV   rw   )r7   r   ry   rg   r4   rx   )r6   r1   rW   r   r   r2   r'   r   r   samples   s    
z)TestProduct.check_dot_vm.<locals>.samplesTrv   )   ru   )ru   r   )r   ru   rT   r   r   rm   )r   rS   Tr   r[   r2   ri   r7   ry   r4   rp   rz   rt   )r(   pyfunc2pyfunc3rs   r   cfunc2cfunc3r6   r1   r   r   r   r   r'   r   check_dot_vm   sF    

zTestProduct.check_dot_vmc                 C   s   |  ttd dS )zC
        Test vector * matrix and matrix * vector np.dot()
        rq   N)r   r   r    r'   r   r   r   test_dot_vm   s    zTestProduct.test_dot_vmc                    s.   fdd}t dd|}|d k	r0t dd|}dD ]\}}}	||||	D ]0\}
} |||
|f  |||j|
jf qJ|d k	r4||||	D ]\\}
}tj||f|
jd} |||
|f| tj||f|
jd} |||j|
jf| qq4d\}}}	 ||	d tj}
 |	|tj} 	||
|f |d k	rt||ftj} 	||
||f  ||	tj}
 |	|tj}t||d ftj} j	||
||fdd	  ||	tj
}
 |	|tj} ||
|f| |d k	r* ||	tj}
 |	|tj}t||ftj
} ||
||f| d S )
Nc                 3   s   t ddD ]B\}} | |tjj|d} ||tjj|d}||fV  q
 jD ]*} | ||} |||}||fV  qT|d d d |d d d fV  d S r~   )r   r7   r   ry   rg   rx   )r6   r1   kZorder_aZorder_br   r   r2   r'   r   r   r      s    
z)TestProduct.check_dot_mm.<locals>.samplesTrv   )r   ru      )r   ru   r   )r   r   r   )r   ru   r   )ru   r   r   )r   r   ru   )ru   r   r   rT   r   r   r   )r   rS   r   r   r[   r2   ri   r7   ry   rp   rz   rt   )r(   r   r   rs   r   r   r   r6   r1   r   r   r   r   r   r'   r   check_dot_mm   sB    


zTestProduct.check_dot_mmc                 C   s   |  ttd dS )z/
        Test matrix * matrix np.dot()
        rq   N)r   r   r    r'   r   r   r   test_dot_mm  s    zTestProduct.test_dot_mmc                 C   s   |  td dS )z&
        Test vector @ vector
        '@'N)r{   r   r'   r   r   r   test_matmul_vv   s    zTestProduct.test_matmul_vvc                 C   s   |  tdd dS )z:
        Test vector @ matrix and matrix @ vector
        Nr   )r   r   r'   r   r   r   test_matmul_vm'  s    zTestProduct.test_matmul_vmc                 C   s   |  tdd dS )z&
        Test matrix @ matrix
        Nr   )r   r   r'   r   r   r   test_matmul_mm.  s    zTestProduct.test_matmul_mmc           	   	   C   s  d\}}}t j}| |||d d d }| |||d d d }t ||f|}tddt}| |j ||| W 5 Q R X tddt}| |j |||| W 5 Q R X | 	||d d d }| 	||d d d }tddt
}| |j ||| W 5 Q R X d S )Nr   rw   Trv   )r   ry   r7   r[   r   r   rK   py_funcr    r4   r!   )	r(   r6   r   r1   r2   r   r   r   rO   r   r   r   test_contiguity_warnings5  s     
z$TestProduct.test_contiguity_warnings)F)rq   )"__name__
__module____qualname____doc__r   ry   rz   
complex128	complex64rx   r&   r4   r7   
contextlibcontextmanagerrK   rS   rf   ri   rp   rt   r{   r   r|   r}   r   r   r   r   r   r   r   r   __classcell__r   r   r)   r   r"      s>   	





8
>



r"   c                 C   s   t j| S r   r   linalginvr   r   r   r   invert_matrixN  s    r   c                 C   s   t j| S r   )r   r   choleskyr   r   r   r   cholesky_matrixR  s    r   c                 C   s   t j| S r   )r   r   eigr   r   r   r   
eig_matrixV  s    r   c                 C   s   t j| S r   )r   r   eigvalsr   r   r   r   eigvals_matrixZ  s    r   c                 C   s   t j| S r   )r   r   eighr   r   r   r   eigh_matrix^  s    r   c                 C   s   t j| S r   )r   r   eigvalshr   r   r   r   eigvalsh_matrixb  s    r   c                 C   s   t j| |S r   r   r   svd)r   full_matricesr   r   r   
svd_matrixf  s    r   c                 C   s   t j| S r   r   r   qrr   r   r   r   	qr_matrixj  s    r   rw   c                 C   s   t j| ||S r   r   r   lstsq)ABrcondr   r   r   lstsq_systemn  s    r   c                 C   s   t j| |S r   r   r   solve)r   r   r   r   r   solve_systemr  s    r   V瞯<c                 C   s   t j| S r   r   r   pinv)r   r   r   r   r   pinv_matrixv  s    r   c                 C   s   t j| S r   r   r   slogdetr   r   r   r   slogdet_matrixz  s    r   c                 C   s   t j| S r   )r   r   detr   r   r   r   
det_matrix~  s    r   c                 C   s   t j| |S r   )r   r   norm)r   ordr   r   r   norm_matrix  s    r   c                 C   s   t j| |S r   )r   r   cond)r   pr   r   r   cond_matrix  s    r   c                 C   s   t j| |S r   r   r   matrix_rank)r   tolr   r   r   matrix_rank_matrix  s    r   c                 C   s   t j| |S r   )r   r   matrix_power)r   r1   r   r   r   matrix_power_matrix  s    r   c                 C   s   t | |S r   r   trace)r   offsetr   r   r   trace_matrix  s    r   c                 C   s
   t | S r   r   r   r   r   r   trace_matrix_no_offset  s    r   c                 C   s   t j| ||dS r   )r   outerr   r   r   r   outer_matrix  s    r   c                 C   s   t | |S r   )r   kronr   r   r   r   kron_matrix  s    r   c                       s   e Zd ZdZejejejejfZ	 fddZ
dd ZdddZefd	d
Zdd Zdd ZdddZdd Zdd Zdd Zd ddZdd Zdd Z  ZS )!TestLinalgBasezU
    Provides setUp and common data/error modes for testing np.linalg functions.
    c                    s   t   tt|   d S r   )r#   r$   r%   r   r&   r'   r)   r   r   r&     s    zTestLinalgBase.setUpc                 C   s>   t |}t|t jr(|d d |S |d d |S d S r+   r,   r0   r   r   r   r4     s    
zTestLinalgBase.sample_vectorNc                 C   s  d}t |dkrtd|dkr(td|tjtjtjtjfkrHtd|dk	r`|dk	r`td|dkrl|}|d	k r|td
tjd |\}}|dk s|dk rtdt	||}	|dkr|	}
n6|dkrtdt
|tstd|}
||	krtd|d	ks
|d	kr<||krtdt||}| ||||}n| || |||}tj|\}}| || |ddd ||}tj|\}}t|||
}t||f}tt||}|||d d|
 |d	 d|
 f< tt|||j}tj|||d}|S )a  
        Provides a sample matrix with an optionally specified rank or condition
        number.

        size: (rows, columns), the dimensions of the returned matrix.
        dtype: the dtype for the returned matrix.
        order: the memory layout for the returned matrix, 'F' or 'C'.
        rank: the rank of the matrix, an integer value, defaults to full rank.
        condition: the condition number of the matrix (defaults to 1.)

        NOTE: Only one of rank or condition may be set.
              ?r   size must be a length 2 tuple.)rX   rU    order must be one of 'F' or 'C'.*dtype must be a numpy floating point type.N/Only one of rank or condition can be specified.r   Condition number must be >=1.r   +Negative dimensions given for matrix shape.Rank must be greater than zero.Rank must an integer."Rank given greater than full rank.8Condition number was specified for a vector (always 1.).rw   r2   rW   )r=   rk   r   rz   ry   r   r   randomseedmin
isinstancer   maxr4   r5   r   r   Zlinspacezerosnonzeroeyer   r   array)r(   rY   r2   rW   rank	conditionZd_condr6   r1   minmnrvZmaxmnQrc   U_VsvSidxr   r   r   specific_sample_matrix  sZ    



"$z%TestLinalgBase.specific_sample_matrixc              	   C   s4   |  |}||  W 5 Q R X | |t|j d S r   )rj   r@   rA   rl   )r(   rO   rP   ro   errrn   r   r   r   assert_error  s    zTestLinalgBase.assert_errorc                 C   s   d}|  |||tjj d S )Nz.Last 2 dimensions of the array must be square.r   r   r   ZLinAlgErrorr(   rO   rP   ro   r   r   r   assert_non_square  s    z TestLinalgBase.assert_non_squarec                 C   s   d| }|  |||tj d S )Nz9np.linalg.%s() only supported on float and complex arraysr   r	   rr   r(   namerO   rP   ro   r   r   r   assert_wrong_dtype  s    z!TestLinalgBase.assert_wrong_dtypeTc                 C   s.   |rdnd}d||f }|  |||tj d S )N	np.linalgr   z$%s.%s() only supported on 2-D arraysr  r(   r  rO   rP   Z	la_prefixprefixro   r   r   r   assert_wrong_dimensions  s    z&TestLinalgBase.assert_wrong_dimensionsc                 C   s   d}|  |||tjj d S )Nz$Array must not contain infs or NaNs.r   r  r   r   r   assert_no_nan_or_inf  s    z#TestLinalgBase.assert_no_nan_or_infc                 C   s   t |tr"|D ]}| || qnft |ts|jj}|jj}d}| ||B | d}|dkrj| || n|dkr| || ntddS )a6  
        This checks that in a computed result from numba (array, possibly tuple
        of arrays) all the arrays are contiguous in memory and that they are
        all at least one of "C_CONTIGUOUS" or "F_CONTIGUOUS". The computed
        result of the contiguousness is then compared against a hardcoded
        expected result.

        got: is the computed results from numba
        expected_contig: is "C" or "F" and is the expected type of
                        contiguousness across all input values
                        (and therefore tests).
        z6Results are not at least one of all C or F contiguous.z0Computed contiguousness does not match expected.rU   rX   zUnknown contigN)	r   tupleassert_contig_sanityr   r^   r`   f_contiguous
assertTruerk   )r(   rR   Zexpected_contigr   Zc_contigZf_contigro   r   r   r   r  "  s    

z#TestLinalgBase.assert_contig_sanityc                 C   s   d}| j |||tjjd d S )Nz(Matrix is singular to machine precision.r   r   r  r   r   r   assert_raise_on_singularG  s    z'TestLinalgBase.assert_raise_on_singularc                 C   sv   |  |jd |jd  tj|jd |jd}dt|jj }|dkrPd| }|dkr`d| }tj|||| dS )zE
        Checks if a matrix is equal to the identity matrix.
        rw   rT      N
   d   )	rC   ra   r   r   r2   finfo
resolutiontestingassert_allclose)r(   rR   rtolatolr   r  r   r   r   assert_is_identity_matrixK  s    z(TestLinalgBase.assert_is_identity_matrixc                 C   s   d}|  |||t dS )z5
        For use in norm() and cond() tests.
        z Invalid norm order for matrices.N)r   rk   r  r   r   r   assert_invalid_norm_kind[  s    z'TestLinalgBase.assert_invalid_norm_kindc                 C   s   d}|  |||tjj d S )NzArrays cannot be emptyr   r  r   r   r   assert_raise_on_emptyb  s    z$TestLinalgBase.assert_raise_on_empty)NN)T)NN)r   r   r   r   r   ry   rz   r   r   rx   r&   r4   r   rk   r   r  r  r
  r  r  r  r  r  r  r   r   r   r)   r   r     s"   
   
T
%
r   c                   @   s   e Zd ZdZdd ZdS )TestTestLinalgBasez
    The sample matrix code TestLinalgBase.specific_sample_matrix()
    is a bit involved, this class tests it works as intended.
    c              	      s  t d dddddg}t| jdD ] \}}}|\}}t||} |||}|j| tj	|| |dkr|d }	 j||||	d	}|j| tj	||	 d
t
|j }
 |||}|j| tjjtj|d|
|
d |dkr$d} j||||d}|j| tjjtj|d|
|
d q$tf fdd	}t }d}|dtjdf|td W 5 Q R X d}|dtjdf|td d}|dtjdf|td d}|dtjdf|td d}|dtjdddf|td d}|dtjdd df|td d}|dtjdf|td d}|dtjddf|td d }|dtjdd!f|td d"}|d#tjdd d$f|td d%}|dtjdd&f|td d S )'Nr      r      r  r  r#  ru   ru   r   r!  FCr   r   r  r   r  r        $@r   c              	      s6    |} j|   W 5 Q R X |t|j d S r   )rj   r   r@   rA   rl   )rP   ro   r   rn   instr(   r   r   check_error  s    zCTestTestLinalgBase.test_specific_sample_matrix.<locals>.check_errorblankr   rX   r  r   r   r   zr   r   r   rw   r   )r   r   r   r   r   )r   ru   r  r   g      ?)r   r   rx   r   r   rC   ra   r   r   r   r  r  r  r  r   rk   rj   rb   ry   int32)r(   sizesrY   r2   rW   r6   r1   r   r   r   r  r   r.  rn   ro   r   r,  r   test_specific_sample_matrixm  sv    
    z.TestTestLinalgBase.test_specific_sample_matrixN)r   r   r   r   r5  r   r   r   r   r  g  s   r  c                   @   s(   e Zd ZdZedd Zedd ZdS )TestLinalgInvz"
    Tests for np.linalg.inv.
    c                    s   d}t ddt  fdd}tjdD ]"\}}||f||}|| q,|td  tdf 	d	 tjd
tj
df d	 tdf  td
f dS )z$
        Test np.linalg.inv
        r  Trv   c              	      s   t | } | }|d d}ztjj||dd W n tk
rN   d}Y nX |rjt|| }|    |  W 5 Q R X d S )NrX   Fr  ZnulpT)	r   r  r   r  assert_array_almost_equal_nulprb   r   r  rM   )r   kwargsrQ   rR   use_reconstructionrecrO   r(   r   r   check  s    




z,TestLinalgInv.test_linalg_inv.<locals>.checkr   r   r   r   r   r   r   rT   N)r   r   r   rx   r   r   r[   r  onesr  r3  r
  r  r   )r(   r1   r=  r2   rW   r   r   r<  r   test_linalg_inv  s    
zTestLinalgInv.test_linalg_invc                 C   s   t jddddgddddgddd	d	gdd
ddggdd}t |}tdddd }||d}t j|| ||d}t j|| t j|| d S )Nr   ru   r   r!  r   	   r2  r   r     rX   rV   Trv   c                 S   s$   |r| ddd d f } t j| S Nr   r   r   Xtestr   r   r   ainv  s    z2TestLinalgInv.test_no_input_mutation.<locals>.ainvFr   r   rg   r   r   r  r  )r(   rG  X_origrI  rQ   rR   r   r   r   test_no_input_mutation	  s    





z$TestLinalgInv.test_no_input_mutationN)r   r   r   r   r   rA  rL  r   r   r   r   r6    s
   
2r6  c                   @   s,   e Zd ZdZdd Zdd Zedd ZdS )	TestLinalgCholeskyz'
    Tests for np.linalg.cholesky.
    c           	      C   sj   t jd t j||}t j|\}}t d|d }t t |jt 	||}t j
|||d}|S )Nr   r   r   )r   r   r   randr   r   r-   r   r   diagr   )	r(   r6   r2   rW   r   qr   Lr   r   r   r   r7   '  s    z TestLinalgCholesky.sample_matrixc                 C   s   d}|  |||tjj d S )Nz Matrix is not positive definite.r   r  r   r   r   assert_not_pd3  s    z TestLinalgCholesky.assert_not_pdc                    s   d}t ddt  fdd}tjdD ]\}}|||}|| q,|td d} tjd	tj	d
f 
| tjdtjd
f | tjdtj	d
f  tjdtj	d
ddf dS )z)
        Test np.linalg.cholesky
        r  Trv   c              	      s   t | } | }d}|d ztjj||dd W n tk
rN   d}Y nX |rt|t|j}dt	| j
j }tjj| |||d    |  W 5 Q R X d S )NFrU   r  r7  Tr  r)  )r   r  r   r  r8  rb   r   conjr   r  r2   r  r  rM   )r   rQ   rR   r:  r;  r  r<  r   r   r=  ?  s*    



z6TestLinalgCholesky.test_linalg_cholesky.<locals>.checkr'  r>  r   r   rT   r?  r   r   N)r   r   r   rx   r7   r   r[   r  r@  ry   r  r3  r
  rR  r5   )r(   r1   r=  r2   rW   r   rnr   r<  r   test_linalg_cholesky7  s$    
z'TestLinalgCholesky.test_linalg_choleskyN)r   r   r   r   r7   rR  r   rU  r   r   r   r   rM  "  s
   rM  c                   @   sn   e Zd ZdZdd Zdd Zdd Zdd	d
Zedd Z	edd Z
edd Zedd Zedd ZdS )TestLinalgEigenSystemsz*
    Tests for np.linalg.eig/eigvals.
    c                 C   s   |  ||}t|}tt|jd |jd d}|dd  ||< tt|jd |jd d}|d d ||< tj|||d}|S )Nr   r   rw   r   )r4   r   rO  r   r   ra   r   )r(   r6   r2   rW   vr   r   r   r   r   r7   z  s    
  z$TestLinalgEigenSystems.sample_matrixc                 C   s   |d }|  ||| d S )Nz+() argument must not cause a domain change.)r   r  r   r   r   assert_no_domain_change  s    z.TestLinalgEigenSystems.assert_no_domain_changec                    s    fdd}|S )Nc               	      s   j |  } |  }| d }t|t| d}t|trRd}t| n|j |d d}tt|D ]<}ztj	j
|| || dd W q| tk
r   d}Y q|X q|dt|jj }|r|r|\}}	d d	krhtt|jd |jd
 d}
tt|jd |jd
 d
} |   t||
 ||< tt||t|jd < t||	}t|	t|}tj	j|j|j||d t|	rtj	j|j|j||d n tj	jt|t|||d    |   W 5 Q R X d S )Nr   FTrX   r  r7  r  rw   hr   r)  )r   rC   r=   r   r  ndimr  r\   r   r  r8  rb   r  r2   r  r   r   ra   rS  realrO  Zdiag_indicesr   r  iscomplexobjimagsortrM   )rP   rQ   rR   r   Zres_is_tupler:  r   r  rJ   rW  ZidxlZidxulhsrhsrO   expected_res_lenr  r(   r   r   r=    sj    

  
   
z3TestLinalgEigenSystems._check_worker.<locals>.checkr   )r(   rO   r  rb  check_for_domain_changer=  r   ra  r   _check_worker  s    \z$TestLinalgEigenSystems._check_workerNc              	   C   s`  d}t dd|}| ||||}t| jdD ]\}}	| |||	}
||
 q.tjtjfD ]}|tjd|d | 	|tj
d|df | ||tj
dtjdf | ||tj
d|df | |tjd	d
gtjtjgg|df qZ|r\tddgddgg}||tj ||\}}| t|j tjtjfD ]}| ||||f q>dS )z$
        Test np.linalg.eig
        r  Trv   r'  r>  rT   r   r?  r          @r   r  r   N)r   rd  r   rx   r7   r   rz   r   r[   r  r@  r  r3  r
  r  r   infnanr/   r   r  anyr]  ry   rX  )r(   r  funcrb  rc  r1   rO   r=  r2   rW   r   tyr   lr   r   r   r   checker_for_linalg_eig  s6    

z-TestLinalgEigenSystems.checker_for_linalg_eigc                 C   s   |  dtdd d S )Nr   r   T)rl  r   r'   r   r   r   test_linalg_eig'  s    z&TestLinalgEigenSystems.test_linalg_eigc                 C   s   |  dtdd d S )Nr   r   T)rl  r   r'   r   r   r   test_linalg_eigvals+  s    z*TestLinalgEigenSystems.test_linalg_eigvalsc                 C   s   |  dtdd d S )Nr   r   F)rl  r   r'   r   r   r   test_linalg_eigh/  s    z'TestLinalgEigenSystems.test_linalg_eighc                 C   s   |  dtdd d S )Nr   r   F)rl  r   r'   r   r   r   test_linalg_eigvalsh3  s    z+TestLinalgEigenSystems.test_linalg_eigvalshc                    s   dD ]}|\}}}t tj| tdd fdd}| ||||}tjtjfD ]}| j |d tjddd	dgdd
d	d	gd	d	dd	gdd	d	dggd|d}t	|}	|
|d}
tj||	 ||d}tj||	 ||d W 5 Q R X qPqd S )N))r   r   T)r   r   T)r   r   F)r   r   FTrv   c                    s    |r| ddd d f }  | S rE  r   rF  methr   r   ri  D  s    z;TestLinalgEigenSystems.test_no_input_mutation.<locals>.func)rr  r2   r*  r   r   rC  rD  r!  rX   )rW   r2   F)getattrr   r   r   rd  ry   r   ZsubTestr   rg   r   r  r  )r(   cr6   ZnoutZdomain_changeri  r=  r2   rG  rK  rQ   rR   r   rq  r   rL  7  s,    



 

z-TestLinalgEigenSystems.test_no_input_mutation)N)r   r   r   r   r7   rX  rd  rl  r   rm  rn  ro  rp  rL  r   r   r   r   rV  u  s    a 
>



rV  c                   @   s0   e Zd ZdZdd Zedd Zedd ZdS )	TestLinalgSvdz"
    Tests for np.linalg.svd.
    c                 C   s   |\}}}t t|D ]}| || j|| j qt|jd |jd f}t|| tt|||}	t|j	j
}
tjj||	d|
 d|
 d d S )Nr   r   r  r  r)  )r\   r=   rC   ra   r   r   Zfill_diagonalr   r  r2   r  r  r  )r(   r   rR   rQ   ur   vtr   sr;  r  r   r   r   check_reconstructionm  s    
z"TestLinalgSvd.check_reconstructionc                    s   t ddt  fdd}ddddd	g}d
}t|j|dD ]&\}}}}|||}|||d q>d}	|	 tjdtjdf 	|	 tjdtj
df  tjddgtjtjggtj
df dD ]}
t|
df} | qdS )z$
        Test np.linalg.svd
        Trv   c              	      s   t | f|} | f|}t|t| t|d |d d}tt|D ]<}ztjj|| || dd W qX tk
r   d}Y qXX qX|r	| || 
   | f| W 5 Q R X d S )Nru   rX   Fr  r7  T)r   rC   r=   r  r\   r   r  r8  rb   ry  rM   )r   r9  rQ   rR   r:  r   r<  r   r   r=    s&      

z,TestLinalgSvd.test_linalg_svd.<locals>.checkr   )r!  r  )r  r!  r%  r&  )TFr'  )r   r   r?  rT   r  r   re  r   r   r   r   r>  N)r   r   r   rx   r   r  r   r@  r3  r
  ry   r  r   rf  rg  r[   r  )r(   r=  r4  r   rY   r2   ZfmatrW   r   rT  szrP   r   r<  r   test_linalg_svd  s.    zTestLinalgSvd.test_linalg_svdc                 C   s   t jddddgddddgddd	d	gdd
ddggdd}t |}tdddd }||d}t j|| ||d}t j|| z&t||D ]\}}t j|| qW n" tk
r   | 	||| Y nX d S )Nr   ru   r   r!  rB  r   rC  r2  r   r  rD  rX   rV   Trv   c                 S   s$   |r| ddd d f } t j| S rE  r   rF  r   r   r   ri    s    z2TestLinalgSvd.test_no_input_mutation.<locals>.funcF)
r   r   rg   r   r   r  r  ziprb   ry  r(   rG  rK  ri  rQ   rR   Ze_aZg_ar   r   r   rL    s&    





z$TestLinalgSvd.test_no_input_mutationN)r   r   r   r   ry  r   r~  rL  r   r   r   r   ru  b  s   

Cru  c                   @   s(   e Zd ZdZedd Zedd ZdS )TestLinalgQrz!
    Tests for np.linalg.qr.
    c           	         s   t ddt  fdd}ddddd	g}t|jd
D ] \}}}|||}|| q8d}| tjdtjdf 	| tjdtj
df  tjddgtjtjggtj
df dD ]} t|f qdS )z#
        Test np.linalg.qr
        Trv   c           
   	      sB  t | f|} | f|}t|t| t|d |d d}tt|D ]<}ztjj|| || dd W qX tk
r   d}Y qXX qX|r|\}}tt|D ]}|| j	|| j	 qt
||}t| jj}	tjj| |d|	 d|	 d t
t|j|    | f| W 5 Q R X d S )	Nr   rX   Fr  r7  Tr  r)  )r   rC   r=   r  r\   r   r  r8  rb   ra   r   r  r2   r  r  r  	conjugater   rM   )
r   r9  rQ   rR   r:  r   rP  rr;  r  r<  r   r   r=    s<      


z*TestLinalgQr.test_linalg_qr.<locals>.checkr   r"  r$  r%  r&  r'  r   r?  rT   r  r   re  rz  N)r   r   r   rx   r   r  r   r@  r3  r
  ry   r  r   rf  rg  r  r[   )	r(   r=  r4  rY   r2   rW   r   rT  r}  r   r<  r   test_linalg_qr  s*    7
zTestLinalgQr.test_linalg_qrc                 C   s   t jddddgddddgddd	d	gdd
ddggdd}t |}tdddd }||d}t j|| ||d}t j|| t||D ]\}}t j|| qd S )Nr   ru   r   r!  rB  r   rC  r2  r   r  rD  rX   rV   Trv   c                 S   s$   |r| ddd d f } t j| S rE  r   rF  r   r   r   ri  I  s    z1TestLinalgQr.test_no_input_mutation.<locals>.funcF)r   r   rg   r   r   r  r  r  r  r   r   r   rL  @  s     





z#TestLinalgQr.test_no_input_mutationN)r   r   r   r   r   r  rL  r   r   r   r   r    s
   
Xr  c                   @   s*   e Zd ZdZd
ddZdd Zdd Zd	S )TestLinalgSystemszu
    Base class for testing "system" solvers from np.linalg.
    Namely np.linalg.solve() and np.linalg.lstsq().
    Tc                 C   s.   |rdnd}d||f }|  |||tj d S )Nr  r   z*%s.%s() only supported on 1 and 2-D arraysr  r  r   r   r   assert_wrong_dimensions_1Da  s    z,TestLinalgSystems.assert_wrong_dimensions_1Dc                 C   s   d}|  |||tjj d S )Nz<Incompatible array sizes, system is not dimensionally valid.r   r  r   r   r   assert_dimensionally_invalidg  s    z.TestLinalgSystems.assert_dimensionally_invalidc                 C   s   d| }|  |||tj d S )NzAnp.linalg.%s() only supports inputs that have homogeneous dtypes.r  r  r   r   r   assert_homogeneous_dtypesl  s    z+TestLinalgSystems.assert_homogeneous_dtypesN)T)r   r   r   r   r  r  r  r   r   r   r   r  Z  s   
r  c                   @   s(   e Zd ZdZedd Zedd ZdS )TestLinalgLstsqz$
    Tests for np.linalg.lstsq.
    c                    s  t ddt  fddddddd	g}tj}d
dg}t|d}fdd}|D ]}t|}t}|||}	||	| |\}
}t|
|}|
dkr\|dkr\|d }j||||d}	||	| j||||d}	d| }|| }||	||d q\ddgddgddgddgg}|D ]*\}	}t|	t|f}	 | q tj
ddgddggtjd} ||ff d}tj
ddgdd ggtjd}| ||f | ||f tj
ddgdd ggtjd}| ||f | ||f tj
ddgtjd}| ||f tj
ddgtjtjggtjd} ||f  ||f tj
ddgtjd} ||ff tj
ddgdd ggd!d"gd#d$gggtjd}| ||f tj
dgtjd}tj
dgdgdggtjd} ||f  ||f d%S )&z&
        Test np.linalg.lstsq
        Trv   c                    s  t | |f|} | |f|}t|t| t|d |d d}zb|d |d  tt|D ]<}ztjj|| || dd W qr tk
r   d}Y qrX qrW n tk
r   d}Y nX |rd|\}}}	}
dd	d
g}zF|	|d  |D ],}t	|| tj
r|| j|| j qW n0 tk
r^   t|	|d  dk  Y nX t| jj}z,t| |}tjj||d| d| d W n tk
rb   |D ]}z(tjj|| || d| d| d W n6 tk
r   tj| }d| d|  Y nX tj|t| |d  }tj|t| | }tjj||dd qY nX    | |f| W 5 Q R X d S )Nr   rU   Fr   r  r7  Tr   r   ru   r)  r  r   r*  r  )r   rC   r=   r  r\   r   r  r8  rb   r   Zndarrayra   r  absr  r2   r  r   r  r   r   ZassertGreaterr   rM   )r   r   r9  rQ   rR   r:  r   xresr   rx  Zout_array_idxr  r;  rt  Zres_expectedZres_gotr<  r   r   r=    sz      


 

  
z0TestLinalgLstsq.test_linalg_lstsq.<locals>.checkr   r"  r$  r%  r&  rX   rU   r*  c                    sn   d}|D ]`}t }| jd |f||} | |f| t }|d d df j|d} | |f| qd S )Nr      r   rV   )nextr   ra   rg   )r   dtr9  b_sizesb_sizeb_orderr   rc   )r=  cycle_orderr(   r   r   inner_test_loop_fn  s      z=TestLinalgLstsq.test_linalg_lstsq.<locals>.inner_test_loop_fnr   r(  r+  r   r   r{  r0  r|  r   r   r   re        @      @rT   r   r   ru   r   r     r!  rD  N)r   r   r   rx   r  r   r   r   r[   r  r   ry   r3  r  rz   r  r
  rf  rg  r  r  r  )r(   r4  Zcycle_dtordersspecific_condr  Za_sizer  Za_orderr   r6   r1   r   r  r   approx_half_rank_rcondZemptiesr   rP   okrT  badZoneDbad1Dbad2Dr   )rO   r=  r  r(   r   test_linalg_lstsq  s    \


   
    ,z!TestLinalgLstsq.test_linalg_lstsqc              	   C   s   t jdddgdddgdddgddd	gdd
dgdddggdd}t |}t ddddddg}tdddd }|||d t j|| d S )Nr   g)\(@gGz@g@r  g      @gffffff@gffffff?g(\@gzG@g)\(
@g(\?g@rX   rV   re  r        @g      @Trv   c                 S   s&   |r| ddd d f } t j| |S rE  r   rG  yrH  r   r   r   f2n  s    z*TestLinalgLstsq.test_issue3368.<locals>.f2F)r   r   rg   r   r  r  )r(   rG  rK  r  r  r   r   r   test_issue3368b  s    

zTestLinalgLstsq.test_issue3368N)r   r   r   r   r   r  r  r   r   r   r   r  q  s   
 cr  c                   @   s(   e Zd ZdZedd Zedd ZdS )TestLinalgSolvez$
    Tests for np.linalg.solve.
    c                    s  t ddt  fdd}dddg}t|jdD ]t\}}}|||}d	}t|dD ]L\}}	|jd
 |f||	}
|||
 |
ddd
f j|	d}||| qZq4 tdtd tj	ddgddggtj
d} || d}tj	dd
gd
dggtjd}| ||f | ||f tj	ddgddggtjd}| ||f | ||f tj	dd
gtj
d}| ||f tj	ddgtjtjggtj
d} ||f  ||f tj	ddgtj
d} || tj	ddgddggddgddgggtj
d}| ||f tj	dgtj
d}tj	dgdgdggtj
d} ||f  ||f jdtj
ddd} ||f dS ) z&
        Test np.linalg.solve
        Trv   c              	      s   t | |f|} | |f|}|d d}ztjj||dd W n tk
rZ   d}Y nX |r|j|j t| |}t	| j
j}tjj||d| d| d    | |f| W 5 Q R X d S )NrX   Fr  r7  Tr  r)  )r   r  r   r  r8  rb   rC   ra   r   r  r2   r  r  rM   )r   r   r9  rQ   rR   r:  r;  r  r<  r   r   r=    s0      



z0TestLinalgSolve.test_linalg_solve.<locals>.checkr  r%  r!  r!  r'  r  r   NrV   r>  r  r           rT   r   r   r   ru   r   re  r  r  r!  rD  r  r?  rU   r(  )r   r   r   rx   r   ra   rg   r   r[   r   ry   r3  r  rz   r  r
  rf  rg  r  r  r  r  )r(   r=  r4  rY   r2   rW   r   r  r  r  r   rc   r  rT  r  Zok_oneDr  r  r   r<  r   test_linalg_solve~  sR    +
  

 
,z!TestLinalgSolve.test_linalg_solvec                 C   s   t jddddgddddgddddgddddggdd}t |}t dddd	g}t |}td
ddd }|||d}t j|| t j|| |||d}t j|| t j|| t j|| d S )Nr   r   r  r   rX   rV   re  r  r   Trv   c                 S   s&   |r| ddd d f } t j| |S rE  r   r  r   r   r   ri    s    z4TestLinalgSolve.test_no_input_mutation.<locals>.funcFrJ  )r(   rG  rK  r  Zy_origri  rQ   rR   r   r   r   rL    s&    





z&TestLinalgSolve.test_no_input_mutationN)r   r   r   r   r   r  rL  r   r   r   r   r  y  s
   
tr  c                   @   s(   e Zd ZdZedd Zedd ZdS )TestLinalgPinvz#
    Tests for np.linalg.pinv.
    c                    s0  t ddt  fdd}ddddd	g}d
}t|jdD ]p\}}}|||}|| |\}}	|dkr<|	dkr<t||	}
j||||d}d| }|
| }|||d q<dD ]}|t| qd}| tj	dtj
df | tj	dtjdf  tjddgtjtjggtjdf dS )z%
        Test np.linalg.pinv
        Trv   c           	   	      sx  t | f|} | f|}|d d}ztjj||dd W n tk
rV   d}Y nX |rT|j|j t|| }z	| W n tk
rR   dt
| jj } |}tjj|| d| d| d | jd	 | jd
 kr6tddt}|| t| jd	 | jf|d	 }tjj||d| d| d tj|| | Y nX    | f| W 5 Q R X d S )NrX   Fr  r7  Tr  r  r)  r   r   rv   )r   r  r   r  r8  rb   rC   ra   r   r  r  r2   r  r  r   r   r   r/   Z
assertLessr   r   rM   )	r   r9  rQ   rR   r:  r;  r  r   Z
lstsq_pinvr<  r   r   r=    sb      

 
z.TestLinalgPinv.test_linalg_pinv.<locals>.checkr   r"  r$  r%  r&  r*  r'  r   r+  r   r  )r{  r|  r   r?  rT   r  re  N)r   r   r   rx   r   r   r   r[   r  r@  r3  r
  ry   r  r   rf  rg  )r(   r=  r4  r  rY   r2   rW   r   r6   r1   r   r   r  r}  rT  r   r<  r   test_linalg_pinv  s>    D

zTestLinalgPinv.test_linalg_pinvc                 C   s   t dddd }tjddddgd	d
ddgddddgddddggdd}t|}|d}||}tj|| ||}tj|| tj|| d S )NTrv   c                 S   s   t j| d S )Nr   r   )rW  r   r   r   some_fn  s    z.TestLinalgPinv.test_issue5870.<locals>.some_fnr   ru   r   r!  rB  r   rC  r2  r   r  rD  rX   rV   )r   r   r   )r   r   r   rg   r5   r   r  r  )r(   r  Zv_dataZv_origZ
reshaped_vrQ   rR   r   r   r   test_issue5870  s     






zTestLinalgPinv.test_issue5870N)r   r   r   r   r   r  r  r   r   r   r   r    s
   
sr  c                   @   sL   e Zd ZdZdd Zdd Zdd Zedd	 Zed
d Z	edd Z
dS )TestLinalgDetAndSlogdetz
    Tests for np.linalg.det. and np.linalg.slogdet.
    Exactly the same inputs are used for both tests as
    det() is a trivial function of slogdet(), the tests
    are therefore combined.
    c              	   K   s`   t |f|}||f|}dt|jj }tjj|||d |   ||f| W 5 Q R X d S Nr  r  )r   r   r  r2   r  r  r  rM   )r(   rO   r   r9  rQ   rR   r  r   r   r   	check_det  s    
z!TestLinalgDetAndSlogdet.check_detc           	   	   K   s   t |f|}||f|}| t|t| | t|d tdD ]$}| t|| t||  qD|j|d }tjj	||d dd dt
|jj }tjj|d |d ||d |   ||f| W 5 Q R X d S )Nr   r   r  r7  r  r   r)  )r   rC   r=   r\   r   r\  r2   typer  r8  r  r  r  rM   )	r(   rO   r   r9  rQ   rR   r   Zgot_convr  r   r   r   check_slogdet  s0         
z%TestLinalgDetAndSlogdet.check_slogdetc           	      C   s   dddg}t || jdD ]"\}}}| |||}||| qt | jdD ] \}}tjd|d}||| qH||td | ||tjdtjdf | 	||tjd	tj
df | |tjd
dgtjtjggtj
df d S )Nr  )r   r   r  r'  r%  rT   r>  r?  r  r   re  )r   rx   r   r   r   r[   r  r@  r3  r
  ry   r  r   rf  rg  )	r(   rT  r=  rO   r4  rY   r2   rW   r   r   r   r   do_test  s(    
zTestLinalgDetAndSlogdet.do_testc                 C   s"   t ddt}| d| j| d S )NTrv   r   )r   r   r  r  r(   rO   r   r   r   test_linalg_det  s    z'TestLinalgDetAndSlogdet.test_linalg_detc                 C   s"   t ddt}| d| j| d S )NTrv   r   )r   r   r  r  r  r   r   r   test_linalg_slogdet  s    z+TestLinalgDetAndSlogdet.test_linalg_slogdetc                 C   s   t jddddgddddgddd	d	gdd
ddggdd}t |}tdddd }||d}t j|| ||d}t j|| t j|| d S )Nr   ru   r   r!  rB  r   rC  r2  r   r  rD  rX   rV   Trv   c                 S   s$   |r| ddd d f } t j| S rE  r   rF  r   r   r   ri    s    z<TestLinalgDetAndSlogdet.test_no_input_mutation.<locals>.funcFrJ  r(   rG  rK  ri  rQ   rR   r   r   r   rL    s    





z.TestLinalgDetAndSlogdet.test_no_input_mutationN)r   r   r   r   r  r  r  r   r  r  rL  r   r   r   r   r    s   #!

r  c                   @   s   e Zd ZdZedd ZdS )TestLinalgNormz#
    Tests for np.linalg.norm.
    c           
         s  t ddt  fdd}dddg}dtjtj d	dd
dddddg}t|j|D ]"\}}}||}|||d qTtj|D ]*\}}d|ddd }|||d qdddddg}dtjtj dd
ddg}t|jd|D ]&\}}}}|||}|||d qdg}tj|dD ]d\}}}d||}||dd |d ||ddddf |d ||ddddf |d q"tj|dD ]P\}}}tjd||d}	 ||d tjd||d}	 ||d qd}	
|	 tjdtjd f |	 tjd!tjd dddf  tjd"d#gtjtjggtjd df  tjd"d#gd$d%ggtjd d&f dS )'z%
        Test np.linalg.norm
        Trv   c              	      sr   t | f|} | f|}t|  dt| jj }tjj|||d 	   | f| W 5 Q R X d S r  )
r   r  r   r\  r  r2   r  r  r  rM   r   r9  rQ   rR   r  r<  r   r   r=  ,  s    
z.TestLinalgNorm.test_linalg_norm.<locals>.checkr   r   r!  Nr   rw   r   r  r  g@g333333)r   r  ru   r   r"  r$  r%  r&  r'  )   r  r  r   r  r>  r   r?  rT      r   re  r  r  r  )r   r   r   rf  r   rx   r4   r   r[   rC   r  r@  r3  r  ry   r5   r  r   rg  r  )
r(   r=  r4  Z	nrm_typesrY   r2   Znrm_typer   rW   rT  r   r<  r   test_linalg_norm%  sv    
 

     zTestLinalgNorm.test_linalg_normN)r   r   r   r   r   r  r   r   r   r   r     s   r  c                   @   s   e Zd ZdZedd ZdS )TestLinalgCondz#
    Tests for np.linalg.cond.
    c              	      s  t ddt  fdd}dtjtj dddd	g}d
dg}t|jd|D ]&\}}}}|||}|||d qLddddg}t|jdD ] \}}}|||}|| qdD ]}	 t|	f qtj	ddgddggtj
d}
||
 ||
dd tj	ddgddggtj
d}
||
d	d t 6 tj	ddgddggtj
d}tdt || W 5 Q R X d}| tjdtjdf | tjdtj
df  tj	ddgtjtjggtj
df  tj	ddgddggtj
ddf dS ) z%
        Test np.linalg.cond
        Trv   c              	      sr   t | f|} | f|}t|  dt| jj }tjj|||d 	   | f| W 5 Q R X d S r  )
r   r  r   r\  r  r2   r  r  r  rM   r  r<  r   r   r=    s    
z.TestLinalgCond.test_linalg_cond.<locals>.checkNr   rw   r   r  r%  r  r'  )r   r   r"  r$  r&  rz  r   rT   gg?ignorer   r?  r  r   re  r  r  r  )r   r   r   rf  r   rx   r   r  r[   r   ry   r:   r;   r<   RuntimeWarningr  r@  r3  r
  r  rg  r  )r(   r=  Zpsr4  rY   r2   rW   r   r   r}  r  rT  r   r<  r   test_linalg_cond  sR    

zTestLinalgCond.test_linalg_condN)r   r   r   r   r   r  r   r   r   r   r    s   r  c                   @   s(   e Zd ZdZedd Zedd ZdS )TestLinalgMatrixRankz*
    Tests for np.linalg.matrix_rank.
    c              	      s  t ddt  fdd}ddddd	g}t|jd
D ]\}}}|||}|| d}tdt|d D ]}j||||d} || || |j\}	}
d|ddddf< t	
t	|	|
}t	|rdt	j| d dt	j|  }d|d< ndt	j| }d|d< ||||d d| |d d| f<  |||d  |||d qpd|ddddf<  |d || t	|rd|d< nd|d<  ||d |||d q8jD ]L}t	jd|d} |d || d|d<  |d || qdD ](}dD ]} t	||f q8q0d}| t	jdt	jdf | t	jdt	jddddf  t	jdd gt	jt	jggt	jdf dS )!z,
        Test np.linalg.matrix_rank
        Trv   c              	      sJ   t | f|} | f|}tj||    | f| W 5 Q R X d S r   )r   r   r  r  rM   )r   r9  rQ   rR   r<  r   r   r=    s
    
z;TestLinalgMatrixRank.test_linalg_matrix_rank.<locals>.checkr   r"  r$  r%  r&  r'  vIh%<=r   r(  r  Nr                 ?y+=+=r   g+=)r   )rw   rw   r  rT   rz  )Nr  r   r?  r  r   ru   re  )r   r   r   rx   r   r\   r   rC   ra   r   r   r   r\  r   rN  r/   r   r  r[   r  r@  r3  r  ry   r5   r  r   rf  rg  )r(   r=  r4  rY   r2   rW   r   r   r   r6   r1   r   r   r  r}  rT  r   r<  r   test_linalg_matrix_rank  s    

*

     z,TestLinalgMatrixRank.test_linalg_matrix_rankc                 C   s   t jddddgddddgddd	d	gdd
ddggdd}t |}tdddd }||d}t j|| ||d}t j|| t j|| d S )Nr   ru   r   r!  rB  r   rC  r2  r   r  rD  rX   rV   Trv   c                 S   s$   |r| ddd d f } t j| S rE  r   rF  r   r   r   ri  T	  s    z9TestLinalgMatrixRank.test_no_input_mutation.<locals>.funcFrJ  r  r   r   r   rL  G	  s    





z+TestLinalgMatrixRank.test_no_input_mutationN)r   r   r   r   r   r  rL  r   r   r   r   r    s
   
dr  c                   @   s$   e Zd ZdZdd Zedd ZdS )TestLinalgMatrixPowerz+
    Tests for np.linalg.matrix_power.
    c              	   C   s2   ||d d |  tj ||  W 5 Q R X d S )Nr   r   rj   r	   rr   )r(   rO   rP   r   r   r   assert_int_exponenenti	  s    z+TestLinalgMatrixPower.assert_int_exponenentc                    sN  t ddt  fdd}dddg}dd	gttd
d ddg }t||jdD ]>\}}}}|||}||| tjd||d}||| qTd}		|	 tj
dtjddf 	|	 tj
dtjddf t
ddf}
d} |
| |	 tj
dtjddf  t
ddf  tddgddggdf d S )NTrv   c              	      sh   t | |} | |}|d dt| jj }tjj||||d    | | W 5 Q R X d S )NrU   r  r)  )	r   r  r   r  r2   r  r  r  rM   )r   pwrrQ   rR   r  r<  r   r   r=  t	  s    


z=TestLinalgMatrixPower.test_linalg_matrix_power.<locals>.checkr  r  r  r  iir  r  !   r'  r>  r   r   r?  rT   r   )ru   r  zinput must be a square array333333?r  r   rw   )r   r   listr\   r   rx   r   r   r[   r  r@  r3  r   r
  ry   r  r  r   )r(   r=  r4  ZpowersrY   r  r2   rW   r   rT  rP   ro   r   r<  r   test_linalg_matrix_powerp	  s2    

z.TestLinalgMatrixPower.test_linalg_matrix_powerN)r   r   r   r   r  r   r  r   r   r   r   r  d	  s   r  c                       s8   e Zd ZdZ fddZdd Zdd Zdd	 Z  ZS )
	TestTracez
    Tests for np.trace.
    c                    s2   t t|   tddt| _tddt| _d S )NTrv   )r%   r  r&   r   r   cfunc_w_offsetr   cfunc_no_offsetr'   r)   r   r   r&   	  s    zTestTrace.setUpc              	   K   s0   || |  tj ||f| W 5 Q R X d S r   r  )r(   rO   r   r9  r   r   r   assert_int_offset	  s    zTestTrace.assert_int_offsetc           
         s   fdd}dddddg}dd	d
gt tdd dddg }t|| jdD ]b\}}}} |||}|||d |dkr|| tjd||d}|||d |dkrL|| qLd}	 |	 jtj	dtj
ddfd  |	 jtj	dtj
dfd  j jt	ddd d S )Nc              	      s   d|krt | f|} j}nt| f|} j}|| f|}dt| jj }tjj	||||d  
  || f| W 5 Q R X d S )Nr   r  r)  )r   r  r   r  r   r  r2   r  r  r  rM   )r   r9  rQ   rO   rR   r  r'   r   r   r=  	  s    
z#TestTrace.test_trace.<locals>.checkr   r"  r$  r%  r&  iiir  r  r#  r  r  r'  )r   r   r>  r   r   rT   r   Fr?  r  )r  r\   r   rx   r   r   r[   r
  r  r@  ry   r  r  )
r(   r=  r4  offsetsrY   r   r2   rW   r   rT  r   r'   r   
test_trace	  s:    "

 
  zTestTrace.test_tracec              	   C   sd   t ddddd }tjdtjd}|| | t}|d W 5 Q R X t|j}| d	| dS )
z
Issue 2314z(optional(float64[:,:]),)Trv   c                 S   s
   t | S r   r   r   r   r   r   tested	  s    z5TestTrace.test_trace_w_optional_input.<locals>.testedr  rT   Nz(expected array(float64, 2d, A), got None)	r   r   r@  ry   rj   	TypeErrorrA   rl   rC   )r(   r  r   rn   errmsgr   r   r   test_trace_w_optional_input	  s    


z%TestTrace.test_trace_w_optional_input)	r   r   r   r   r&   r  r  r  r   r   r   r)   r   r  	  s
   2r  c                   @   sh   e Zd ZeddddgZeddddgZddddddd	d
gZdd Zdd Zdd Z	dd Z
dd ZdS )
TestBasicsrX   rU   r   r%  r&  )r!  r0  )ru   r  r  c              	   C   s\   |  ||tjdgggtjdtdfd |  ||tdtjdgggtjdfd d S )Nr   rT   F)r  r   r   ry   r@  )r(   rT  rO   r   r   r   _assert_wrong_dim
  s          zTestBasics._assert_wrong_dimc                 C   sP   t |ts|S t|dkr*| |d |S | |d |d  |j||dS d S )Nr   r   rV   )r   r  r=   r4   r5   )r(   rY   r2   rW   r   r   r   
_gen_input

  s    
 zTestBasics._gen_inputc                 C   sT   |  ||t| j}|  ||t| j}t|r:|d }t|rL|d }||fS )Nr  )r  r  order1order2r   r\  )r(   size1size2r2   r   r   r   r   r   
_get_input
  s    

zTestBasics._get_inputc           	         s   t ddt  fdd}tj}tjjD ]d\}}t|}|||\}}||| tj	t
|jt
|jft
|jd}||||d q4d  d S )NTrv   c              	      s   t | |} | |}dtt| jj }tjj||||d d|kr | |f|}tjj||||d tjj|d |||d    | |f| W 5 Q R X d S )Nr  r)  r   )	r   r   r  asarrayr2   r  r  r  rM   r   r   r9  rQ   rR   r  r<  r   r   r=  #
  s    

 
z$TestBasics.test_outer.<locals>.checkrT   r   r   )r   r   r   rx   r   r4  r  r  r   r[   r  rY   r2   r  )	r(   r=  dtsr  r  r2   r   r   rt  r   r<  r   
test_outer 
  s    


zTestBasics.test_outerc           	         s   t ddt  fdd}tjjjD ]&\}}}|||\}}||| q.d  tdd d d tdd d d f}d}j	 ||t
jd	 d S )
NTrv   c              	      sb   t | |} | |}dtt| jj }tjj||||d    | | W 5 Q R X d S )Nr  r)  )	r   r   r  r  r2   r  r  r  rM   r  r<  r   r   r=  F
  s    


z#TestBasics.test_kron.<locals>.checkr   r  r   zonly supports 'C' or 'F' layoutr  )r   r   r   r4  rx   r  r  r   r[   r   r	   rr   )	r(   r=  r  r  r2   r   r   rP   ro   r   r<  r   	test_kronC
  s    (zTestBasics.test_kronN)r   r   r   r   r  r  r4  r  r  r  r  r  r   r   r   r   r  	  s   
#r  c                   @   s   e Zd Zdd ZdS )TestHelpersc                    s   ddl m  fdd}t fdd}ddg}tjg}d	d
g}||tj||| t fdd}ddg}tjg}d	d
g}dd }|||||| d S )Nr   _copy_to_fortran_orderc           
         sb   t |||D ]P\}}}tt|j||d}| |}	 |||	  |jj|	jj qd S )NrV   )	r   r   r-   prodr5   rN   ZassertNotEqualctypesdata)
ZudtZexpectfnshapesrx   r  ra   r2   rW   r   r  r'   r   r   r=  b
  s
    z5TestHelpers.test_copy_to_fortran_order.<locals>.checkc                    s    | S r   r   r   r  r   r   direct_calll
  s    z;TestHelpers.test_copy_to_fortran_order.<locals>.direct_call)ru   r   )ru   r   r  rU   rX   c                    s   | d d d d } |S Nr   r   r   r   Zslicedr  r   r   slice_to_anyv
  s    z<TestHelpers.test_copy_to_fortran_order.<locals>.slice_to_any)ru   ru   r   )ru   ru   r   r  c                 S   s   | d d d d }t |S r  )r   asfortranarrayr  r   r   r   expected_slice_to_any
  s    zETestHelpers.test_copy_to_fortran_order.<locals>.expected_slice_to_any)Znumba.np.linalgr  r   r   Zintpr  )r(   r=  r  r  rx   r  r  r  r   )r  r(   r   test_copy_to_fortran_order_
  s    
z&TestHelpers.test_copy_to_fortran_orderN)r   r   r   r  r   r   r   r   r  ^
  s   r  __main__)r   )rw   )r   )N)N)N)r   )N)Jr   r#   	itertoolsr   r   sysr:   numbersr   r   platformnumpyr   Znumbar   r   r   Z
numba.corer	   Znumba.tests.supportr
   r   r   r   r   r   r   Zunittestr   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  r6  rM  rV  ru  r  r  r  r  r  r  r  r  r  r  r  r  r  r   mainr   r   r   r   <module>   s      1







 FjQS n x  
  iT BTd)
