`i6ddlZddlZddlmZddlmZddlmZddlmZddl m Z ddl m Z  ddZ dd Z dd Zd Zd Zd ZdS)N)cublas)_dtype)device)_csr) _interfaceh㈵>ct||||\}}}}|j} |j} |jd} || dz}| dkrtj|dfStj|} | dkr|dfS||t| z}n-tt||t| z}|| |z } d}d}||kr| | }|}tj | |}|dkr|}n ||z }|||zz}| |}|tj ||z }|||zz}| ||zz } |dz }| ||tj | }||krn||kd}||kr||ks|}||fS)aUses Conjugate Gradient iteration to solve ``Ax = b``. Args: A (ndarray, spmatrix or LinearOperator): The real or complex matrix of the linear system with shape ``(n, n)``. ``A`` must be a hermitian, positive definitive matrix with type of :class:`cupy.ndarray`, :class:`cupyx.scipy.sparse.spmatrix` or :class:`cupyx.scipy.sparse.linalg.LinearOperator`. b (cupy.ndarray): Right hand side of the linear system with shape ``(n,)`` or ``(n, 1)``. x0 (cupy.ndarray): Starting guess for the solution. tol (float): Tolerance for convergence. maxiter (int): Maximum number of iterations. M (ndarray, spmatrix or LinearOperator): Preconditioner for ``A``. The preconditioner should approximate the inverse of ``A``. ``M`` must be :class:`cupy.ndarray`, :class:`cupyx.scipy.sparse.spmatrix` or :class:`cupyx.scipy.sparse.linalg.LinearOperator`. callback (function): User-specified function to call after each iteration. It is called as ``callback(xk)``, where ``xk`` is the current solution vector. atol (float): Tolerance for convergence. Returns: tuple: It returns ``x`` (cupy.ndarray) and ``info`` (int) where ``x`` is the converged solution and ``info`` provides convergence information. .. seealso:: :func:`scipy.sparse.linalg.cg` rN ) _make_systemmatvecshapecupy empty_likelinalgnormfloatmaxrdotcnrm2)Abx0tolmaxiterMcallbackatolxr psolvenb_normritersrhozrho1pbetaqalpharesidinfos x/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupyx/scipy/sparse/linalg/_iterative.pycgr/ sBaB**JAq!Q XF XF  Ab&Avvq!!1$$ [  a F {{!t  |U6]]"5;;eFmm 344 FF1II A E C '// F1IIk!Q A::AA:DD1H A F1IIfk!Q'''  M  M     HQKKK A D== % '//( D $ d7Nc t||||\}}} }|j} |j} |jd} | dkrtj|dfStj|}|dkr|dfS||t|z}n-tt||t|z}|| dz}|d}t|| }| d} | dvr"td | |d} tj | |f|j d }tj|d z|f|j d }tj|d zf|j }t!|}d} | | }|| |z }t#j|}| d kr ||n| dkr|dkr|||z ||ks||krn||z }||dddf<||d<t'|D]w}| |}| |}|||\|d|d z|f<}t#j|||d z|f|d z|kr|||d z|fz }||dd|d zf<xtjtj||}tj|d}| ||zz } ||z }[d}||kr||ks|}||fS)aUses Generalized Minimal RESidual iteration to solve ``Ax = b``. Args: A (ndarray, spmatrix or LinearOperator): The real or complex matrix of the linear system with shape ``(n, n)``. ``A`` must be :class:`cupy.ndarray`, :class:`cupyx.scipy.sparse.spmatrix` or :class:`cupyx.scipy.sparse.linalg.LinearOperator`. b (cupy.ndarray): Right hand side of the linear system with shape ``(n,)`` or ``(n, 1)``. x0 (cupy.ndarray): Starting guess for the solution. tol (float): Tolerance for convergence. restart (int): Number of iterations between restarts. Larger values increase iteration cost, but may be necessary for convergence. maxiter (int): Maximum number of iterations. M (ndarray, spmatrix or LinearOperator): Preconditioner for ``A``. The preconditioner should approximate the inverse of ``A``. ``M`` must be :class:`cupy.ndarray`, :class:`cupyx.scipy.sparse.spmatrix` or :class:`cupyx.scipy.sparse.linalg.LinearOperator`. callback (function): User-specified function to call on every restart. It is called as ``callback(arg)``, where ``arg`` is selected by ``callback_type``. callback_type (str): 'x' or 'pr_norm'. If 'x', the current solution vector is used as an argument of callback function. if 'pr_norm', relative (preconditioned) residual norm is used as an argument. atol (float): Tolerance for convergence. Returns: tuple: It returns ``x`` (cupy.ndarray) and ``info`` (int) where ``x`` is the converged solution and ``info`` provides convergence information. Reference: M. Wang, H. Klie, M. Parashar and H. Sudan, "Solving Sparse Linear Systems on NVIDIA Tesla GPUs", ICCS 2009 (2009). .. seealso:: :func:`scipy.sparse.linalg.gmres` rNr pr_norm)rr3zUnknown callback_type: {}F)dtypeorderr r5Tr)out)r r rrrrrrrmin ValueErrorformatemptyr5zerosnumpy_make_compute_hurrrangelstsqasnumpyarray)rrrrrestartrrrr callback_typerr r r!r"VHe compute_hur$mxr#r_normvjr&uretyr-s r.gmresrQ\sURaB**JAq!Q XF XF  AAvvq!!1$$ [  a F {{!t  |U6]]"5;;eFmm 344b&'1ooG! ,,,4;;MJJKKK  Aw>Ug--  J!!!Q$!w  Aq Aq A&Jq!,,MAdqsdAgJ Kq1ay ) ) ) )sW}}!A#q& M!!!QqS& l  a!44 Js1v   QU  ;> D 4 t8Or0ct||||\}}}}|j} |j} |jd} | dkrtj|dfStj|} | dkr|dfS||t| z}n-tt||t| z}|| dz}|| |z } tj | | }| }| }| }d} | |}| |}tj | |}||z }|||zz }| ||z}|||zz }| |}|||zz}tj|}|dz }| ||||ks||krn9tj | |}||z }|}|||zz}||z}||z }||z}||z }d}||kr||ks|}||fS)aUse Conjugate Gradient Squared iteration to solve ``Ax = b``. Args: A (ndarray, spmatrix or LinearOperator): The real or complex matrix of the linear system with shape ``(n, n)``. b (cupy.ndarray): Right hand side of the linear system with shape ``(n,)`` or ``(n, 1)``. x0 (cupy.ndarray): Starting guess for the solution. tol (float): Tolerance for convergence. maxiter (int): Maximum number of iterations. M (ndarray, spmatrix or LinearOperator): Preconditioner for ``A``. The preconditioner should approximate the inverse of ``A``. ``M`` must be :class:`cupy.ndarray`, :class:`cupyx.scipy.sparse.spmatrix` or :class:`cupyx.scipy.sparse.linalg.LinearOperator`. callback (function): User-specified function to call after each iteration. It is called as ``callback(xk)``, where ``xk`` is the current solution vector. atol (float): Tolerance for convergence. Returns: tuple: It returns ``x`` (cupy.ndarray) and ``info`` (int) where ``x`` is the converged solution and ``info`` provides convergence information. .. seealso:: :func:`scipy.sparse.linalg.cgs` rNTr ) r r rrrrrrrdotcopy)rrrrrrrrrr r r!r"r0r%r#rNr(r$rPrLsigmar+r*r&AzrKrho_newr)r-s r.cgsrZsJ<aB**JAq!Q XF XF  AAvvq!!1$$ [  a F {{!t  |U6]]"5;;eFmm 344a% VVAYYB (2r  C  A A  A E F1II F1IIQe   M F1q5MM UQY VAYY URZ!!!$$     HQKKK T>>Ug-- (2q//} qL T  Q T  Q;> D $ d7Nr0cZt|}tj|}|'tj|j||j|j}|jd|jdkr'td|j|jj dvr'td|j|jd}|j|fks|j|dfkstd| |j }|tj|f|j }nT|j|fks|j|dfkstd | |j }|!tj|j|j }nkt|}tj|}|'tj|j||j|j}|j|jkrtd ||||fS) aMake a linear system Ax = b Args: A (cupy.ndarray or cupyx.scipy.sparse.spmatrix or cupyx.scipy.sparse.LinearOperator): sparse or dense matrix. M (cupy.ndarray or cupyx.scipy.sparse.spmatrix or cupyx.scipy.sparse.LinearOperator): preconditioner. x0 (cupy.ndarray): initial guess to iterative method. b (cupy.ndarray): right hand side. Returns: tuple: It returns (A, M, x, b). A (LinaerOperator): matrix of linear system M (LinearOperator): preconditioner x (cupy.ndarray): initial guess b (cupy.ndarray): right hand side. N)r rmatvecr5rr z"expected square matrix (shape: {})fdFDzunsupprted dtype (actual: {})zb has incompatible dimensionsr7zx0 has incompatible dimensions)rr5z/matrix and preconditioner have different shapes)_make_fast_matvecraslinearoperatorLinearOperatorrr\r5r:r;char TypeErrorastyperavelrr=IdentityOperator)rrrr fast_matvecr!rs r.r r +s&$A&&K#A&&A  %agk./iqw H H HwqzQWQZ=DDQWMMNNNw|6!!7>>qwGGHHH  A GtOOqw1a&008999 !!A z Jt17 + + +QD  BHA$6$6=>> > IIag   $ $ & &y  'agQW E E E'**  ' * *  ")!'+23)17LLLA 7ag  NOO O aA:r0c  ddlmddlm tj|r dr}t jjtj d|j  tj d|j  tj |j  jtj|jdf|j }tj|jdf|j } j| j|} j|} jjj|j jj|j  }tj|tj ~~~~ f d}|SdS)Nr)cusparsespmv?r7c . tj|} j|} j|} jj j|jjj|j jj |S)N) rrDnVecDescriptorcreatespMVctypesdatadescptr)rrPdesc_xdesc_y _cusparsealgr+r)buff cuda_dtyperhdesc_Ahandleop_as r.r z!_make_fast_matvec..matvects""A-44Q77F-44Q77F NNel/fk  &+z3  O O OHr0)cupy_backends.cuda.libsrhcupyxrisspmatrix_csrcheck_availabilityrget_cusparse_handle CUSPARSE_OPERATION_NON_TRANSPOSEr>rCr5r to_cuda_dtypeCUSPARSE_MV_ALG_DEFAULTrr<rSpMatDescriptorrnrmspMV_bufferSizerprqrrint8)rrrPrtru buff_sizer rvrwr+r)rxryrhrzr{r|s @@@@@@@@@@r.r^r^^s====== 1("="=f"E"E+--9 C)){3(()!'22 / J }AG 4 4 4 J }AG 4 4 4)0033)0033)0033-- D%,+V[&+ K fk:s<< z)TY// vq&               4r0ctjjjdkr tjnVjjdkr tjn9jjdkr tjnjjdkr tjj dtj djtj djtj djfd }|S) Nfdr4Drrjrkgctj|dzfj}tj|dzjjjj|jjd jj|jjd tj|dzjjjj|jjdjj|jjd ||fS)Nr r7) rr<r5_cublas CUBLAS_OP_Crprqrs CUBLAS_OP_N) rNrMhrFgemvr{moner!onezeros r.rIz$_make_compute_hu..compute_hus J!vQW - - - VW(!QqS#*/16:  At{/Q @ @ @ VW(!QqS$+2BAFJ  Asz A ? ? ?!t r0) rget_cublas_handler5rarsgemvdgemvcgemvzgemvrr>rC)rFrIrr{rr!rrs` @@@@@@r.r?r?s  % ' 'Fw|s}   }   }   }  A +c17 # #C ;sAG $ $D ;tQW % %D r0)NrNNNN)NrNNNNNN)r>rr cupy._corer cupy.cudarr}rcupyx.scipy.sparsercupyx.scipy.sparse.linalgrr/rQrZr r^r?r0r.rs% 555555######000000@D MMMM`BF26llll^AE ]]]]@000f   Fr0