
    `iP                     t    d dl Z d dlZd dlmZ d dlmZ d dlmZ d dlm	Z	 d Z
d Zd Zd	 ZddZd ZddZdS )    N)runtime)internal)device)_utilc                    ddl m} ddl m} | j        }|d         }|                     |d                              d||          } | j        d         }t          j        ||ft          j	                  }t          j        |ft          j	                  }|d	z  ||z  k    }	|	rt          j                    }
|}||z  | j        z  }| j        j        }|||z  z   }t          j        |||t          j                  }|t          j        k    r|j        }nJ|t          j        k    r|j        }n2|t          j        k    r|j        }n|t          j        k    r|j        }nJ  ||
||j        j        ||j        j        |j        j        |           nt          j                    }
|t          j        k    r|j        }|j        }n_|t          j        k    r|j        }|j        }n@|t          j        k    r|j        }|j        }n!|t          j        k    r|j         }|j!        }nJ tE          |          D ]u}| |         j        j        } ||
||||          }t          j        ||          } ||
|||||j        j        ||         j        j        ||         j        j                   v|                     |          |                    |dd                   |                    |dd                   fS )a  Compute pivoted LU decomposition.

    Decompose a given batch of square matrices. Inputs and outputs are
    transposed.

    Args:
        a_t (cupy.ndarray): The input matrix with dimension ``(..., N, N)``.
            The dimension condition is not checked.
        dtype (numpy.dtype): float32, float64, complex64, or complex128.

    Returns:
        tuple:
        lu_t (cupy.ndarray):
            ``L`` without its unit diagonal and ``U`` with
            dimension ``(..., N, N)``.
        piv (cupy.ndarray):
            1-origin pivot indices with dimension
            ``(..., N)``.
        dev_info (cupy.ndarray):
            ``getrf`` info with dimension ``(...)``.

    .. seealso:: :func:`scipy.linalg.lu_factor`

    r   cublascusolverC)orderdtypei   FN)#cupy_backends.cuda.libsr	   r   shapeastypereshapecupyemptynumpyint32r   get_cublas_handleitemsizedataptrarangeuintpfloat32sgetrfBatchedfloat64dgetrfBatched	complex64cgetrfBatched
complex128zgetrfBatchedget_cusolver_handlesgetrf_bufferSizesgetrfdgetrf_bufferSizedgetrfcgetrf_bufferSizecgetrfzgetrf_bufferSizezgetrfrange)a_tr   r	   r   
orig_shapen
batch_sizeipivdev_infouse_batchedhandleldastepstartstopa_arraygetrfBatchedgetrf_bufferSizegetrfia_ptr
buffersize	workspaces                          n/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupy/linalg/_decomposition.py
_lu_factorrG   
   s   2 /.....000000J2A **U#*
&
&
.
.r1a
8
8C1J:z1oU[999Dz:-u{;;;H u$A-K .8)++3w%tj((+eT4tzBBBEM!!!/LLem##!/LLeo%%!/LLe&&&!/LL5Aw|'dimMz	+ 	+ 	+ 	+
 +--EM!!'9OEEem##'9OEEeo%%'9OEEe&&&'9OEE5z"" 	8 	8AFKOE))&!QqAAJ
:U;;;IE1eQ	(:Q (1+"2"68 8 8 8
 	JZ_%%CRC))     c           	         ddl m} ddl m} ddlm}  |d          st          d          t          j        |           \  }}| j        dk    rt          j
        | j        |          S |dk    r|j        }n#|dk    r|j        }n|d	k    r|j        }n|j        }|                     |d
d          }t          j                            |          }|j        d         }	|j        d         |j        j        z  }
t-          j                    }t1          j        |j        dd                   }t          j
        |t4          j                  } |||j        |	|j        j        |
|j        j        |           t          j        j                             ||           t          j!        |                              |d          S )a  Batched Cholesky decomposition.

    Decompose a given array of two-dimensional square matrices into
    ``L * L.T``, where ``L`` is a lower-triangular matrix and ``.T``
    is a conjugate transpose operator.

    Args:
        a (cupy.ndarray): The input array of matrices
            with dimension ``(..., N, N)``

    Returns:
        cupy.ndarray: The lower-triangular matrix.
    r   r   r
   )check_availabilitypotrfBatchedzpotrfBatched is not availablefdFr   Tr   copyr   r   Nr   FrP   )"r   r	   r   cupyx.cusolverrJ   RuntimeErrorr   linalg_common_typesizer   r   r   spotrfBatcheddpotrfBatchedcpotrfBatchedzpotrfBatchedr   _core	_mat_ptrsstridesr   r   r   r(   r   prodr   r   CUBLAS_FILL_MODE_UPPERr   r   linalg3_check_cusolver_dev_info_if_synchronization_allowedtril)ar	   r   rJ   r   	out_dtyperK   xxpr4   ldxr9   r5   r7   s                 rF   _potrf_batchedrg   j   s    /.....000000111111n-- <:;;;/22E9v{{z!'9---||-	#-	#--	c--A			a	 	 B	A
)B-17+
+C'))Fqwss|,,Jz*EK888HL-q"'+s:' ' ' 	KIIh      9Q<<yu555rH   c           
         ddl m} ddl m} t          j        |            t          j        |            t          j        |            | j        dk    rt          |           S t          j	        |           \  }}| j
        dk    rt          j        | j        |          S |                     |dd          }t          |           }t!          j                    }t          j        dt$          j        	          }|d
k    r|j        }	|j        }
n8|dk    r|j        }	|j        }
n#|dk    r|j        }	|j        }
n|j        }	|j        }
 |
||j        ||j        j        |          }t          j        ||	          } |	||j        ||j        j        ||j        j        ||j        j                   t          j        j                             |	|           t          j!        |d           |                    |d          S )a6  Cholesky decomposition.

    Decompose a given two-dimensional square matrix into ``L * L.H``,
    where ``L`` is a lower-triangular matrix and ``.H`` is a conjugate
    transpose operator.

    Args:
        a (cupy.ndarray): Hermitian (symmetric if all elements are real),
            positive-definite input matrix with dimension ``(..., M, M)``.

    Returns:
        cupy.ndarray: The lower-triangular matrix of shape ``(..., M, M)``.

    .. warning::
        This function calls one or more cuSOLVER routine(s) which may yield
        invalid results if input conditions are not met.
        To detect these invalid results, you can set the `linalg`
        configuration to a value that is not `ignore` in
        :func:`cupyx.errstate` or :func:`cupyx.seterr`.

    .. seealso:: :func:`numpy.linalg.cholesky`
    r   r   r
      r   TrO      r   rL   rM   rN   )kFrQ   )"r   r	   r   r   _assert_cupy_array_assert_stacked_2d_assert_stacked_squarendimrg   rT   rU   r   r   r   r   lenr   r(   r   r   spotrfspotrf_bufferSizedpotrfdpotrf_bufferSizecpotrfcpotrf_bufferSizezpotrfzpotrf_bufferSizer^   r   r   r_   r`   _tril)rb   r	   r   r   rc   rd   r4   r9   r7   potrfpotrf_bufferSizerD   rE   s                rF   choleskyr|      s   . /.....000000	Q	Q	 ###vzza   /22E9v{{z!'9---	c--AAA'))Fz!5;///H||#5	##5	##5#5!!-q!&*aA AJ
:U333I	E-q!&*aJ(9; ; ; 	KIIx   
KQ88IE8***rH   c                    ddl m} | j        d d         }t          j        |          }| j        dd          \  }}t          ||          }|dk    s|dk    rt          j        |           \  }}	|dk    r4t          j	        |||fz   |	          t          j	        |||fz   |	          fS |dk    r2t          j
        |||	          }
|
t          j	        |||fz   |	          fS |dk    rt          j	        |||fz   |	          S |dk    r3t          j	        |||fz   |	          t          j	        ||fz   |	          fS  | j        dg| j        dd          R  }  || |          }|dk    r%|                    ||j        dd          z             S |\  }
}|
                    ||
j        dd          z             }
|dk    rdnd}|                    ||j        |d          z             }|
|fS )	Nr   )_geqrf_orgqr_batchedr   reducedcompleterrawr   )rR   r~   r   r   r]   minr   rT   r   r   stacked_identityr   )rb   moder~   batch_shaper5   mr4   rk   r   rc   qoutr   idxs                 rF   _qr_batchedr      s)   333333'#2#,K{++J7233<DAqAq		A Q!q&& 3A66y9J{aV3Y??J{aV3Y??A AZ&{AyAAAtz+A"6	BBCCS[[:kQF2I>>>U]]J{aV3Y??J{aT19==? ? 		"&&&&A

q$
'
'Cs{{{{;2337888DAq			+,--A""2C			+-..Aq6MrH   r   c                 "
   ddl m} t          j        |            |dvr>|dv rd                    |          }nd                    |          }t          |          | j        dk    rt          | |          S t          j        |           \  }}| j	        \  }}t          ||          }|dk    r|dk    r.t          j        |df|          t          j        d|f|          fS |d	k    r,t          j        ||          t          j        ||f|          fS |d
k    rt          j        d|f|          S t          j        ||f|          t          j        d|          fS |                                                     |dd          }	t!          j                    }
t          j        dt$          j                  }|dk    r|j        }|j        }nh|dk    r|j        }|j        }nS|dk    r|j        }|j        }n>|dk    r|j        }|j        }n)d                    | j                  }t          |           ||
|||	j        j        |          }t          j        ||          }t          j        ||          } ||
|||	j        j        ||j        j        |j        j        ||j        j        	  	         t          j        j                             ||           |d
k    rI|	ddd|f                                         }t          j!        |                              |d          S |dk    r.|	                    |d          |                    |d          fS |d	k    r ||k    r|}t          j        ||f|          }n|}t          j        ||f|          }|	|d|<   |dk    r|j"        }|j#        }n>|dk    r|j$        }|j%        }n)|dk    r|j&        }|j'        }n|dk    r|j(        }|j)        } ||
||||j        j        ||j        j                  }t          j        ||          } ||
||||j        j        ||j        j        |j        j        ||j        j        
  
         t          j        j                             ||           |d|                                         }|	ddd|f                                         }|                    |d          t          j!        |                              |d          fS )a  QR decomposition.

    Decompose a given two-dimensional matrix into ``Q * R``, where ``Q``
    is an orthonormal and ``R`` is an upper-triangular matrix.

    Args:
        a (cupy.ndarray): The input matrix.
        mode (str): The mode of decomposition. Currently 'reduced',
            'complete', 'r', and 'raw' modes are supported. The default mode
            is 'reduced', in which matrix ``A = (..., M, N)`` is decomposed
            into ``Q``, ``R`` with dimensions ``(..., M, K)``, ``(..., K, N)``,
            where ``K = min(M, N)``.

    Returns:
        cupy.ndarray, or tuple of ndarray:
            Although the type of returned object depends on the mode,
            it returns a tuple of ``(Q, R)`` by default.
            For details, please see the document of :func:`numpy.linalg.qr`.

    .. warning::
        This function calls one or more cuSOLVER routine(s) which may yield
        invalid results if input conditions are not met.
        To detect these invalid results, you can set the `linalg`
        configuration to a value that is not `ignore` in
        :func:`cupyx.errstate` or :func:`cupyx.seterr`.

    .. seealso:: :func:`numpy.linalg.qr`
    r   r
   )r   r   r   r   )rL   fulleeconomicz)The deprecated mode '{}' is not supportedzUnrecognized mode '{}'ri   r   r   r   r   r   TrO   rj   r   rL   rM   rN   DzDdtype must be float32, float64, complex64 or complex128 (actual: {})NFrQ   r   )*r   r   r   rl   format
ValueErrorro   r   rT   r   r   r   r   identity	transposer   r   r(   r   r   sgeqrf_bufferSizesgeqrfdgeqrf_bufferSizedgeqrfcgeqrf_bufferSizecgeqrfzgeqrf_bufferSizezgeqrfr   r   r   r_   r`   _triusorgqr_bufferSizesorgqrdorgqr_bufferSizedorgqrcungqr_bufferSizecungqrzungqr_bufferSizezungqr)rb   r   r   msgr   rc   r   r4   rk   rd   r9   r7   geqrf_bufferSizegeqrfrD   rE   taur   mcr   orgqr_bufferSizeorgqrs                         rF   qrr     sK   : 100000	Q666111?FFtLLCC,33D99Coovzz1d### /22E97DAqAq		AAvv9:q!fi00$*aVY2O2OOOZ=I..
Aq690M0MMMS[[:q!fi000:q!fi00$*T92M2MMM	U#D99A'))Fz!5;///H||#5	##5	##5	##5%vag 	oo "!&!Q
A>>J
:U333I
*Qe
$
$
$C	E&!Q
A
(,	*J8IK K KKIIx   s{{aaa!eH  {1~~$$YU$;;;u}}HHYUH++JJyuJ--/ 	/ za!eeJ1vu%%J1vu%%AbqbE ||#5	##5	##5	##5!!2q!&*a7 7J
:U333I	E2q!&*ay~7IHM%' ' ' 	KIIx   	
#2#A	!!!SbS&	A	''Aie446 6rH   c                 0   ddl m}m} | j        d d         }t	          j        |          }| j        dd          \  }}t          j        |           \  }	}
|
j        	                                }|dk    rt          ||          }t          j        ||fz   |          }|rt|r7t          j        |||fz   |
          }t          j        |||fz   |
          }n6t          j        |||fz   |
          }t          j        |||fz   |
          }|||fS |S |dk    s|dk    rt          j        |dz   |          }|rj|r-t          j        |||
          }t          j        |||
          }n6t          j        ||dfz   |
          }t          j        |d|fz   |
          }|||fS |S  | j        dg| j        dd          R  } t          j        s|dk    r-|dk    r'|                     |	dd	
          }  || ||d	          }n || |	j        ||d	          }|r|\  }}}|                    |
d	          } |j        g ||j        dd          R  }|                    |d	          } |j        g ||j        dd          R  }|                    |
d	          } |j        g ||j        dd          R  }|||                    dd                                          fS |}|                    |d	          } |j        g ||j        dd          R  }|S )Nr   )_gesvdj_batched_gesvd_batchedr   r   r   r       r   FrO   rQ   )rR   r   r   r   r   r]   r   rT   charlowerr   r   r   r   r   r   is_hipr   swapaxesconj)rb   full_matrices
compute_uvr   r   r   r5   r4   r   r   uv_dtypes_dtyperk   suvtr   vs                     rF   _svd_batchedr     s   >>>>>>>>'#2#,K{++J7233<DAq.q11OE8m!!##G Q1IIJ{aT)733 		 FJ{aV38DDDZq!f 4HEEEJ{aV38DDDZq!f 4HEEEa8OH	
a166J{T)733 		 F*;8DD+KHEEJ{aV38DDDZq!f 4HEEEa8OH 		"&&&&A~ N!r''a2ggHHU#EH22oa
EBB
 nQ
M:uMM 1aHHXEH**AI4{4agbccl444HHW5H))AI4{4agbccl444HHXEH**AI4{4agbccl444!QZZB'',,....HHW5H))AI4{4agbccl444rH   Tc                    ddl m} t          j        |            | j        dk    rt          | ||          S t          j        |           \  }}|j                                        }|j                                        }| j	        \  }}	|	dk    s|dk    r}t          j        d|          }
|rd|r-t          j        ||          }t          j        |	|          }n0t          j        |df|          }t          j        d|	f|          }||
|fS |
S |	|k    r|                     |dd          }d	}n6| j	        \  }	}|                                                     |dd          }d}|}|r|rEt          j        |	|	f|          }|d
d
d
|f         }t          d          }t          d          }n8|}t          j        ||f|          }t          d          }t          d          }|j        j        |j        j        }}n#d\  }}t          d          }t          d          }t          j        ||          }
t%          j                    }t          j        dt(          j                  }|dk    r|j        }|j        }n8|dk    r|j        }|j        }n#|dk    r|j        }|j        }n|j        }|j        } |||	|          }t          j        ||          }t<          j        sd}n3t          j        tA          |	|          dz
  |          }|j        j        } |||||	||j        j        |	|
j        j        ||	|||j        j        |||j        j                   t          j!        j        "                    ||           |
                    |d	          }
|r^|                    |d	          }|                    |d	          }|r)|                                |
|                                fS ||
|fS |
S )a  Singular Value Decomposition.

    Factorizes the matrix ``a`` as ``u * np.diag(s) * v``, where ``u`` and
    ``v`` are unitary and ``s`` is an one-dimensional array of ``a``'s
    singular values.

    Args:
        a (cupy.ndarray): The input matrix with dimension ``(..., M, N)``.
        full_matrices (bool): If True, it returns u and v with dimensions
            ``(..., M, M)`` and ``(..., N, N)``. Otherwise, the dimensions
            of u and v are ``(..., M, K)`` and ``(..., K, N)``, respectively,
            where ``K = min(M, N)``.
        compute_uv (bool): If ``False``, it only returns singular values.

    Returns:
        tuple of :class:`cupy.ndarray`:
            A tuple of ``(u, s, v)`` such that ``a = u * np.diag(s) * v``.

    .. warning::
        This function calls one or more cuSOLVER routine(s) which may yield
        invalid results if input conditions are not met.
        To detect these invalid results, you can set the `linalg`
        configuration to a value that is not `ignore` in
        :func:`cupyx.errstate` or :func:`cupyx.seterr`.

    .. note::
        On CUDA, when ``a.ndim > 2`` and the matrix dimensions <= 32, a fast
        code path based on Jacobian method (``gesvdj``) is taken. Otherwise,
        a QR method (``gesvd``) is used.

        On ROCm, there is no such a fast code path that switches the underlying
        algorithm.

    .. seealso:: :func:`numpy.linalg.svd`
    r   r
   ri   r   r   r   TrO   FNAOS)r   r   Nrj   rL   rM   rN   rQ   )#r   r   r   rl   ro   r   rT   r   r   r   r   r   eyer   r   ordr   r   r   r(   r   r   sgesvdsgesvd_bufferSizedgesvddgesvd_bufferSizecgesvdcgesvd_bufferSizezgesvdzgesvd_bufferSizer   r   r   r_   r`   )rb   r   r   r   r   r   
real_dtyper   r4   r   r   r   r   rd   
trans_flagrk   job_ujob_vtu_ptrvt_ptrr9   r7   gesvdgesvd_bufferSizerD   rE   	rwork_ptrrworks                               rF   svdr     s1   H 100000	QvzzA}j999 .q11OE8!!##Jm!!##G 7DAqAvvaJtW%% 		 8HQh///Xax000J1vX666ZAh777a8OH 	AvvHHU#DH11

w1KKMM  c ==
	A  		
Aq6///A111bqb5BHHEXXFFAQF%000BHHEXXF
BGKvvCS
1J'''A'))Fz!5;///H||#5	##5	##5#5!!&!Q//J
:U333I> # 		
3q!99Q;g666JN		Evq!QVZAFJq9>%z9   	KIIx   	
u%%A  HHXEH**YYxeY,, 	;;==!R\\^^33q!8OrH   )r   )TT)r   r   cupy_backends.cuda.apir   
cupy._corer   	cupy.cudar   cupy.linalgr   rG   rg   r|   r   r   r   r    rH   rF   <module>r      s      * * * * * *                  ] ] ]@06 06 06fA+ A+ A+H# # #LC6 C6 C6 C6L> > >DF F F F F FrH   