
    PhH                       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 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#d@dZ$d>dZ%d>dZ&dAd Z'dd!d"dBd#Z(dCd$Z)dd%dDd&Z*d>d'Z+dAd(Z,dd%dDd)Z-d*d+dEd,Z.dFd-Z/d. Z0dAd/Z1d0d1dGd2Z2dHd3Z3dd4dId5Z4d dd6dJd7Z5ddd=d8Z6dddd9dKd:Z7g d;Z8y)L    )annotations   )_floating_dtypes_numeric_dtypesfloat32float64	complex64
complex128)reshape)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__     aC:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\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                  | j                   t        vrt        d      t        j                  j                  | j                        }|rt        j                  |      j                  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mT)xr0   Ls      r"   r6   r6   ,   sZ     	ww&&LMM
		188$Azz!}::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=   )r2   r   r3   shape
ValueErrorndimr   r8   r4   crossr7   )x1x2r>   s      r"   rD   rD   <   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)	r2   r   r3   r   r8   r4   r5   detr7   r:   s    r"   rH   rH   N   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<   )rJ   axis1axis2)r   r8   r4   diagonalr7   )r:   rJ   s     r"   rO   rO   [   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)r2   r   r3   r   mapr   r8   r4   r5   eighr7   rI   s    r"   rR   rR   f   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)	r2   r   r3   r   r8   r4   r5   eigvalshr7   rI   s    r"   rT   rT   v   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)	r2   r   r3   r   r8   r4   r5   invr7   rI   s    r"   rV   rV      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)r2   r   r3   r   r8   r4   matmulr7   rE   rF   s     r"   rX   rX      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)rL   r<   r>   r[   r\   )	r2   r   r3   r   r8   r4   r5   normr7   )r:   r[   r\   s      r"   matrix_normra      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)	r2   r   r3   r   r8   r4   r5   matrix_powerr7   )r:   ns     r"   rc   rc      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[   rL   .r=   )rC   r4   r5   LinAlgErrorsvdr7   maxrA   finfor2   eps
isinstancer   asarraynewaxisr8   count_nonzero)r:   re   r.   tols       r"   matrix_rankrs      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<   rL   )rC   rB   r   r8   r4   swapaxesr7   rI   s    r"   matrix_transposerv      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)
r2   r   r3   rC   rB   r   r8   r4   outerr7   rY   s     r"   rx   rx      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 pinvNrL   )rcond)r2   r   r3   rk   rA   r4   rl   rm   r   r8   r5   pinvr7   )r:   re   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}   )r2   r   r3   r$   rQ   r   r8   r4   r5   qrr7   )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)r2   r   r3   r(   rQ   r   r8   r4   r5   slogdetr7   rI   s    r"   r   r     sH     	ww&&KLL #ejj"))*;*;AHH*EFGGr!   c                X   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} ||      } || |||      } ||j                  |d	            S )
Nr   )
_makearray_assert_stacked_2d_assert_stacked_square_commonTypeisComplexTypeget_linalg_error_extobj_raise_linalgerror_singular)_umath_linalgr   zDD->Dzdd->d)	signatureextobjF)copy)linalg.linalgr   r   r   r   r   r   r   r5   r   rC   solve1solveastype)abr   r   r   r   r   r   r   r   _wraptresult_tgufuncr   r   rs                     r"   _solver   +  s    > > > 'a=DAqq1mGAta#KAx 	vv{%%$$ )+I$%@AFq!y8A.//r!   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)r2   r   r3   r   r8   r   r7   rY   s     r"   r   r   F  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   )r2   r   r3   r,   rQ   r   r8   r4   r5   rj   r7   )r:   r   s     r"   rj   rj   S  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 svdvalsFrg   )	r2   r   r3   r   r8   r4   r5   rj   r7   rI   s    r"   svdvalsr   d  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   )r2   r   r3   r   r8   r4   	tensordotr7   )rE   rF   r   s      r"   r   r   l  sK     
xx&"((/*IFGG::bll299biidCDDr!   )rJ   r2   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 tracerL   r<   )rJ   rM   rN   r2   )r2   r   r3   r   r   r	   r
   r   r8   r4   ro   tracer7   )r:   rJ   r2   s      r"   r   r   u  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   )r2   r   r3   rk   rC   tuplerA   rB   r4   broadcast_arraysr7   moveaxisr   r8   )	rE   rF   r>   rC   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     J1/1IQs   	)r2   )r>   r\   r   )r2   r   r3   r7   ravelrn   r   r   rC   ranger4   	transposer   prodrA   intr   r8   r5   r`   list)r:   r>   r[   r\   r   _axisrestnewshaper   r   rA   r   s              @r"   vector_normr     si    	ww&&HII 	
A|GGI	D%	  /tQVV<JaffJJ$;LLH%--WW$/$Qaggaj$/s;YSW>XSWaqwwqzSW>XY[
**RYY^^AEs^;
<C QWW$dlU166]affUAE!H c5<(J! 0>Xs   F++F0
)r6   rD   rH   rO   rR   rT   rV   rX   ra   rc   rs   rv   rx   r{   r   r   r   rj   r   r   r   r   r   )r:   r   r0   boolreturnr   )rE   r   rF   r   r>   r   r   r   )r:   r   r   r   )r:   r   rJ   r   r   r   )r:   r   r   r   )rE   r   rF   r   r   r   )r:   r   r[   r   r\   z2Optional[Union[int, float, Literal['fro', 'nuc']]]r   r   )r:   r   rd   r   r   r   )r:   r   re   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, ...]])rE   r   rF   r   r   z/Union[int, Tuple[Sequence[int], Sequence[int]]]r   r   )r:   r   rJ   r   r2   zOptional[Dtype]r   r   )
r:   r   r>   z%Optional[Union[int, Tuple[int, ...]]]r[   r   r\   zOptional[Union[int, float]]r   r   )9
__future__r   _dtypesr   r   r   r   r	   r
   _manipulation_functionsr   _array_objectr   core.numericr   typingr   _typingr   r   r   r   r   r   r   numpy.linalgnumpyr4   r   r$   r(   r,   r6   rD   rH   rO   rR   rT   rV   rX   ra   rc   rs   rv   rx   r{   r   r   r   r   rj   r   r   r   r   r   __all__r    r!   r"   <module>r      sA   "  -   /  II    z J 
  ,1   35 A$
/ ,- PB 4/7( 27rw [; GK :056$ @D <" ?H IH0064 /3 ]"A cd E )*D f* 46 &, OSej  PQ +Z Fr!   