o i6@sddlZddlZddlmZddlmZddlmZddlmZddl m Z ddl m Z   ddd Z  dd d Z  dd d ZddZddZddZdS)N)cublas)_dtype)device)_csr) _interfaceh㈵>cCstt||||\}}}}|j} |j} |jd} |dur| d}| dkr)t|dfStj|} | dkr7|dfS|durB|t| }n tt||t| }|| |} d}d}||kr| | }|}t | |}|dkrn|}n ||}|||}| |}|t ||}|||}| ||} |d7}|dur||t | }||krn||ks[d}||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_normritersrhozrho1pbetaqalpharesidinfor,a/home/ubuntu/veenaModal/venv/lib/python3.10/site-packages/cupyx/scipy/sparse/linalg/_iterative.pycg sP!        r.c Cst||||\}}} }|j} |j} |jd} | dkr!t|dfStj|}|dkr/|dfS|dur:|t|}n tt||t|}|durM| d}|durSd}t || }| dur^d} | dvrit d | |durod} tj | |f|j dd }tj|d |f|j dd }tj|d f|j d }t|}d} | | }|| |}t|}| d kr||n| dkr|dkr|||||ks||krnr||}||dddf<||d<t|D]A}| |}| |}|||\|d|d |f<}tj|||d |fd|d |kr|||d |f}||dd|d f<qtjt||}t|d}| ||7} ||7}qd}||krH||ksH|}||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` rNrpr_norm)rr0zUnknown callback_type: {}F)dtypeorderr r2Tr)out)r r r r rrrrrmin ValueErrorformatemptyr2zerosnumpy_make_compute_hurrrangelstsqasnumpyarray)rrrrrestartrrrr callback_typerr rrr VHe compute_hur"mxr!r_normvjr$uretyr+r,r,r-gmres\sv)         rNcCst||||\}}}}|j} |j} |jd} | dkr!t|dfStj|} | dkr/|dfS|dur:|t| }n tt||t| }|durM| d}|| |} t | | }| }| }| }d} | |}| |}t | |}||}|||}| ||}|||7}| |}|||8}tj|}|d7}|dur||||ks||krn#t | |}||}|}|||}||9}||7}||9}||7}qfd}||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 r r rrrrrdotcopy)rrrrrrrrrr rrr r0r#r!rKr&r"rMrIsigmar)r(r$AzrHrho_newr'r+r,r,r-cgssb            rVcCsjt|}t|}|durtj|j||j|jd}|jd|jdkr+td|j|jj dvr9t d|j|jd}|j|fksO|j|dfksOtd| |j }|duret j|f|jd }n|j|fksv|j|dfksvtd | |j }|durtj|j|jd }n#t|}t|}|durtj|j||j|jd}|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 rmatvecr2rr z"expected square matrix (shape: {})fdFDzunsupprted dtype (actual: {})zb has incompatible dimensionsr4zx0 has incompatible dimensions)r r2z/matrix and preconditioner have different shapes)_make_fast_matvecraslinearoperatorLinearOperatorr rWr2r7r8char TypeErrorastyperavelr r:IdentityOperator)rrrr fast_matvecrrr,r,r-r +s<        r c s ddlmddlmt|rdrtj t d|j t d|j t |j jtj|jdf|j d}tj|jdf|j d}j|j|}j|} jjj|jjj|j }t|tj~~~~ f dd}|SdS) Nr)cusparsespmv?r4c sTt|}j|}j|} jjj|jjj|jjj |S)N) r rDnVecDescriptorcreatespMVctypesdatadescptr)rrMdesc_xdesc_y _cusparsealgr)r'buff cuda_dtyperbdesc_Ahandleop_ar,r-r ts   z!_make_fast_matvec..matvec)cupy_backends.cuda.libsrbcupyxrisspmatrix_csrcheck_availabilityrget_cusparse_handle CUSPARSE_OPERATION_NON_TRANSPOSEr;r@r2r to_cuda_dtypeCUSPARSE_MV_ALG_DEFAULTr r9r SpMatDescriptorrgrfspMV_bufferSizerirjrkint8)rrrMrmrn buff_sizer r,ror-rY^s.       rYcstjjdkrtjnjjdkrtjnjjdkr"tjn jjdkr+tjj dt djt djt djfd d }|S) Nfdr1Drrdregc stj|dfjd}tj|djjjj|jjdjj|jjd tj|djjjj|jjdjj|jjd ||fS)Nr r4) r r9r2_cublas CUBLAS_OP_Crirjrl CUBLAS_OP_N)rKrJhrCgemvrumoneronezeror,r-rFsz$_make_compute_hu..compute_hu) rget_cublas_handler2r\rsgemvdgemvcgemvzgemvr r;r@)rCrFr,rr-r<s      r<)NrNNNN)NrNNNNNN)r;r r cupy._corer cupy.cudarrwrcupyx.scipy.sparsercupyx.scipy.sparse.linalgrr.rNrVr rYr<r,r,r,r-s(       P o `3 #