
    ,|hG                       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mZ ddlmZ ddlmZ d d	lmZ er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lZ G d de      Z G d de      Z G d de      Z  G d de      Z!ddd=dZ"ddd>dZ#d?dZ$d dd@dZ%dAdZ&d?dZ'd?d Z(dBd!Z)dd"d#dCd$Z*dDd%Z+dd&dEd'Z,d?d(Z-dBd)Z.dd&dEd*Z/d+d,dFd-Z0dGd.Z1d/ Z2dBd0Z3d1d2dHd3Z4dId4Z5dd5dJd6Z6d dd7dKd8Z7ddd>d9Z8dddd:dLd;Z9g d<Z:y)M    )annotations   )_floating_dtypes_numeric_dtypesfloat32float64	complex64
complex128)reshape)conj)Array   )normalize_axis_tuple)TYPE_CHECKING)LiteralOptionalSequenceTupleUnionDtype)
NamedTupleNc                  "    e Zd ZU ded<   ded<   y)
EighResultr   eigenvalueseigenvectorsN__name__
__module____qualname____annotations__     U/var/www/html/test/engine/venv/lib/python3.12/site-packages/numpy/array_api/linalg.pyr   r      s    r"   r   c                  "    e Zd ZU ded<   ded<   y)QRResultr   QRNr   r!   r"   r#   r%   r%      s    HHr"   r%   c                  "    e Zd ZU ded<   ded<   y)SlogdetResultr   sign	logabsdetNr   r!   r"   r#   r)   r)   "   s    
Kr"   r)   c                  ,    e Zd ZU ded<   ded<   ded<   y)	SVDResultr   USVhNr   r!   r"   r#   r-   r-   &   s    HHIr"   r-   F)upperc              D   | j                   t        vrt        d      t        j                  j                  | j                        }|rDt        j                  |      j                  }|j                   t        t        fv rt        |      }|S t        j                  |      S )z
    Array API compatible wrapper for :py:func:`np.linalg.cholesky <numpy.linalg.cholesky>`.

    See its docstring for more information.
    z2Only floating-point dtypes are allowed in cholesky)dtyper   	TypeErrornplinalgcholesky_arrayr   _newmTr	   r
   r   )xr1   Lr.   s       r#   r7   r7   -   sx     	ww&&LMM
		188$AJJqM77y*--QA::a=r"   axisc                 | j                   t        vs|j                   t        vrt        d      | j                  |j                  k7  rt	        d      | j
                  dk(  rt	        d      | j                  |   dk7  rt	        d      t        j                  t        j                  | j                  |j                  |            S )zz
    Array API compatible wrapper for :py:func:`np.cross <numpy.cross>`.

    See its docstring for more information.
    z(Only numeric dtypes are allowed in crossz"x1 and x2 must have the same shaper   z/cross() requires arrays of dimension at least 1   zcross() dimension must equal 3r>   )r3   r   r4   shape
ValueErrorndimr   r9   r5   crossr8   )x1x2r?   s      r#   rE   rE   @   s     
xx&"((/*IBCC	xx288=>>	ww!|JKK	xx~9::::bhhryy"))$?@@r"   c                   | j                   t        vrt        d      t        j                  t
        j                  j                  | j                              S )z
    Array API compatible wrapper for :py:func:`np.linalg.det <numpy.linalg.det>`.

    See its docstring for more information.
    z-Only floating-point dtypes are allowed in det)	r3   r   r4   r   r9   r5   r6   detr8   r;   s    r#   rI   rI   R   s=     	ww&&GHH::biimmAHH-..r"   )offsetc              n    t        j                  t        j                  | j                  |dd            S )z
    Array API compatible wrapper for :py:func:`np.diagonal <numpy.diagonal>`.

    See its docstring for more information.
    r=   )rK   axis1axis2)r   r9   r5   diagonalr8   )r;   rK   s     r#   rP   rP   _   s&     ::bkk!((62NOOr"   c                   | j                   t        vrt        d      t        t	        t
        j                  t        j                  j                  | j                               S )z
    Array API compatible wrapper for :py:func:`np.linalg.eigh <numpy.linalg.eigh>`.

    See its docstring for more information.
    z.Only floating-point dtypes are allowed in eigh)r3   r   r4   r   mapr   r9   r5   r6   eighr8   rJ   s    r#   rS   rS   j   sF     	ww&&HII s5::ryy~~ahh'?@AAr"   c                   | j                   t        vrt        d      t        j                  t
        j                  j                  | j                              S )z
    Array API compatible wrapper for :py:func:`np.linalg.eigvalsh <numpy.linalg.eigvalsh>`.

    See its docstring for more information.
    z2Only floating-point dtypes are allowed in eigvalsh)	r3   r   r4   r   r9   r5   r6   eigvalshr8   rJ   s    r#   rU   rU   z   s?     	ww&&LMM::bii((233r"   c                   | j                   t        vrt        d      t        j                  t
        j                  j                  | j                              S )z
    Array API compatible wrapper for :py:func:`np.linalg.inv <numpy.linalg.inv>`.

    See its docstring for more information.
    z-Only floating-point dtypes are allowed in inv)	r3   r   r4   r   r9   r5   r6   invr8   rJ   s    r#   rW   rW      s=     	ww&&GHH::biimmAHH-..r"   c                   | j                   t        vs|j                   t        vrt        d      t        j                  t        j                  | j                  |j                              S )z|
    Array API compatible wrapper for :py:func:`np.matmul <numpy.matmul>`.

    See its docstring for more information.
    z)Only numeric dtypes are allowed in matmul)r3   r   r4   r   r9   r5   matmulr8   rF   rG   s     r#   rY   rY      sI     
xx&"((/*ICDD::bii		299566r"   fro)keepdimsordc                  | j                   t        vrt        d      t        j                  t
        j                  j                  | j                  d||            S )
    Array API compatible wrapper for :py:func:`np.linalg.norm <numpy.linalg.norm>`.

    See its docstring for more information.
    z5Only floating-point dtypes are allowed in matrix_norm)rM   r=   r?   r\   r]   )	r3   r   r4   r   r9   r5   r6   normr8   )r;   r\   r]   s      r#   matrix_normrb      sF     	ww&&OPP::biinnQXXHxUXnYZZr"   c                   | j                   t        vrt        d      t        j                  t
        j                  j                  | j                  |            S )z
    Array API compatible wrapper for :py:func:`np.matrix_power <numpy.matrix_power>`.

    See its docstring for more information.
    zMOnly floating-point dtypes are allowed for the first argument of matrix_power)	r3   r   r4   r   r9   r5   r6   matrix_powerr8   )r;   ns     r#   rd   rd      sC     	ww&&ghh ::bii,,QXXq9::r"   )rtolc              p   | j                   dk  rt        j                  j                  d      t        j                  j	                  | j
                  d      }|W|j                  dd      t        | j                  d	d       z  t        j                  |j                        j                  z  }nXt        |t              r|j
                  }|j                  dd      t        j                  |      d
t        j                  f   z  }t        j                  t        j                   ||kD  d            S )z
    Array API compatible wrapper for :py:func:`np.matrix_rank <numpy.matrix_rank>`.

    See its docstring for more information.
    r   zA1-dimensional array given. Array must be at least two-dimensionalF
compute_uvNr=   T)r?   r\   rM   .r>   )rD   r5   r6   LinAlgErrorsvdr8   maxrB   finfor3   eps
isinstancer   asarraynewaxisr9   count_nonzero)r;   rf   r/   tols       r#   matrix_rankrt      s     	vvzii##$ghh
		ahh51A|eede+c!''"#,.??"((177BSBWBWWdE";;D eede+BJJt,<S"**_,MM::b&&q3wR899r"   c                   | j                   dk  rt        d      t        j                  t	        j
                  | j                  dd            S )Nr   z5x must be at least 2-dimensional for matrix_transposer=   rM   )rD   rC   r   r9   r5   swapaxesr8   rJ   s    r#   matrix_transposerw      s9    vvzPQQ::bkk!((B344r"   c               ,   | j                   t        vs|j                   t        vrt        d      | j                  dk7  s|j                  dk7  rt	        d      t        j                  t        j                  | j                  |j                              S )zz
    Array API compatible wrapper for :py:func:`np.outer <numpy.outer>`.

    See its docstring for more information.
    z(Only numeric dtypes are allowed in outerr   z/The input arrays to outer must be 1-dimensional)
r3   r   r4   rD   rC   r   r9   r5   outerr8   rZ   s     r#   ry   ry      sl     
xx&"((/*IBCC 
ww!|rww!|JKK::bhhryy"))455r"   c              @   | j                   t        vrt        d      |Bt        | j                  dd       t        j                  | j                         j                  z  }t        j                  t
        j                  j                  | j                  |            S )z
    Array API compatible wrapper for :py:func:`np.linalg.pinv <numpy.linalg.pinv>`.

    See its docstring for more information.
    z.Only floating-point dtypes are allowed in pinvNrM   )rcond)r3   r   r4   rl   rB   r5   rm   rn   r   r9   r6   pinvr8   )r;   rf   s     r#   r|   r|      st     	ww&&HII |17723< 288AGG#4#8#88::biinnQXXTn:;;r"   reducedmodec         	         | j                   t        vrt        d      t        t	        t
        j                  t        j                  j                  | j                  |             S )z
    Array API compatible wrapper for :py:func:`np.linalg.qr <numpy.linalg.qr>`.

    See its docstring for more information.
    z,Only floating-point dtypes are allowed in qrr~   )r3   r   r4   r%   rR   r   r9   r5   r6   qrr8   )r;   r   s     r#   r   r     sJ     	ww&&FGG SRYY\\!((\%FGHHr"   c                   | j                   t        vrt        d      t        t	        t
        j                  t        j                  j                  | j                               S )z
    Array API compatible wrapper for :py:func:`np.linalg.slogdet <numpy.linalg.slogdet>`.

    See its docstring for more information.
    z1Only floating-point dtypes are allowed in slogdet)r3   r   r4   r)   rR   r   r9   r5   r6   slogdetr8   rJ   s    r#   r   r     sH     	ww&&KLL #ejj"))*;*;AHH*EFGGr"   c                   ddl m}m}m}m}m}m}m} ddlm	}	  ||       \  } }
 ||         ||         ||      \  }} || |      \  }}|j                  dk(  r|	j                  }n|	j                  } ||      rdnd}t        j                  |dddd	      5   || ||
      }d d d         |j                  |d            S # 1 sw Y   "xY w)Nr   )
_makearray_assert_stacked_2d_assert_stacked_square_commonTypeisComplexTypeget_linalg_error_extobj_raise_linalgerror_singular)_umath_linalgr   zDD->Dzdd->dcallignore)r   invalidoverdivideunder)	signatureF)copy)linalg.linalgr   r   r   r   r   r   r   r6   r   rD   solve1solver5   errstateastype)abr   r   r   r   r   r   r   r   _wraptresult_tgufuncr   rs                    r#   _solver   /  s    > > > 'a=DAqq1mGAta#KAx 	vv{%%$$ )+I	5v"88
E .1a9-. .//	. .s   CCc                   | j                   t        vs|j                   t        vrt        d      t        j                  t        | j                  |j                              S )z
    Array API compatible wrapper for :py:func:`np.linalg.solve <numpy.linalg.solve>`.

    See its docstring for more information.
    z/Only floating-point dtypes are allowed in solve)r3   r   r4   r   r9   r   r8   rZ   s     r#   r   r   K  sG     
xx''288;K+KIJJ::fRYY		233r"   Tfull_matricesc         	         | j                   t        vrt        d      t        t	        t
        j                  t        j                  j                  | j                  |             S )z
    Array API compatible wrapper for :py:func:`np.linalg.svd <numpy.linalg.svd>`.

    See its docstring for more information.
    z-Only floating-point dtypes are allowed in svdr   )r3   r   r4   r-   rR   r   r9   r5   r6   rk   r8   )r;   r   s     r#   rk   rk   X  sJ     	ww&&GHH c%**biimmAHHMm&Z[\\r"   c                   | j                   t        vrt        d      t        j                  t
        j                  j                  | j                  d            S )Nz1Only floating-point dtypes are allowed in svdvalsFrh   )	r3   r   r4   r   r9   r5   r6   rk   r8   rJ   s    r#   svdvalsr   i  s?    ww&&KLL::biimmAHHm?@@r"   axesc                  | j                   t        vs|j                   t        vrt        d      t        j                  t        j                  | j                  |j                  |            S )Nz,Only numeric dtypes are allowed in tensordotr   )r3   r   r4   r   r9   r5   	tensordotr8   )rF   rG   r   s      r#   r   r   q  sK     
xx&"((/*IFGG::bll299biidCDDr"   )rK   r3   c              :   | j                   t        vrt        d      |3| j                   t        k(  rt        }n| j                   t
        k(  rt        }t        j                  t        j                  t        j                  | j                  |dd|                  S )zz
    Array API compatible wrapper for :py:func:`np.trace <numpy.trace>`.

    See its docstring for more information.
    z(Only numeric dtypes are allowed in tracerM   r=   )rK   rN   rO   r3   )r3   r   r4   r   r   r	   r
   r   r9   r5   rp   tracer8   )r;   rK   r3   s      r#   r   r   z  sv     	wwo%BCC }77gEWW	!E ::bjj!((6SU]b!cdeer"   c              r   | j                   t        vs|j                   t        vrt        d      t        | j                  |j                        }d|| j                  z
  z  t        | j                        z   }d||j                  z
  z  t        |j                        z   }||   ||   k7  rt        d      t        j                  | j                  |j                        \  }}t        j                  ||d      }t        j                  ||d      }|dd d d f   |d   z  }t        j                  |d         S )Nz)Only numeric dtypes are allowed in vecdot)r   z6x1 and x2 must have the same size along the given axisr=   .).N).r   r   )r3   r   r4   rl   rD   tuplerB   rC   r5   broadcast_arraysr8   moveaxisr   r9   )	rF   rG   r?   rD   x1_shapex2_shapex1_x2_ress	            r#   vecdotr     s   	xx&"((/*ICDDrww DTBGG^$uRXX6HTBGG^$uRXX6H~$'QRR""299bii8HC
++c4
$C
++c4
$C
c4l
c)n
,C::c)n%%r"   r`   c         	     j   | j                   t        vrt        d      | j                  }||j	                         }d}nt        |t              rt        || j                        t        fdt        |j                        D              }||z   }t        j                  ||      j                  t        j                  |D cg c]  }|j                  |    c}t              g|D cg c]  }|j                  |    c}      }d}n|}t!        j"                  t        j$                  j'                  |||            }	|rct)        | j                        }
t        |t        | j                        n|| j                        }|D ]  }d|
|<   	 t        |	t        |
            }	|	S c c}w c c}w )r_   z.Only floating-point dtypes are allowed in normr   c              3  ,   K   | ]  }|vs|  y w)Nr!   ).0inormalized_axiss     r#   	<genexpr>zvector_norm.<locals>.<genexpr>  s     J1/1IQJs   	)r3   )r?   r]   r   )r3   r   r4   r8   ravelro   r   r   rD   ranger5   	transposer   prodrB   intr   r9   r6   ra   list)r;   r?   r\   r]   r   _axisrestnewshaper   r   rB   r   s              @r#   vector_normr     sd    	ww&&HII 	
A|GGI	D%	  /tQVV<JaffJJ$;LLH%--WW$/Qaggaj/s;YSW>Xaqwwqz>XY[
**RYY^^AEs^;
<C QWW$dlU166]affU 	AE!H	c5<(J! 0>Xs   F++F0
)r7   rE   rI   rP   rS   rU   rW   rY   rb   rd   rt   rw   ry   r|   r   r   r   rk   r   r   r   r   r   )r;   r   r1   boolreturnr   )rF   r   rG   r   r?   r   r   r   )r;   r   r   r   )r;   r   rK   r   r   r   )r;   r   r   r   )rF   r   rG   r   r   r   )r;   r   r\   r   r]   z2Optional[Union[int, float, Literal['fro', 'nuc']]]r   r   )r;   r   re   r   r   r   )r;   r   rf   zOptional[Union[float, Array]]r   r   )r;   r   r   zLiteral['reduced', 'complete']r   r%   )r;   r   r   r)   )r;   r   r   r   r   r-   )r;   r   r   zUnion[Array, Tuple[Array, ...]])rF   r   rG   r   r   z/Union[int, Tuple[Sequence[int], Sequence[int]]]r   r   )r;   r   rK   r   r3   zOptional[Dtype]r   r   )
r;   r   r?   z%Optional[Union[int, Tuple[int, ...]]]r\   r   r]   zOptional[Union[int, float]]r   r   );
__future__r   _dtypesr   r   r   r   r	   r
   _manipulation_functionsr   _elementwise_functionsr   _array_objectr   core.numericr   typingr   _typingr   r   r   r   r   r   r   numpy.linalgnumpyr5   r   r%   r)   r-   r7   rE   rI   rP   rS   rU   rW   rY   rb   rd   rt   rw   ry   r|   r   r   r   r   rk   r   r   r   r   r   __all__r!   r"   r#   <module>r      sD   "  - (   /  II    z J 
  ,1 & 35 A$
/ ,- PB 4/7( 27rw [; GK :056$ @D <" ?H IH0084 /3 ]"A cd E )*D f* 46 &, OSej  PQ +Z Fr"   