+ /iD1^RIHt^RIt^RIHtHtHtHtHtH t H t H t H t H t ^RIHt^RIHt^RIHt^RIHtHtR.t]!R 4RR l4tRR ltRR ltRR ltR#))warnN) atleast_2darange zeros_likeimagdiag iscomplexobjtriltriuargsort empty_like)ComplexWarning)_apply_over_batch)_asarray_validated)get_lapack_funcs_compute_lworkldlc<\\WR74pVP^,VP^,8wd \R4hVP^8Xd2\ V4\ V4\ P!.\R73#VP^,p\V4'd\M\pV\JdMV'dERRr\ P!\\V444'd\R\ ^R7MRR r\#W3V34wr\%WVR 7p V !W\VVR 7wrpV^8d!\VP'4 R V) R 24h\)WR 7wpp\+V VWR7wpp\-VVVVR 7wppVVV3#)a Computes the LDLt or Bunch-Kaufman factorization of a symmetric/ hermitian matrix. This function returns a block diagonal matrix D consisting blocks of size at most 2x2 and also a possibly permuted unit lower triangular matrix ``L`` such that the factorization ``A = L D L^H`` or ``A = L D L^T`` holds. If `lower` is False then (again possibly permuted) upper triangular matrices are returned as outer factors. The permutation array can be used to triangularize the outer factors simply by a row shuffle, i.e., ``lu[perm, :]`` is an upper/lower triangular matrix. This is also equivalent to multiplication with a permutation matrix ``P.dot(lu)``, where ``P`` is a column-permuted identity matrix ``I[:, perm]``. Depending on the value of the boolean `lower`, only upper or lower triangular part of the input array is referenced. Hence, a triangular matrix on entry would give the same result as if the full matrix is supplied. Parameters ---------- A : array_like Square input array lower : bool, optional This switches between the lower and upper triangular outer factors of the factorization. Lower triangular (``lower=True``) is the default. hermitian : bool, optional For complex-valued arrays, this defines whether ``A = A.conj().T`` or ``A = A.T`` is assumed. For real-valued arrays, this switch has no effect. overwrite_a : bool, optional Allow overwriting data in `A` (may enhance performance). The default is False. 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 ------- lu : ndarray The (possibly) permuted upper/lower triangular outer factor of the factorization. d : ndarray The block diagonal multiplier of the factorization. perm : ndarray The row-permutation index array that brings lu into triangular form. Raises ------ ValueError If input array is not square. ComplexWarning If a complex-valued array with nonzero imaginary parts on the diagonal is given and hermitian is set to True. See Also -------- cholesky, lu Notes ----- This function uses ``?SYTRF`` routines for symmetric matrices and ``?HETRF`` routines for Hermitian matrices from LAPACK. See [1]_ for the algorithm details. Depending on the `lower` keyword value, only lower or upper triangular part of the input array is referenced. Moreover, this keyword also defines the structure of the outer factors of the factorization. .. versionadded:: 1.1.0 References ---------- .. [1] J.R. Bunch, L. Kaufman, Some stable methods for calculating inertia and solving symmetric linear systems, Math. Comput. Vol.31, 1977. :doi:`10.2307/2005787` Examples -------- Given an upper triangular array ``a`` that represents the full symmetric array with its entries, obtain ``l``, 'd' and the permutation vector `perm`: >>> import numpy as np >>> from scipy.linalg import ldl >>> a = np.array([[2, -1, 3], [0, 2, 0], [0, 0, 1]]) >>> lu, d, perm = ldl(a, lower=0) # Use the upper part >>> lu array([[ 0. , 0. , 1. ], [ 0. , 1. , -0.5], [ 1. , 1. , 1.5]]) >>> d array([[-5. , 0. , 0. ], [ 0. , 1.5, 0. ], [ 0. , 0. , 2. ]]) >>> perm array([2, 1, 0]) >>> lu[perm, :] array([[ 1. , 1. , 1.5], [ 0. , 1. , -0.5], [ 0. , 0. , 1. ]]) >>> lu.dot(d).dot(lu.T) array([[ 2., -1., 3.], [-1., 2., 0.], [ 3., 0., 1.]]) ) check_finitez%The input array "a" should be square.dtypehetrf hetrf_lworkzscipy.linalg.ldl(): The imaginary parts of the diagonalare ignored. Use "hermitian=False" for factorization ofcomplex symmetric arrays.) stacklevelsytrf sytrf_lwork)lower)lworkr overwrite_azB exited with the internal error "illegal value in argument number z0". See LAPACK documentation for the error codes.)r hermitian)rrshape ValueErrorsizer nparrayintr complexfloatanyrrrrrrupper_ldl_sanitize_ipiv_ldl_get_d_and_l_ldl_construct_tri_factor)Arr rranr_or_csslsolver solver_lworkrldupivinfoswap_arr pivot_arrdluperms&&&&& V/var/www/html/photoedit/myenv/lib/python3.14/site-packages/scipy/linalg/_decomp_ldl.pyrrsr\ %aCDAwwqzQWWQZ@AAvv{!}jmRXXb-DDD  A$QWUFY2 66$tAw- -.< L2+QGaT:F <% 8EA%(35NCd axAGGI;'/04ug6001 1-S>Hi S)5 NEAr(XyNHB q$;cVPp\V4p\V\R7pRpV'd^^^V^3M RRV^, RR3wrgrp \ WV 4Fp V'dRpKW ,p V ^8d%W^,8wdW<^, ,W;&^WK&KBV ^8dKWW,,8Xd8V )V ^,8wdW<)^, ,W;V,&^WKV,&RpK\ R4h W43#)a This helper function takes the rather strangely encoded permutation array returned by the LAPACK routines ?(HE/SY)TRF and converts it into regularized permutation and diagonal pivot size format. Since FORTRAN uses 1-indexing and LAPACK uses different start points for upper and lower formats there are certain offsets in the indices used below. Let's assume a result where the matrix is 6x6 and there are two 2x2 and two 1x1 blocks reported by the routine. To ease the coding efforts, we still populate a 6-sized array and fill zeros as the following :: pivots = [2, 0, 2, 0, 1, 1] This denotes a diagonal matrix of the form :: [x x ] [x x ] [ x x ] [ x x ] [ x ] [ x] In other words, we write 2 when the 2x2 block is first encountered and automatically write 0 to the next entry and skip the next spin of the loop. Thus, a separate counter or array appends to keep track of block sizes are avoided. If needed, zeros can be filtered out later without losing the block structure. Parameters ---------- a : ndarray The permutation array ipiv returned by LAPACK lower : bool, optional The switch to select whether upper or lower triangle is chosen in the LAPACK call. Returns ------- swap_ : ndarray The array that defines the row/column swap operations. For example, if row two is swapped with row four, the result is [0, 3, 2, 3]. pivots : ndarray The array that defines the block diagonal structure as given above. rFTznWhile parsing the permutation array in "scipy.linalg.ldl", invalid entries found. The array syntax is invalid.)r#rrr&ranger") r/rr0swap_pivotsskip_2x2xyrsreriindcur_vals && r>r+r+s` A 1IE S )FH+01aAb"ac2r5JA""RR  H & Q;a%"19- FK q[W#%0x3q5 $XaZ0!e Fq5MHCD D-!2 =r?c\V4p\\V44pVP^,p^pV'dRMRwrV'd \VR4M \ V^4p \ V4p ^WV 3&W^8g,Fp W|,p V ^8XdWV,Wy,3,WWV,Wy,3&V'd@V'd8WV,Wy,3,P 4WWV ,Wx,3&M(WV,Wy,3,WWV ,Wx,3&RWV,Wy,3&T pK WZ3#)aI Helper function to extract the diagonal and triangular matrices for LDL.T factorization. Parameters ---------- ldu : ndarray The compact output returned by the LAPACK routing pivs : ndarray The sanitized array of {0, 1, 2} denoting the sizes of the pivots. For every 2 there is a succeeding 0. lower : bool, optional If set to False, upper triangular part is considered. hermitian : bool, optional If set to False a symmetric complex array is assumed. Returns ------- d : ndarray The block diagonal matrix. lu : ndarray The upper/lower triangular matrix g)r)rrNrA)r rr!r r rconj)r6pivsrr is_cr;r0blk_irFrGr< diag_indsblkincs&&&& r>r,r,s0  D T#YA  A E6DAc2T#q\Bq I B)AIk !8"%Aguw&6"7AAguw  &)'57*:&;&@&@&B'57"#&)'57*:&;'57"##%BQw " 5Lr?cVP^,p\V4pV'd V^, RR3M^V^3wrgp\WgV4Fp W,p W8wgKV'dT M^p V'dTMV ^,p W),V'd^M^8Xd%Y'dRM^, p Y'd^M^, p W V .W13,W V .W13&WYV .,WZV .&K V\V43#)a! Helper function to construct explicit outer factors of LDL factorization. If lower is True the permuted factors are multiplied as L(1)*L(2)*...*L(k). Otherwise, the permuted factors are multiplied as L(k)*...*L(2)*L(1). See LAPACK documentation for more details. Parameters ---------- lu : ndarray The triangular array that is extracted from LAPACK routine call with ones on the diagonals. swap_vec : ndarray The array that defines the row swapping indices. If the kth entry is m then rows k,m are swapped. Notice that the mth entry is not necessarily k to avoid undoing the swapping. pivs : ndarray The array that defines the block diagonal structure returned by _ldl_sanitize_ipiv(). lower : bool, optional The boolean to switch between lower and upper triangular structure. Returns ------- lu : ndarray The square outer factor which satisfies the L * D * L.T = A perm : ndarray The permutation vector that brings the lu to the triangular form Notes ----- Note that the original argument "lu" is overwritten. rA)r!rrBr ) r<swap_vecrPrr0r=rHrIrJrKs_indcol_scol_es &&&& r>r-r-.sF  A !9D"'!A#r2aAYJBBRR   < CaEACEEy%QQ/u!+e*,.U|U[/H,IBs|U[( )!%El!3D ! wt} r?)r.)TTFT)T)TT)warningsrnumpyr$rrrrrr r r r r numpy.exceptionsrscipy._lib._utilr_decomprlapackrr__all__rr+r,r-r?r>rds^BBB+.'4 '8NNbRj5p6r?