VpfjddlmZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddl m Z mZmZmZmZddlmZddlm ZddlmZeeje jj Zeeje jj Zeeje jj Z d Z!d Z"d Z#d Z$dZ%dZ&eeej'Z(eeej)Z*eeeZ+edZ,dZ-d.dde,ddZ.d.dde,ddZ/dZ0d.dddddddZ1d.ddddddZ2d.dZ3dZ4d/d Z5d!Z6d"Z7d#Z8d$Z9d%Z:d&Z;d'Zd.dddddd-Z?dS)0)partialN) device_put)lax)scipy) tree_leavestree_maptree_structure tree_reducePartial)dtypes)safe_map precisionct|j|j}tj|stj|r|t|j|jz }|S)zVector dot-product guaranteed to have a real valued result despite possibly complex input. Thus neglects the real-imaginary cross-terms. The result is a real float. )_vdotrealjnp iscomplexobjimag)xyresults \/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/scipy/sparse/linalg.py_vdot_real_partr(sY  &a$C,Q//$ eAFAF###F -c btttt||SN)sumrrrrrs r_vdot_real_treer 8s$ [/1a88 9 9 : ::rc tttttjt jj||S)Nr) rrrrrvdotr PrecisionHIGHESTrs r _vdot_treer%<sN ['H -#/#/#/0116677 8 88rc t|}tjtt t ||Sr)rrsqrtrmapr)rxss r_normr*As11~~" #c/2r2233 4 44rcRtttj||Sr)rroperatormul)scalartrees r_mulr0Fs '(,// 6 66rcDttfd|S)Nc|z Sr)vr.s rz_div..Ks AJr)rr)r/r.s `r_divr6Js% '....// 6 66rc|Srr3rs r _identityr9Ss (rcDt|r|St|tjtjfrS|jdks|jd|jdkrtd|jtt|St|drut|drt|jdks|jd|jdkrtd|jttj|Std|)z;Normalize an argument for computing matrix-vector products.rz8linear operator must be a square matrix, but has shape: __matmul__shapez6linear operator must be either a function or ndarray: )callable isinstancenpndarrayjaxArrayndimr> ValueErrorr_dothasattrlenr,matmul TypeError)fs r_normalize_matvecrMXs' a[[F H!bj#),-- Fv{{agajAGAJ..  NQW N N P PP 4  q,Fq'Ps17||q00AGAJ!'!*4L4L  NQW N N P PP 8?A & && DDD F FFrgh㈵>)tolatolMct||}tjtj||ztj|fd}fd} t ||} | x} } tjt | t| | } || | | df}tj || |^}}|S)Ncn|\}}}}}tur|jnt||}|k|kzSr)r9rr ) value_rgammakrsrQatol2maxiters rcond_funz_cg_solve..cond_funssCAq%AI~~?1a+@+@B J1w; ''rc|\}}}}}|}|t||z }t|t||}t |t||} | } t| | } | |z } t| t| |} || | | |dzfSNr<)r astype_addr0_sub)rTrrVrWprXApalphax_r_z_gamma_beta_p_ArQdtypes rbody_funz_cg_solve..body_funxsAq%A 1B OAr**11%88 8E aeQ B aeR ! !B 2B R $ $ + +E 2 2F UNE b$ua.. ! !B r62q1u $$rr) r rmaximumsquarera result_typerr_r while_loop)rkbx0r[rOrPrQbsr\rmr0p0z0gamma0 initial_valuex_finalrUrZrls` ` ` @@r _cg_solver{ks q!" +cjoo*CJt,<,< = =%((((((( % % % % % % % Aqquu~~" AbEE/"r /;r?? +% 2r " " ) )% 0 0&r62q)-x=AA+'A .rc t||}tjtj||ztj|fd}fd} t ||} t jdgtjt|Rx} x} } || | | | | | | df }tj || |^}}|S)NcZ|^}}}}t||}|k|kz|dkzS)Nr)r )rTrrVrUrXrYrZr[s rr\z!_bicgstab_solve..cond_funs;KAq1a A  B J1w; '16 22rc|\ }}}}}}}}} t||} | |z |z|z } t|t| t|t||} | } | }| t||z }t|t||}t ||k}|}|}t||t||z }t t tj|t|t|| t|tt|| t||}t t tj||t|t||}tj|dk|dkzd| dz}tj| dkd|}|||||| | ||f S)Nrir<i) r%r`r0rar rrrwhere)rTrrVrhatrdomegarhorbqrXrho_betarjphatq_alpha_s exit_earlyshattomega_rerfk_rkrQrZs rrmz!_bicgstab_solve..body_funs-2*Aq$uc1a dA  D #:  %D adDDNN3344 5 5B 1R55D 4B JtR(( (F QVR  !!A A&&.J 1Q44D $A 1   1a 0 0 0F '#)Z00q$vt,,--q$tFD1143E3EFFGG  B '#)Z00T!T&!__-- / /B FaKFaK0#q1u = =B DAIR ( (B r4r2r 99rr<r) r rrnrora lax_internal_convert_element_typer _lattice_result_typerrrq)rkrrrsr[rOrPrQrtr\rmrurho0alpha0omega0ryrzrUrZs` ` ` @r_bicgstab_solvers q!" +cjoo*CJt,<,< = =%333333 :::::::. Aqquu~~"'=8  %{1~~ 68888$8&r2vvtRQ?-x=AA+'A .rcPttjt|Sr)r(rr>r)pytrees r_shapesrs SY F++ , ,,rF)rOrPr[rQcheck_symmetricc|ttj|}t||f\}}|+t dt |D} d| z}|t }t|}t|}t|t|kr/tdt|dt|t|t|kr/tdt|dt|t||||||} d} |r*tt| t |nd} tj||| | | } d}| |fS) Nc3$K|] }|jV dSrsize.0bis r z_isolve..s$002rw000000r ,x0 and b must have matching tree structure:  vs z.arrays in x0 and b must have matching shapes: )rsrOrPr[rQcLt|jjtj Sr) issubclassrltyperAcomplexfloatingr8s r real_valuedz_isolve..real_valueds!',(:;; ;;rF)solvetranspose_solve symmetric)rr zeros_likerrrr9rMr rFrrallr(rcustom_linear_solve) _isolve_solverkrrrsrOrPr[rQrr isolve_solverrrinfos r_isolversZ #.! $ $B aW  %!R _ 00Q000 0 0D4iGYA!!B>!,,,,  7 "   7 7#1!#4#4 7 7 8 88 R[[GAJJ  ) 2;; ) )#AJJ ) ) * **$1FFF,<<<"c#k;q>>22333!  , ! $ D.r)rOrPr[rQc <tt|||||||d S)a Use Conjugate Gradient iteration to solve ``Ax = b``. The numerics of JAX's ``cg`` should exact match SciPy's ``cg`` (up to numerical precision), but note that the interface is slightly different: you need to supply the linear operator ``A`` as a function instead of a sparse matrix or ``LinearOperator``. Derivatives of ``cg`` are implemented via implicit differentiation with another ``cg`` solve, rather than by differentiating *through* the solver. They will be accurate only if both solves converge. Parameters ---------- A: ndarray, function, or matmul-compatible object 2D array or function that calculates the linear map (matrix-vector product) ``Ax`` when called like ``A(x)`` or ``A @ x``. ``A`` must represent a hermitian, positive definite matrix, and must return array(s) with the same structure and shape as its argument. b : array or tree of arrays Right hand side of the linear system representing a single vector. Can be stored as an array or Python container of array(s) with any shape. Returns ------- x : array or tree of arrays The converged solution. Has the same structure as ``b``. info : None Placeholder for convergence information. In the future, JAX will report the number of iterations when convergence is not achieved, like SciPy. Other Parameters ---------------- x0 : array or tree of arrays Starting guess for the solution. Must have the same structure as ``b``. tol, atol : float, optional Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``. We do not implement SciPy's "legacy" behavior, so JAX's tolerance will differ from SciPy unless you explicitly pass ``atol`` to SciPy's ``cg``. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M : ndarray, function, or matmul-compatible object Preconditioner for A. The preconditioner should approximate the inverse of A. Effective preconditioning dramatically improves the rate of convergence, which implies that fewer iterations are needed to reach a given error tolerance. See also -------- scipy.sparse.linalg.cg jax.lax.custom_linear_solve T)rkrrrsrOrPr[rQr)rr{rkrrrsrOrPr[rQs rcgrs0j bc At = = ==rct|}tjt|\}}tj|}|t j|jj}| |j }||ktj |||tfd|}t j|d}||fS)a! Returns the L2-normalized vector (which can be a pytree) x, and optionally the computed norm. If the computed norm is less than the threshold `thresh`, which by default is the machine precision of x's dtype, it will be taken to be 0, and the normalized x to be the zero vector. Nc6tj|z dS)NrN)rr)r norm_castuse_norms rr5z!_safe_normalize..8sCIhI s$K$KrrN)r*r rrcanonicalize_dtyperfinforlepsr_rrrrr)rthreshnormrl weak_type normalized_xrrs @@r_safe_normalizer's q$0+a..A%  #E * *% ^ Ytz " " &F ==   $& F](0uiHH)KKKKKQOO, 8T3 ' '$ t rcZtd||}ttj|S)z Returns A.T.conj() @ v. cHtd||S)Nz ...n,...->n)_einsumconjXrs rr5z%_project_on_columns..Bs7=!&&((A66r)rr r,add)rkr4v_projs r_project_on_columnsr=s1 661  & X\6 * **rr;c2td}tj|jd|j}|}|tjdz }fd}fd} |d|||f\} }}} t j| || ||| f\} }}} ||fS)a Orthogonalize x against the columns of Q. The process is repeated up to `max_iterations` times, or fewer if the condition ||r|| < (1/sqrt(2)) ||x|| is met earlier (see below for the meaning of r and x). Parameters ---------- Q : array or tree of arrays A matrix of orthonormal columns. x : array or tree of arrays A vector. It will be replaced with a new vector q which is orthonormal to the columns of Q, such that x in span(col(Q), q). xnorm : float Norm of x. Returns ------- q : array or tree of arrays A unit vector, orthonormal to each column of Q, such that x in span(col(Q), q). r : array Stores the overlaps of x with each vector in Q. rrl@c |\}}}}t | t fd }t||}t| } fd}d}|d||f}t j|||\} } }}|dz|||fS)Nc$t|SrrG)rhs rr5zJ_iterative_classical_gram_schmidt..body_function..osDAJJrcJ|\}}}}tj||dz kSr^r logical_and)carryrXnot_donerUmax_iterationss r qnorm_condzL_iterative_classical_gram_schmidt..body_function..qnorm_condss-a1a _XqNQ,>'? @ @@rcn|\}}}}t|\}}|tjdz }|d||fS)NrF)rrr')rrXrUr qnorm_scaledqnorms rrzG_iterative_classical_gram_schmidt..body_function..qnormwsB#aA| ##haSXc]]*l< ((rTr<)rrrar`rrq) rrXrrVrQhrrinitrUrQrs @r body_functionz8_iterative_classical_gram_schmidt..body_functionls!Aq!\Aq!!A &&&& * *B Q A Q AAAAAA))) tQ %DN:udCCAq!\ E1a &&rcv|\}}}}t|\}}tj|dz k||kSr^)rrr)rrXrUrVrrnormrs r cond_functionz8_iterative_classical_gram_schmidt..cond_functionsC!Aq!\q!!HAu ?1 23U\5I J JJr)rrzerosr>rlr'rrq) rrxnormrQ0rVr xnorm_scaledrrrXrrUs ` ` r!_iterative_classical_gram_schmidtrGs@1~~a" i BH---!!#&,''''''*KKKKK (-Aq,(?@@!Q<~m] !Q 577*!Q1 A+rc\tjt|\}}tj|}t j|j}tfd|}|||}t|\}} t||| d\}} || z} t|| \} } tfd|| }| j dz | |} |j ddf | }| dk}|||fS) a Performs a single (the k'th) step of the Arnoldi process. Thus, adds a new orthonormalized Krylov vector A(M(V[:, k])) to V[:, k+1], and that vectors overlaps with the existing Krylov vectors to H[k, :]. The tolerance 'tol' sets the threshold at which an invariant subspace is declared to have been found, in which case in which case the new vector is taken to be the zero vector. c|dfS)N.r3)rrXs rr5z(_kth_arnoldi_iteration..s36rr;)r)rcN|jddzf|S)N.r<)atset)rrrXs rr5z(_kth_arnoldi_iteration..s$ADa!e,0033rr<NrN) r rrrrrrrrrrrr_)rXrkrQVHrlrUrr4v_norm_0rrOunit_vv_norm_1 breakdowns` r_kth_arnoldi_iterationrs- (+a.. 9(%  #E * *% %#""""A&&!a!gg!""+!X *1a! L L L$!Q h#$Qs333&(3333Q??!d1q5koohooe,,--!d1aaa4jnnQ!"n) Ayrc&||}||dz}||z||zz }||z||zz}|j||}|j|dz|}|Sr^)rrr)ricssnx1y1x2y2s r_rotate_vectorsrst"Qx" wwyy2~ B&" Bwb"d1gkk"oo!d1q5koob! (rc t|dk}t|t|k}tj||| tj|||z }tjdt|dzz|j}tj|dtj|||z|}tj|dtj||||z}||fS)Nrr<r;)absrrrrsqrtr_rl)arrb_zeroa_lt_brrVrrs r_givens_rotationrs q66Q;& q66CFF?& yA61a!8!88! iCFFaK  ''00! yCIfa!eQ7788" yCIfaQ7788" R-rcfd}tjd|||}t||||dz}j|ddf|t ||g|R}|fS)z Applies the Givens rotations stored in the vectors cs and sn to the vector H_row. Then constructs and applies a new Givens rotation that eliminates H_row's k'th element. c4t||g|ddfRSr)r)rH_rowgivenss rapply_ith_rotationz3_apply_givens_rotations..apply_ith_rotations' 5! 3fQTl 3 3 33rrr<N)r fori_looprrrr)rr rXr R_rowgivens_factorss ` r_apply_givens_rotationsrs44444 -10% 8 8%#E!HeAEl;;. 9QT?  ~ . .& % 4^ 4 4 4% rctfd|}tjt|} tjdz| } tjdf| } tjdz| } | jd|| } fd} fd}d||| | | f}tj | ||}|\}}}} } }~tj | dddd fj| dd tfd |}t||}t!||}t#|\}}|||fS) a2 Implements a single restart of GMRES. The restart-dimensional Krylov subspace K(A, x0) = span(A(x0), A@x0, A@A@x0, ..., A^restart @ x0) is built, and the projection of the true solution into this subspace is returned. This implementation builds the QR factorization during the Arnoldi process. cVtj|dd|jzdffzSN).N))rrrrpadrErrestarts rr5z$_gmres_incremental..)) i!&&8QL?&JKKrr<rr;rcP|\}}}}}}tj|k|kSrr)rrXerrrUptolrs r loop_condz%_gmres_incremental..loop_conds/AsAq!Q ?1w;d 3 33rc>|\}}}}}}t| ||\}}}t||ddf||\}}|j|ddf|}t ||g||ddfR}t ||dz} |dz| ||||fSr^)rrrrrr) rrXrUrRbeta_vecr rr rrkrQs rarnoldi_qr_stepz+_gmres_incremental..arnoldi_qr_steps#( Aq!Q&$Q1a33GAq!+AadGVQ??ME6 QT uAx:VAqqqD\:::H hq1uo  C q5#q!Xv --rNrc8t|dddfSN.rrrs rr5z$_gmres_incremental..$qcrc{A..r)rrrpreyerrrr_rrqjsplinalgsolve_triangularTr`rar)rkrrrs unit_residual residual_normrrrQrrlrr rrrrrXrUdxrresidualrs` ``` @r_gmres_incrementalr+sKKKK! /;q>> *% ggw{%000! 9gq\ / / /& Y! E 2 2 2( [^   4 4U ; ; < <(444444...... mQ8V 4% .OU ; ;%(-%!]Aq(A j!!!AAAssF)+x}==!....22" 2rll! QtAqqtt}}  (!0!:!:- M= ((rct|j|}t|j|}tj||dS)Npos)assume_a)rGr&rr#r$r)rrra2b2s r_lstsqr1sQ ACHHJJ" ACHHJJ"   "b5  1 11rc~tfd|}tjt|\} } tj| } t jtjdz| | } fd} fd} || ddf}tj | | |\}} }}tj | dzf j d || }t| j|tfd |}t#||}t%||}t'|\}}|||fS) ac Implements a single restart of GMRES. The ``restart``-dimensional Krylov subspace K(A, x0) = span(A(x0), A@x0, A@A@x0, ..., A^restart @ x0) is built, and the projection of the true solution into this subspace is returned. This implementation solves a dense linear problem instead of building a QR factorization during the Arnoldi process. cVtj|dd|jzdffzSrrrs rr5z _gmres_batched..rrr<r)rch|\}}}}tj|ktj|Sr)rr logical_not)rrUrrXrs rrz!_gmres_batched..loop_conds1Aq)Q ?1w; (B(B C CCrcR|\}}}}t|||\}}}||||dzfSr^)r)rrrrUrXrrkrQs rarnoldi_processz'_gmres_batched..arnoldi_process"s>JAq!Q,Q1a;;OAq) aAE !!rFr)r>c8t|dddfSr rrs rr5z _gmres_batched..,r!r)rr rrrrrrr"rrqrrrr_r1r&r`rar)rkrrrsr'r(rrrQrrlrrrr7rrUrr)rr*rs` `` @r_gmres_batchedr9 s KKKK!0+a..A%  #E * *%( ggw{%000IGGG!DDDDD"""""" a %~i%@@*!Q1 ^Agk^ 4 4 4 7 : > >}?S?STY?Z?Z [ [( QS(!....22" 2rll! QtAqqtt}}  (!0!:!:- M= ((rc t|} t| \} } fd} fd} |d| | f}tj| | |\}}}}|}|}|S)a The main function call wrapped by custom_linear_solve. Repeatedly calls GMRES to find the projected solution within the order-``restart`` Krylov space K(A, x0, restart), using the result of the previous projection in place of x0 each time. Parameters are the same as in ``gmres`` except: atol: Tolerance for norm(A(x) - b), used between restarts. ptol: Tolerance for norm(M(A(x) - b)), used within a restart. gmres_func: A function performing a single GMRES restart. Returns: The solution. cL|\}}}}tj|k|kSrr)rTrUrXr(rPr[s rr\z_gmres_solve..cond_funEs,"Aq!] ?1w; (< = ==rc P|\}}}}||| \}}}||dz||fSr^r3) rTrrXr'r(rkrQrr gmres_funcrrs rrmz_gmres_solve..body_funIsO).&Aq-&0j 1a tWa'A'A#A}m a!e]M 11rr)rarrrq)rkrrrsrPrrr[rQr=r*r'r(r\rminitializationrzrXrUrs`` `````` r _gmres_solver?5sQtAqquu~~  (!0!:!:->>>>>>2222222222 =-8.~h.II'1a! ! .rbatched)rOrPrr[rQ solve_methodcttj|tt |}t t |f\}t dt|D} d| zt| tt|kr/tdtdt|t|} tj || z|} t| } | tj d| z z|dkrtn!|dkrtntd |d fd } t!j||| | }tjt|}tj|d d}||fS)a GMRES solves the linear system A x = b for x, given A and b. A is specified as a function performing A(vi) -> vf = A @ vi, and in principle need not have any particular special properties, such as symmetry. However, convergence is often slow for nearly symmetric operators. Parameters ---------- A: ndarray, function, or matmul-compatible object 2D array or function that calculates the linear map (matrix-vector product) ``Ax`` when called like ``A(x)`` or ``A @ x``. ``A`` must return array(s) with the same structure and shape as its argument. b : array or tree of arrays Right hand side of the linear system representing a single vector. Can be stored as an array or Python container of array(s) with any shape. Returns ------- x : array or tree of arrays The converged solution. Has the same structure as ``b``. info : None Placeholder for convergence information. In the future, JAX will report the number of iterations when convergence is not achieved, like SciPy. Other Parameters ---------------- x0 : array or tree of arrays, optional Starting guess for the solution. Must have the same structure as ``b``. If this is unspecified, zeroes are used. tol, atol : float, optional Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``. We do not implement SciPy's "legacy" behavior, so JAX's tolerance will differ from SciPy unless you explicitly pass ``atol`` to SciPy's ``gmres``. restart : integer, optional Size of the Krylov subspace ("number of iterations") built between restarts. GMRES works by approximating the true solution x as its projection into a Krylov space of this dimension - this parameter therefore bounds the maximum accuracy achievable from any guess solution. Larger values increase both number of iterations and iteration cost, but may be necessary for convergence. The algorithm terminates early if convergence is achieved before the full subspace is built. Default is 20. maxiter : integer Maximum number of times to rebuild the size-``restart`` Krylov space starting from the solution found at the last iteration. If GMRES halts or is very slow, decreasing this parameter may help. Default is infinite. M : ndarray, function, or matmul-compatible object Preconditioner for A. The preconditioner should approximate the inverse of A. Effective preconditioning dramatically improves the rate of convergence, which implies that fewer iterations are needed to reach a given error tolerance. solve_method : 'incremental' or 'batched' The 'incremental' solve method builds a QR decomposition for the Krylov subspace incrementally during the GMRES process using Givens rotations. This improves numerical stability and gives a free estimate of the residual norm that allows for early termination within a single "restart". In contrast, the 'batched' solve method solves the least squares problem from scratch at the end of each GMRES iteration. It does not allow for early termination, but has much less overhead on GPUs. See also -------- scipy.sparse.linalg.gmres jax.lax.custom_linear_solve Nc3$K|] }|jV dSrrrs rrzgmres..s$ . .RW . . . . . .rrrrg? incrementalrAzinvalid solve_method z+, must be either 'incremental' or 'batched'c 2t|| Sr)r?) rkrrrQrPr=r[rrrss r_solvezgmres.._solves! 1b$gw: N NNr)rrrr)rrrr9rMrrrminr rFr*rnminimumr+r9rrisnanr)rkrrrsrOrPrr[rQrBrb_normMbMb_normrGrfailedrr=rs ` ```` @@rgmresrOVs"LZ #.! $ $BYA!! aW  %!R . .{1~~ . . . . .$ _4iG   'B>!,,,,  7 "   7 7#1!#4#4 7 7 8 88 88& S6\4 ( ($qtt" "II' 3;sD6M22 2$]""#JJy  JJ 2\222 3 33OOOOOOOOOOO a&&III! 9U1XX  & 62q ! !$ D.rc :tt|||||||S)aO Use Bi-Conjugate Gradient Stable iteration to solve ``Ax = b``. The numerics of JAX's ``bicgstab`` should exact match SciPy's ``bicgstab`` (up to numerical precision), but note that the interface is slightly different: you need to supply the linear operator ``A`` as a function instead of a sparse matrix or ``LinearOperator``. As with ``cg``, derivatives of ``bicgstab`` are implemented via implicit differentiation with another ``bicgstab`` solve, rather than by differentiating *through* the solver. They will be accurate only if both solves converge. Parameters ---------- A: ndarray, function, or matmul-compatible object 2D array or function that calculates the linear map (matrix-vector product) ``Ax`` when called like ``A(x)`` or ``A @ x``. ``A`` can represent any general (nonsymmetric) linear operator, and function must return array(s) with the same structure and shape as its argument. b : array or tree of arrays Right hand side of the linear system representing a single vector. Can be stored as an array or Python container of array(s) with any shape. Returns ------- x : array or tree of arrays The converged solution. Has the same structure as ``b``. info : None Placeholder for convergence information. In the future, JAX will report the number of iterations when convergence is not achieved, like SciPy. Other Parameters ---------------- x0 : array or tree of arrays Starting guess for the solution. Must have the same structure as ``b``. tol, atol : float, optional Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``. We do not implement SciPy's "legacy" behavior, so JAX's tolerance will differ from SciPy unless you explicitly pass ``atol`` to SciPy's ``cg``. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M : ndarray, function, or matmul-compatible object Preconditioner for A. The preconditioner should approximate the inverse of A. Effective preconditioning dramatically improves the rate of convergence, which implies that fewer iterations are needed to reach a given error tolerance. See also -------- scipy.sparse.linalg.bicgstab jax.lax.custom_linear_solve r)rrrs rbicgstabrQs.n bc A ' ' ''rr)r;)@ functoolsrr,numpyrArC jax.numpyrrrrr# jax.tree_utilrrr r r jax._srcr jax._src.laxr jax._src.utilr r(dotr#r$rGr"reinsumrrr r%r*r0r6rr`subra _dot_treer9rMr{rrrrrrrrrrrr+r1r9r?rOrQr3rrr]s  11111111111111,,,,,,))))))wsw#-"7888CM$9::: '#* (= > > >    ;;;888 555 777777wx&&wx&& GHd # #      FFF&!Ty!!!!!L,4cY,,,,,^---&CD%&&&&&R7=TTT7=7=7=7=7=t,+++BBBBJ8   &0)0)0)f222))))))XBn3D ynnnnnb9'4c449'9'9'9'9'9'9'r