doi9SrSSKrSSKJrJrJrJr SSKJr SSK J r J r SSK J r /SQrSS jr\"S 5SS j5r\"S 5SS j5rSS jr\"SS5S5r\"S5SSj5rSSjr\"SS5S5rg)z!Cholesky decomposition functions.N)asarray_chkfiniteasarray atleast_2d empty_like)_apply_over_batch) LinAlgError _datacopied)get_lapack_funcs)cholesky cho_factor cho_solvecholesky_bandedcho_solve_bandedcbU(a [U5O [U5n[U5nURS:wa[ SURS35eUR SUR S:wa[ SUR S35eUR S:Xa=[[R"SURS95Rn[XVS9U4$U=(d [XP5n[S U45unU"XQX#S 9upU S:a[U S 35eU S:a[ S U *S 35eX4$)z,Common code for cholesky() and cho_factor().z*Input array needs to be 2D but received a zd-array.rrz8Input array is expected to be square but has the shape: .dtype)potrf)lower overwrite_acleanz7-th leading minor of the array is not positive definitez$LAPACK reported an illegal value in z!-th argument on entry to "POTRF".)rrrndim ValueErrorshapesizer npeyerrr r r ) arrr check_finitea1dtrcinfos Y/var/www/html/land-ocr/venv/lib/python3.13/site-packages/scipy/linalg/_decomp_cholesky.py _choleskyr's:". 1 71:B BB ww!|EbggYhWXX xx{bhhqk!'')xxj34 4 ww!| bffQbhh/ 0 6 6"'..3R!3K j2% 0FEBJGA axfK L   ax2D5':# $   8O)r rc"[XUSUS9upAU$)a Compute the Cholesky decomposition of a matrix. Returns the Cholesky decomposition, :math:`A = L L^*` or :math:`A = U^* U` of a Hermitian positive-definite matrix A. Parameters ---------- a : (M, M) array_like Matrix to be decomposed lower : bool, optional Whether to compute the upper- or lower-triangular Cholesky factorization. During decomposition, only the selected half of the matrix is referenced. Default is upper-triangular. overwrite_a : bool, optional Whether to overwrite data in `a` (may improve performance). check_finite : bool, optional Whether to check that the entire input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- c : (M, M) ndarray Upper- or lower-triangular Cholesky factor of `a`. Raises ------ LinAlgError : if decomposition fails. Notes ----- During the finiteness check (if selected), the entire matrix `a` is checked. During decomposition, `a` is assumed to be symmetric or Hermitian (as applicable), and only the half selected by option `lower` is referenced. Consequently, if `a` is asymmetric/non-Hermitian, `cholesky` may still succeed if the symmetric/Hermitian matrix represented by the selected half is positive definite, yet it may fail if an element in the other half is non-finite. Examples -------- >>> import numpy as np >>> from scipy.linalg import cholesky >>> a = np.array([[1,-2j],[2j,5]]) >>> L = cholesky(a, lower=True) >>> L array([[ 1.+0.j, 0.+0.j], [ 0.+2.j, 1.+0.j]]) >>> L @ L.T.conj() array([[ 1.+0.j, 0.-2.j], [ 0.+2.j, 5.+0.j]]) Trrrr!r'r rrr!r$s r&r r 2sp[&24HA Hr(c$[XUSUS9upAXA4$)a Compute the Cholesky decomposition of a matrix, to use in cho_solve Returns a matrix containing the Cholesky decomposition, ``A = L L*`` or ``A = U* U`` of a Hermitian positive-definite matrix `a`. The return value can be directly used as the first parameter to cho_solve. .. warning:: The returned matrix also contains random data in the entries not used by the Cholesky decomposition. If you need to zero these entries, use the function `cholesky` instead. Parameters ---------- a : (M, M) array_like Matrix to be decomposed lower : bool, optional Whether to compute the upper or lower triangular Cholesky factorization. During decomposition, only the selected half of the matrix is referenced. (Default: upper-triangular) overwrite_a : bool, optional Whether to overwrite data in a (may improve performance) check_finite : bool, optional Whether to check that the entire input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- c : (M, M) ndarray Matrix whose upper or lower triangle contains the Cholesky factor of `a`. Other parts of the matrix contain random data. lower : bool Flag indicating whether the factor is in the lower or upper triangle Raises ------ LinAlgError Raised if decomposition fails. See Also -------- cho_solve : Solve a linear set equations using the Cholesky factorization of a matrix. Notes ----- During the finiteness check (if selected), the entire matrix `a` is checked. During decomposition, `a` is assumed to be symmetric or Hermitian (as applicable), and only the half selected by option `lower` is referenced. Consequently, if `a` is asymmetric/non-Hermitian, `cholesky` may still succeed if the symmetric/Hermitian matrix represented by the selected half is positive definite, yet it may fail if an element in the other half is non-finite. Examples -------- >>> import numpy as np >>> from scipy.linalg import cho_factor >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]]) >>> c, low = cho_factor(A) >>> c array([[3. , 1. , 0.33333333, 1.66666667], [3. , 2.44948974, 1.90515869, -0.27216553], [1. , 5. , 2.29330749, 0.8559528 ], [5. , 1. , 2. , 1.55418563]]) >>> np.allclose(np.triu(c).T @ np. triu(c) - A, np.zeros((4, 4))) True Fr*r+r,s r&r r os!P[&24HA 8Or(c UupE[XAXRUS9$)aSolve the linear equations A x = b, given the Cholesky factorization of A. The documentation is written assuming array arguments are of specified "core" shapes. However, array argument(s) of this function may have additional "batch" dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details. Parameters ---------- (c, lower) : tuple, (array, bool) Cholesky factorization of a, as given by cho_factor b : array Right-hand side overwrite_b : bool, optional Whether to overwrite data in b (may improve performance) check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- x : array The solution to the system A x = b See Also -------- cho_factor : Cholesky factorization of a matrix Examples -------- >>> import numpy as np >>> from scipy.linalg import cho_factor, cho_solve >>> A = np.array([[9, 3, 1, 5], [3, 7, 5, 1], [1, 5, 9, 2], [5, 1, 2, 6]]) >>> c, low = cho_factor(A) >>> x = cho_solve((c, low), [1, 1, 1, 1]) >>> np.allclose(A @ x - [1, 1, 1, 1], np.zeros(4)) True  overwrite_br!) _cho_solve) c_and_lowerbr0r!r$rs r&rrsRHA aE VVr()r$r)r3z1|2cU(a[U5n[U5nO[U5n[U5nURS:wd URSURS:wa [ S5eURSURS:wa&[ SURSURS35eUR S:Xa[[ [R"SURS9S 4[R"SURS95Rn[XVS9$U=(d [XQ5n[S X45unU"XX#S 9upU S:wa[ S U *S 35eU$)Nrrrz$The factored matrix c is not square.zincompatible dimensions (z and )rT)potrsrr0illegal value in zth argument of internal potrs)rrrrrrrrrronesrr r ) r$r3rr0r!b1r#r6xr%s r&r1r1s7 q ! a  QZ AJvv{aggajAGGAJ.?@@wwqzRXXa[ 4QWWIU288*ANOO ww!| q14813385 "''3R!3K j1' 2FEA@GA qy,dUG3PQRR Hr()abrcfU(a [U5nO [U5nURS:XaA[[R "SS/SS//UR S95R n[XS9$[SU45unU"XUS9upgUS:a[US35eUS:a[SUS35eU$) a Cholesky decompose a banded Hermitian positive-definite matrix The matrix a is stored in ab either in lower-diagonal or upper- diagonal ordered form:: ab[u + i - j, j] == a[i,j] (if upper form; i <= j) ab[ i - j, j] == a[i,j] (if lower form; i >= j) Example of ab (shape of a is (6,6), u=2):: upper form: * * a02 a13 a24 a35 * a01 a12 a23 a34 a45 a00 a11 a22 a33 a44 a55 lower form: a00 a11 a22 a33 a44 a55 a10 a21 a32 a43 a54 * a20 a31 a42 a53 * * Parameters ---------- ab : (u + 1, M) array_like Banded matrix overwrite_ab : bool, optional Discard data in ab (may enhance performance) lower : bool, optional Is the matrix in the lower form. (Default is upper form) check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- c : (u + 1, M) ndarray Cholesky factorization of a, in the same banded format as ab See Also -------- cho_solve_banded : Solve a linear set equations, given the Cholesky factorization of a banded Hermitian. Examples -------- >>> import numpy as np >>> from scipy.linalg import cholesky_banded >>> from numpy import allclose, zeros, diag >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]]) >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1) >>> A = A + A.conj().T + np.diag(Ab[2, :]) >>> c = cholesky_banded(Ab) >>> C = np.diag(c[0, 2:], k=2) + np.diag(c[1, 1:], k=1) + np.diag(c[2, :]) >>> np.allclose(C.conj().T @ C - A, np.zeros((5, 5))) True rrr)pbtrf)r overwrite_abz'-th leading minor not positive definiter8z-th argument of internal pbtrf) rrrrrarrayrrr r r)r<r?rr!r#r>r$r%s r&rrsz r " R[ ww!| RXX1v1v&6bhhG H N N"'' j2% 0FEB,?GA axTF"IJKK ax,TF2PQRR Hr(c UupE[XAXRUS9$)a4 Solve the linear equations ``A x = b``, given the Cholesky factorization of the banded Hermitian ``A``. The documentation is written assuming array arguments are of specified "core" shapes. However, array argument(s) of this function may have additional "batch" dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details. Parameters ---------- (cb, lower) : tuple, (ndarray, bool) `cb` is the Cholesky factorization of A, as given by cholesky_banded. `lower` must be the same value that was given to cholesky_banded. b : array_like Right-hand side overwrite_b : bool, optional If True, the function will overwrite the values in `b`. check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- x : array The solution to the system A x = b See Also -------- cholesky_banded : Cholesky factorization of a banded matrix Notes ----- .. versionadded:: 0.8.0 Examples -------- >>> import numpy as np >>> from scipy.linalg import cholesky_banded, cho_solve_banded >>> Ab = np.array([[0, 0, 1j, 2, 3j], [0, -1, -2, 3, 4], [9, 8, 7, 6, 9]]) >>> A = np.diag(Ab[0,2:], k=2) + np.diag(Ab[1,1:], k=1) >>> A = A + A.conj().T + np.diag(Ab[2, :]) >>> c = cholesky_banded(Ab) >>> x = cho_solve_banded((c, False), np.ones(5)) >>> np.allclose(A @ x - np.ones(5), np.zeros(5)) True r/)_cho_solve_banded) cb_and_lowerr3r0r!cbrs r&rrVs fKR RE*6 88r()rDrc@U(a[U5n[U5nO[U5n[U5nURSURS:wa [S5eURS:Xal[ [ R"SS/SS//URS95n[US4[ R"SURS95Rn[XS9$[SX45unU"XX#S 9upU S:a[U S 35eU S:a[S U *S 35eU$) Nrz&shapes of cb and b are not compatible.rrTr)pbtrsr7z&th leading minor not positive definiter8zth argument of internal pbtrs)rrrrrrrr@rrr9rr r ) rDr3rr0r!mr#rGr;r%s r&rBrBs r " a  R[ AJ xx|qwwqz!ABB vv{ BHHq!fq!f%5RXXF G q$i!'')B C I I!&& j2' 2FEB@GA axTF"HIJJ ax,dUG3PQRR Hr()FFTT)FFT)FT)__doc__numpyrrrrrscipy._lib._utilr_miscr r lapackr __all__r'r r rr1rrrBr(r&rPs'DD/+$ 8< F89 9 x8IIX*WZ8\* + 89L L ^58p9l+ , r(