CdWddlmZddlZddlZddlmZddlmZddlZ ddl Z ddl m Z mZmZmZddlmZddlmZmZddlmZmZmZmZdd lmZmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&dZ'dZ(dZ)dZ*d*dZ+d+dZ,d,dZ- d-dZ. d.dZ/dZ0d/dZ1dZ2dZ3d0d Z4d1d"Z5d#Z6d$Z7d0d%Z8d&Z9d'Z:d(Z;e&e j<d2d)Z=dS)3) annotationsN)partial)Number)Array concatenatedotmany from_delayed)eye) RandomState default_rng) array_safemeta_from_arraysolve_triangular_safesvd_flip)tokenizewait) blockwise)delayed)HighLevelGraph)apply derived_fromc#2Kd}|D]}|}||z }||fVdS)Nr)ittotalxtotal_previouss 1lib/python3.11/site-packages/dask/array/linalg.py_cumsum_blocksrsF E &&  u%%%%%&&c(|d|d|zfSNr)lastnews r _cumsum_partr&#s GT!Ws] ##r ct||g}tj|r|n|}tj|r|n|SN)minnpisnan)mnk_0k_1s r_nanminr0's> q!f++Cx{{ !!!C(3-- (33S(r c|jddkr9tj|dtj|d|jdffStj|S)z A wrapper for np.linalg.qr that handles arrays with 0 rows Notes: Created for tsqr so as to manage cases with uncertain array dimensions. In particular, the case where arrays have (uncertain) chunks with 0 rows. r)rrshaper#)r3r* zeros_likelinalgqras r _wrapped_qrr9-sY wqzQ}Qf---r}Qq!'RS*o/V/V/VVVy||Ar Fc $]^_`abcdefghtjdtjd}}tjdjdd}}jdkr|dks-t djjdt|z}j\}]|df} tj tj dj \} } j} j} d|zet%t&ed jd j| i }|| e<t+| e<d |zd zbbefd t/| dD}|| b<eh| b<d |zdzfeffdt/| dD}|| f<eh| f<||z}t1djD }tj||z }||n|d|zk}|ot5|dk}|r|r|r|g}g}d}t7jdD]W\}}|}t9||}|}||z|kr||g}d}|||f||z }Xt|dkr||d|zdzgfgfdt7|D}|| g<fh| g<t=d|D}t?| | } tAttC|]f| j }!tE| gtC|]f|]f|!}"tG|"|\h}#tIj%hj&j|#j&j} tIj%hj&j|#j&j} d |zdzc]chfdt7|D}$|$| c<t+h| c<d|z}%|%ddf|#jddfi}&|&| |%<t+|#| |%<d|zdz}'t%tj'|'d bd cd b| c| i }(|(| |'<bch| |'<nňffdt/| dD})d|zdz}*|*ddftj(t<|)ffi}+|+| |*<fh| |*<d|zdz},t%tj j |,d |*d |*di }-|-| |,<|*h| |,<d |zdzddddftRj*|,ddfdfi}.|.| d<|,h| d<t1d jD }/|/rE]fd!jdD}0]fd"tW|0D}1i}2t+}3nd#|zdz``fd$t/| dD}4d |zd%z__tRj*tXjddfd#fdfi}5d&|zdzaadfd`dfgi}6t/d| dD]}7tZa|7dz f`|7ff|6a|7f<d'|zd(z^^_afd)t/| dD}8tIj%|5|4|6|8}2jh}3^fd*t/| dD}1|2| d+|z<|3| d+|z<d |zdzccdfd,t7|1D}$|$| c<|/rdh| c<n dd+|zh| c<d|zdz}'t%tj'|'d bd cd b| c| i }(|(| |'<bch| |'<d |zd-z}%|%ddftRj*|,ddfdfi}&|&| |%<|,h| |%<|stj.jdp#t1d.jdD}9tj.jdp#t1d/jdD}:|9rW|:rUj};jdtj/ff}n|9r"|:s j};jd]ff}<]]f}=]]f}>n|9sV|:rTj};jdtj/ff}njdjdkrjnjdjdf};jdjdkrjnjdjdf}<jdjdkr]]fnj}=|=}>t?| | } tAt|;| j }?tAt|=| j }@tE| |'|;|<|?}AtE| |%|=|>|@}B|A|BfSd0|zd1z}Ct%tj j0|Cd |%d |%di }Dd |zd2z}E|EddftRj*|Cddfdfi}Fd |zd3z}G|GdftRj*|Cddfdfi}Hd |zd4z}I|IddftRj*|Cddfdfi}Jd |zd5z}Kt%tb|Kd |'d6|Ed7|'| |Edi }L|D| |C<|%h| |C<|F| |E<|Ch| |E<|L| |K<|'|Eh| |K<|H| |G<|Ch| |G<|J| |I<|Ch| |I<tj 0tj dj \}M}N}Ote|]}P|}Qtj.|Pst5|Pn|P}R|R}S|R}T]}Ut|T|U}Vt?| | } tAt|Q|Rf|Mj }WtAt|Sf|Nj }XtAt|V|Vf|Oj }YtE| |K|Q|Rfjd|Rff|W}ZtE| |G|Sf|Sff|X}[tE| |I|V|Vf]f]ff|Y}\|Z|[|\fS)8aDirect Tall-and-Skinny QR algorithm As presented in: A. Benson, D. Gleich, and J. Demmel. Direct QR factorizations for tall-and-skinny matrices in MapReduce architectures. IEEE International Conference on Big Data, 2013. https://arxiv.org/abs/1301.1071 This algorithm is used to compute both the QR decomposition and the Singular Value Decomposition. It requires that the input array have a single column of blocks, each of which fit in memory. Parameters ---------- data: Array compute_svd: bool Whether to compute the SVD rather than the QR decomposition _max_vchunk_size: Integer Used internally in recursion to set the maximum row dimension of chunks in subsequent recursive calls. Notes ----- With ``k`` blocks of size ``(m, n)``, this algorithm has memory use that scales as ``k * n * n``. The implementation here is the recursive variant due to the ultimate need for one "single core" QR decomposition. In the non-recursive version of the algorithm, given ``k`` blocks, after ``k`` ``m * n`` QR decompositions, there will be a "single core" QR decomposition that will have to work with a ``(k * n, n)`` matrix. Here, recursion is applied as necessary to ensure that ``k * n`` is not larger than ``m`` (if ``m / n >= 2``). In particular, this is done to ensure that single core computations do not have to work on blocks larger than ``(m, n)``. Where blocks are irregular, the above logic is applied with the "height" of the "tallest" block used in place of ``m``. Consider use of the ``rechunk`` method to control this behavior. Taller blocks will reduce overall memory use (assuming that many of them still fit in memory at once). See Also -------- dask.array.linalg.qr Powered by this algorithm dask.array.linalg.svd Powered by this algorithm dask.array.linalg.sfqr Variant for short-and-fat arrays rr#aInput must have the following properties: 1. Have two dimensions 2. Have only one column of blocks Note: This function (tsqr) supports QR decomposition in the case of tall-and-skinny matrices (single column chunk/block; see qr) Current shape: {}, Current chunksize: {}-r#r#r3dtyper6ij) numblocksgetitemz-q1c<i|]}|dftj|dfdfSroperatorrB).0i name_q_st1 name_qr_st1s r ztsqr..C  QX- Q/BAFr z-r1c<i|]}|dftj|dfdfSrr#rE)rGrHrJ name_r_st1s rrKztsqr..rLr c3HK|]}|D]}tj|VdSr(r*r+rGcscs r ztsqr..s7!P!P"R!P!P"(1++!P!P!P!P!P!P!Pr Nstackc`i|]*\}}|dftjtfd|Dff+S)rc g|] \}}|df SrDr)rGidx_rOs r z#tsqr...s$KKK&#q*c1-KKKr )r*vstacktuple)rGrHsub_block_inforOname_r_stackeds rrKztsqr..s]   "> Q " KKKKNKKKL%   r c3RK|]"}ttd|V#dS)c|dSr"rrs rz tsqr...s adr N)summap)rGr^s rrUztsqr..sG! ! 9GCNNN33 4 4! ! ! ! ! ! r r?r3chunksmeta)_max_vchunk_sizez-q2c i|]\}}td|Dtd|DD]J\}}|dftjj|dft |d|dt dffKS)cg|] }|d SrDrrGrs rr[z#tsqr...s...!1...r cg|] }|d S)r#rrms rr[z#tsqr...s===!===r rr#)ziprrFrBnameslice)rGrHr^jer- name_q_st2q_inners rrKztsqr..s    ">..~...==n===>>   1 A  q!$!ad##uQ{{4!     r zr-innerdotz-q3cg|]}|dfSrDr)rGrHrOs rr[ztsqr..s DDD1ZA&DDDr z-qr2z-q2-auxc3HK|]}|D]}tj|VdSr(rQrRs rrUztsqr..4s8&U&UrRT&U&UQrx{{&U&U&U&U&U&U&Ur c0g|]}t|Sr)r)rGrsr-s rr[ztsqr..8s!@@@Ac!Qii@@@r chg|].}t|d|dtdf/SrN)rqrzs rr[ztsqr..9sE56qtQqT""E!QKK0r r3cHi|]}|fttj|dfdffS)rr3)r)getattrrp)rGrHdata name_q2bss rrKztsqr..CsDAwAq0A7&K Lr z-ncumsumrqz-qcZi|]'}|fttt|fftdfgf(SrD)r]rrq)rGrHname_blockslicename_n name_q2css rrKztsqr..YsR     !!$UYN3eQ5GH'   r cg|]}|fSrr)rGrHrs rr[ztsqr..fsNNNQ_a0NNNr z q-blocksizescBi|]\}}|dftjddf|fSrDrE)rGrHbrtname_q_st2_auxs rrKztsqr..msG   1A !1NAq3I1 M   r z-r2c3>K|]}tj|VdSr(rQrGrTs rrUztsqr..;6 6 BHQKK6 6 6 6 6 6 r c3>K|]}tj|VdSr(rQrs rrUztsqr..rr svdz-2z-u2z-s2z-v2z-u4ikkj)3lenrhmaxndim ValueErrorformatr3 chunksizerr*r5r6onesr?__dask_graph__layerscopy dependenciesrr9rpset__dask_layers__rangeanyceilint enumerater)appendr]rrrdrtsqrtoolzmergedaskrvr\rFrBrr}r&r+nanrrr0)ir~ compute_svdrjnrnccr_maxcctokenr,rAqqrrrr dsk_qr_st1 dsk_q_st1 dsk_r_st1single_core_compute_mchunks_well_definedprospective_blocksmeaningful_reduction_possiblecan_distribute all_blocks curr_block curr_block_szrYa_mm_qn_qm_r dsk_r_stackedvchunks_rstackedgraphr_stacked_meta r_stackedr_inner dsk_q_st2 name_r_st2 dsk_r_st2 name_q_st3 dsk_q_st3to_stackname_r_st1_stackeddsk_r_st1_stacked name_qr_st2 dsk_qr_st2 dsk_q_st2_auxchucks_are_all_knownq2_block_sizes block_slicesdsk_q_blockslicesdeps dsk_q2_shapesdsk_n dsk_q2_cumsumrHdsk_block_slices is_unknown_m is_unknown_nq_shapeq_chunksr_shaper_chunksq_metar_metaqr name_svd_st2 dsk_svd_st2 name_u_st2 dsk_u_st2 name_s_st2 dsk_s_st2 name_v_st2 dsk_v_st2 name_u_st4 dsk_u_st4uussvvhkm_un_un_sm_vhn_vhd_vhu_metas_metavh_metausvhr-rrrrrIrtrrJrOr_rusi` @@@@@@@@@@@@rrr<s%pQ #dk!n"5"5BT[^$$dk!nQ&7BF INNrQww 8 9? DN99    (4-- -E :DAqQI Y\\"'djAAA B BFB  " " ) . . 0 0F&&((5::<WXX &.        &/z%:%:    'z#&w'>'>'@'@#A#A Z &  !Q'',1)=> &z#&w'>'>'@'@#A#A Z U]U*  F      !9j)D    'z$. #; Z  EDDDil0C0CDDD$u_u40!Q7")eXEV9WX%6!",6< '(UlV+  IL    )62    ){%7$8 [!#U*Y6 Q "X%5 Q7JA$N "/~(3} ^$#&&U&UT[&U&U&U#U#UU 1 OA@@@Q@@@N:H:X:XL!# 55DD  %%/Iy|,,M&-F)GdiA5F+PRSTE !5(50I'^a)Q-@AM1il++   A&N1 y!n--&o4O       y|,,     !& }m5E!! I;DNNNN% ! :M:MNNNL):~%&/3 ^e+,&.      !,//   'z  P(6'7L $ $(68N'OL $U]U*  F      !9j)D    'z$. #; Z &.  !Q'(*:[!Q >q!ffDJGHv|44 s7||RX>> s7||RX>> %78& Q Q Q %78& Q Q Q!t u}t+  IM    !6*    &.  !Q'(*:\1a Z &z$. #; Z &z$0> Z &z$0> Z immBG& $K$K$KLL B AqMMHQKK.c!fffQ4v|44 sC:AA sC6{{BH==!$T4L(9(939EE   *KNSF+     %C6C6)& Q Q Q  :dD\A4!,W   !Rxr c tjdtjd}}jddjdd}}jdkr|dkr ||ks|dkstd|pdt z}|dz }j\}}t jt j dj \} } j } j } |d z} |d z| ddfjddfi| | <t!| | <fd t%|dz D| <t| dkr%t!| <nt!| <|d z}|d z}|dz}|ddft jj| ddffi| |<| h| |<|ddft&j|ddfdfi| |<|h| |<|ddft&j|ddfdfi| |<|h| |<t+| | }t-t|t/||f| j }t-tt/|||f| j }t1|||t/||f|t/||f|}t1||t/|||f||f|}|g}|dkrt-tt/||||z f| j }t1|t/||||z f|jdddf|}||j|t9|d}||fS)a/Direct Short-and-Fat QR Currently, this is a quick hack for non-tall-and-skinny matrices which are one chunk tall and (unless they are one chunk wide) have chunks that are wider than they are tall Q [R_1 R_2 ...] = [A_1 A_2 ...] it computes the factorization Q R_1 = A_1, then computes the other R_k's in parallel. Parameters ---------- data: Array See Also -------- dask.array.linalg.qr Main user API that uses this function dask.array.linalg.tsqr Variant for tall-and-skinny case rr#r;aInput must have the following properties: 1. Have two dimensions 2. Have only one row of blocks 3. Either one column of blocks or (first) chunk size on cols is at most that on rows (e.g.: for a 5x20 matrix, chunks=((5), (8,4,8)) is fine, but chunks=((5), (4,8,8)) is not; still, prefer something simple like chunks=(5,10) or chunks=5) Note: This function (sfqr) supports QR decomposition in the case of short-and-fat matrices (single row chunk/block; see qr)zsfqr-rZr=r>A_1A_restc2i|]}d|fjdd|zfSrN)rp)rGrYr~ name_A_rests rrKzsfqr..As<;>a 1a#g6r Q_R_1QR_1rfrgNaxis)rrhrrrr3r*r5r6rr?rrrrrprrrrFrBrrr)rrTrvr)r~rprrcrrprefixr,r-rrrrname_A_1 name_Q_R1name_Qname_R_1rQ_metaR_1_metarrRs A_rest_metarRrs` @rsfqrrs*.Q #dk!n"5"5B [^A  Aq 1B a 1WW 2XXa I    -Wx~~-F cMF :DAq Y\\"'djAAA B BFB  " " ) . . 0 0F&&((5::<(>$?$? [!!$'EE [! I c\F~H#Q*RY\Ha;K,LMF9'jLq!nx'7)Q9JA&NOF6N%;L!1a(8+;iA=NPQ*RSF8'[L 6< 0 0E T33q!99~#6#6bh G G GFtS#a))R%9%9JJJH eVAs1ayy>1c!Qii.vVVVA xAq 2Bxh W W WC B Avv%dCQAF0C,D,DBHUUU   q!99a"f% Aqrr*+     !#''&//"""BQA a4Kr cDtt|||z|S)aCompression level to use in svd_compressed Given the size ``n`` of a space, compress that that to one of size ``q`` plus n_oversamples. The oversampling allows for greater flexibility in finding an appropriate subspace, a low value is often enough (10 is already a very conservative choice, it can be further reduced). ``q + oversampling`` should not be larger than ``n``. In this specific implementation, ``q + n_oversamples`` is at least ``min_subspace_size``. Parameters ---------- n: int Column/row dimension of original matrix q: int Size of the desired subspace (the actual size will be bigger, because of oversampling, see ``da.linalg.compression_level``) n_oversamples: int, default=10 Number of oversamples used for generating the sampling matrix. min_subspace_size : int, default=20 Minimum subspace size. Examples -------- >>> compression_level(100, 10) 20 )r)r)r-r n_oversamplesmin_subspace_sizes rcompression_levelrps$< s$a-&788! < <>> u, s, v = svd_compressed(x, 20) # doctest: +SKIP Returns ------- u: Array, unitary / orthogonal s: Array, singular values in decreasing order (largest first) v: Array, unitary / orthogonal References ---------- N. Halko, P. G. Martinsson, and J. A. Tropp. Finding structure with randomness: Probabilistic algorithms for constructing approximate matrix decompositions. SIAM Rev., Survey and Review section, Vol. 53, num. 2, pp. 217-288, June 2011 https://arxiv.org/abs/0909.4061 )r&r'rr(r)TrN)r0r%rrvrrr) r8rr&r'rr(r) coerce_signscomp a_compressedvrrs rsvd_compressedr7sB   !#    D||~~ T 88A;;L<>t444GAq!  13A A !!!RaR%A "1"A "1"aaa%A1~~1 a7Nr ct|jddkr-t|jddkrt|St|jddkrt|St d)a Compute the qr factorization of a matrix. Parameters ---------- a : Array Returns ------- q: Array, orthonormal r: Array, upper-triangular Examples -------- >>> q, r = da.linalg.qr(x) # doctest: +SKIP See Also -------- numpy.linalg.qr: Equivalent NumPy Operation dask.array.linalg.tsqr: Implementation for tall-and-skinny arrays dask.array.linalg.sfqr: Implementation for short-and-fat arrays r#ra}qr currently supports only tall-and-skinny (single column chunk/block; see tsqr) and short-and-fat (single row chunk/block; see sfqr) matrices Consider use of the rechunk method. For example, x.rechunk({0: -1, 1: 'auto'}) or x.rechunk({0: 'auto', 1: -1}) which rechunk one shorter axis to a single chunk, while allowing the other axis to automatically grow/shrink appropriately.)rrhrrNotImplementedErrorr7s rr6r6Es|0 18A;1QXa[!1!1A!5!5Aww QXa[  Q  Aww! I   r c|j}|jdkr-td|j|j|ddkr4|ddkr(t d|j||d|dcxkrdkrnn|j\}}t |j}tj tj |j d|j j \}}}ttjj d |d \} } } t| ||f| } t| |f| } t| ||f| } n|d|dkr2t|d \} } } |jd|jdk} nFt|jd \} } }|j| | j} } } |jd|jdk} | r0t |j}| ddd|f| d|ddf} } |rt#| | \} } | | | fS)aZ Compute the singular value decomposition of a matrix. Parameters ---------- a : (M, N) Array coerce_signs : bool Whether or not to apply sign coercion to singular vectors in order to maintain deterministic results, by default True. Examples -------- >>> u, s, v = da.linalg.svd(x) # doctest: +SKIP Returns ------- u : (M, K) Array, unitary / orthogonal Left-singular vectors of `a` (in columns) with shape (M, K) where K = min(M, N). s : (K,) Array, singular values in decreasing order (largest first) Singular values of `a`. v : (K, N) Array, unitary / orthogonal Right-singular vectors of `a` (in rows) with shape (K, N) where K = min(M, N). Warnings -------- SVD is only supported for arrays with chunking in one dimension. This requires that all inputs either contain a single column of chunks (tall-and-skinny) or a single row of chunks (short-and-fat). For arrays with chunking in both dimensions, see da.linalg.svd_compressed. See Also -------- np.linalg.svd : Equivalent NumPy Operation da.linalg.svd_compressed : Randomized SVD for fully chunked arrays dask.array.linalg.tsqr : QR factorization for tall-and-skinny arrays dask.array.utils.svd_flip : Sign normalization for singular vectors r;z1Array must be 2D. Input shape: {} Input ndim: {} rr#zArray must be chunked in one dimension only. This function (svd) only supports tall-and-skinny or short-and-fat matrices (see da.linalg.svd_compressed for SVD on fully chunked arrays). Input shape: {} Input numblocks: {} r=r>)noutF) full_matrices)r3riTr2N)rArrrr3r9r)r*r5r ones_like_metar?rr rrr)r8r3nbr,r-rmumsmvrrr6truncatevtuts rrrls^X Bv{{ %vagqv66    !uqyyRUQYY! $%+F17B$7$7     !u1w1 LLY]] Lagm D D D  B1'")-a000%HHH1a 1a&r 2 2 2 1$R 0 0 0 1a&r 2 2 2 a52a5==1$///GAq!wqzAGAJ.HHQSd333IB2dArt!qAwqzAGAJ.H  &AG AQQQU8Qrr111uXqA1~~1 a7Nr c&t||dS)NTlower)r)r8rs r_solve_triangular_lowerrJs AT 2 2 22r c ddl}|jdkrtd|j\}}||krtdt t |jd|jdzdksd}t|t |jd}t |jd}t|}d|z}d |z} d |z} d |z} d |z} d |z} d|z}d|z}d|z}i}tt||D]}|j ||f}|dkr^g}t|D]6}|||||f}tj | ||f| ||ff||<| |7tj|t |ff}|jj|f||||f<t|dz|D]}tj | ||f|j ||ff}|dkr^g}t|D]6}|||||f}tj | ||f| ||ff||<| |7tj|t |ff}t&| ||f|f||||f<t|dz|D]}|j ||f}|dkr^g}t|D]6}|||||f}tj | ||f| ||ff||<| |7tj|t |ff}tjt&|||ftj|fff||||f<tt||D]}tt||D]}||krtj|||fdf|| ||f<tj|||fdf|| ||f<tj|||fdf|| ||f<tj | ||f| ||ff|| ||f<tj| ||ff||||f<tj| ||ff|| ||f<||krtj|jd||jd|ff|| ||f<tj | ||f|||ff|| ||f<tj|jd||jd|ff|| ||f<|||f|| ||f<9tj|jd||jd|ff|| ||f<tj|jd||jd|ff|| ||f<|||f|| ||f<|jtjd|j\}}}t3||j}t3||j}t3||j}t5j| ||g}t9|| |j|j|}t5j| ||g}t9|| |j|j|} t5j| ||g}t9|| |j|j|}!|| |!fS)a! Compute the lu decomposition of a matrix. Examples -------- >>> p, l, u = da.linalg.lu(x) # doctest: +SKIP Returns ------- p: Array, permutation matrix l: Array, lower triangular matrix with unit diagonal. u: Array, upper triangular matrix rNr;z/Dimension must be 2 to perform lu decompositionz9Input must be a square matrix to perform lu decompositionr#zqAll chunks must be a square matrix to perform lu decomposition. Use .rechunk method to change the size of chunks.zlu-lu-zlu-p-zlu-l-zlu-u-z lu-p-inv-z lu-l-permute-zlu-u-transpose-z lu-plu-dot-z lu-lu-dot-r=r>rfrrg) scipy.linalgrrr3rrrhrrr)rpr*rvrrFsubrdr5lurJ transposerBzerosrr?rrfrom_collectionsr)"r8scipyxdimydimmsgvdimhdimrname_luname_pname_lname_u name_p_invname_l_permutedname_u_transposed name_plu_dot name_lu_dotdskrHtargetprevspprevrrrppllrpp_metall_metauu_metarlrs" rrOrOs v{{JKKKJD$ t||TUUU s18A;!,-- . .! 3 3 @ oo qx{  D qx{  D QKKEG u_F u_F u_Fu$J%-O)E1 5(L&K C 3tT?? # #**&!Q q55E1XX # ##Q1a/Voq!%6!RCA  q1ud##  Afa^F1uuq''A'Aq!3D!#/1a)@61a. QCILL&&&&",e = +&1-\6*"CA   &3tT?? # #44s4'' 4 4AAvv%-%5A$JFAqL!%-%5A$JFAqL!%-%5A$JFAqL!/1fvq!nvqRSn-UOQ)*02 vq!n/M%q!+,)+1~(FJ1$%%Q%'X A A/O$PFAqL!&(Vj!Q-?'1a$QFAqL!%'X A A/O$PFAqL!.5q!_OQ)**%'X A A/O$PFAqL!%'X A A/O$PFAqL!%,aOFAqL!!- 42vQW!E!E!EFFJBBarx000Garx000Garx000G  +FCqc J J JE eV1718'JJJA  +FCqc J J JE eV1718'JJJA  +FCqc J J JE eV1718'JJJA a7Nr c h|jdkrtdjdkrY|jdjdkrtd|jdjdkrd}t|ntdt |jd}jdkrdnt jd}t ||}d|zd |z}fd }fd } i} |rt |D]} t |D]} || | } | dkrjg}t | D]B}|| ||| f}tj|j | |f| || f| |<| |Ctj | t|ff} t|j | | f| f| | | | <nt |D]} t |D]} || | } | |dz krng}t | dz|D]B}|| ||| f}tj|j | |f| || f| |<| |Ctj | t|ff} t|j | | f| f| | | | <t!j| |g }t%|}t%}tt'ddgddgg|j| t'ddgj| }t%|j|j}t+|jj|S)a Solve the equation `a x = b` for `x`, assuming a is a triangular matrix. Parameters ---------- a : (M, M) array_like A triangular matrix b : (M,) or (M, N) array_like Right-hand side matrix in `a x = b` lower : bool, optional Use only data contained in the lower triangle of `a`. Default is to use upper triangle. Returns ------- x : (M,) or (M, N) array Solution to the system `a x = b`. Shape of return matches `b`. r;za must be 2 dimensionalr#rz'a.shape[1] and b.shape[0] must be equalz\a.chunks[1] and b.chunks[0] must be equal. Use .rechunk method to change the size of chunks.zb must be 1 or 2 dimensionalzsolve-triangular-zsolve-tri-dot-c@jdkr j|fSj||fSr")rrp)rHrrrs r_b_initz!solve_triangular.._b_inits( 6Q;;619 61a< r c,jdkr|fS||fSr")r)rHrrrrps r_keyzsolve_triangular.._keys# 6Q;;7NA: r rLr?likerfrg)rrr3rhrrrr*rvrprrFrNrdrJrrrRrr r?r)r8rrIrVvchunkshchunksr name_mdotrorqrbrHrrrcrdrrfra_metab_metaresrirps ` @rsolve_triangularrzUs( v{{2333v{{ 71: # #FGG G 8A;!(1+ % %D S// ! &7888!(1+G6Q;;aaC $4$4G Q5 ! !E  &D!5(I      C w T TA7^^ T T Aq55E"1XX++(!Q14%'Vafa^TT!QZZ$HD  T****&lFS%LAF#:QVQNF"SDDAJJ T Tw  A7^^   Aw{??E"1q5'22++(!Q14%'Vafa^TT!QZZ$HD  T****&lFS%LAF)VQN#DDAJJ   +D#QF K K KE Q  F Q  F !QFQF#17@@@Aq6v666  C 1afCI 6 6 6D AGAH4 H H HHr gencH|tjdt|rd}|dkrt|\}}nG|dkr.t |\}}}|j|}ntd|dt||d }t||S) a^ Solve the equation ``a x = b`` for ``x``. By default, use LU decomposition and forward / backward substitutions. When ``assume_a = "pos"`` use Cholesky decomposition. Parameters ---------- a : (M, M) array_like A square matrix. b : (M,) or (M, N) array_like Right-hand side matrix in ``a x = b``. sym_pos : bool, optional Assume a is symmetric and positive definite. If ``True``, use Cholesky decomposition. .. note:: ``sym_pos`` is deprecated and will be removed in a future version. Use ``assume_a = 'pos'`` instead. assume_a : {'gen', 'pos'}, optional Type of data matrix. It is used to choose the dedicated solver. Note that Dask does not support 'her' and 'sym' types. .. versionchanged:: 2022.8.0 ``assume_a = 'pos'`` was previously defined as ``sym_pos = True``. Returns ------- x : (M,) or (M, N) Array Solution to the system ``a x = b``. Shape of the return matches the shape of `b`. See Also -------- scipy.linalg.solve NzThe sym_pos keyword is deprecated and should be replaced by using ``assume_a = 'pos'``.``sym_pos`` will be removed in a future version.)categoryposr{z assume_a = zT is not a recognized matrix structure, valid structures in Dask are 'pos' and 'gen'.TrH) warningswarn FutureWarning _choleskyrOrrvrrz)r8rsym_posassume_arlrreuys rsolversJ  ?"     H5||11 U  Q%%1a CGGAJJ px p p p    !Qd + + +B Ar " ""r cxt|t|jd|jddS)a Compute the inverse of a matrix with LU decomposition and forward / backward substitutions. Parameters ---------- a : array_like Square matrix to be inverted. Returns ------- ainv : Array Inverse of the matrix `a`. r)rh)rr r3rhr7s rinvrs1 C 18A;q>::: ; ;;r c@tj|Sr()r*r5choleskyr7s r_cholesky_lowerrs 9  a  r c2t|\}}|r|S|S)a 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. Default is upper-triangular. Returns ------- c : (M, M) Array Upper- or lower-triangular Cholesky factor of `a`. )r)r8rIrlrs rrrs%& Q<D  +E4qc J J JE R# > > >D  %E B   Wry)BFRWaOafaQR^+TU V  D  +E4r1g N N NE 9a ( (D eU171:- NNNA iq  r cv |"tt|j}n5t|trt |f}nt|}t |dkrtd|dkr$d}t |dkrtd|tj |j t}|,t|dz||dz}n3|dkrmt |dkrtd|jdkrtd t!|dd| }n|tjkrt|}t |dkr|||}nu||dd |d d }|d ur||}n!|tj krt|}t |dkr|||}n||dd |d d }|d ur||}n|d krWt |dkrtd|d k|j ||}n$|dkrt|}t |dkr|||}n||d d |dd }|d ur||}nt |dkrg|dkrat||d d |dd }|d ur||}nt |dkrP|dkrJ|jdkrtd t!|dd| }nt |dkrP|dkrJ|jdkrtd t!|dd| }nOt |dkrtdt||z||d|z z}|S)Nr;z&Improper number of dimensions to norm.fror#zInvalid norm order for vectors.rg?nucz+SVD based norm not implemented for ndim > 2)rTrFrz Invalid norm order for matrices.rg?)r]rrrrrrrr$r* promote_typesr?floatrrdr9rinfrsqueezer))rordrrrs rnormrs |U16]]## D& ! !D |T{{ 4yy1}}ABBB e|| t99>>>?? ? !!'51122A { VVq[  4(  ; ;s B  t99>>>?? ? 6A::%&STT T FF1IdO    2 2  FF t99>>4(33AA47T2266DGd6SSA5  II4I((  FF t99>>4(33AA47T2266DGd6SSA5  II4I((  t99>>?@@ @ !VOOAG $ $ ( (dX ( F F  FF t99>>4(33AA47T2266DGd6SSA5  II4I(( TaC2II FFJJDGdJ 3 3 7 7T!Wt 7 T T u   t $$A TaC1HH 6A::%&STT T FF1IdO    2 2 TaC2II 6A::%&STT T FF1IdO    2 2 t99>>?@@ @ VVs]  TH  = =#) L Hr )FNr()rr)rrrNF)rrrNFT)T)F)Nr{)NNF)> __future__rrFr functoolsrnumbersrnumpyr*tlzrdask.array.corerrrr dask.array.creationr dask.array.randomr r dask.array.utilsr rrr dask.baserrdask.blockwiser dask.delayedrdask.highlevelgraphr dask.utilsrrrr&r0r9rrrr0r7r6rrJrOrzrrrrrrrr5rrr rrsR""""""EEEEEEEEEEEE######66666666 %$$$$$$$$$$$$$ ......********&&&$$$)))   EEEEPiiiiX====H XXXX| VVVVr$ $ $ NZZZZz333EEEP^I^I^I^IB9#9#9#9#x<<<$!!!4NNNbB!B!B!JbiK K K K K K r