\h(DSrSSKJrJrJrJr SSKJr SrSr Sr Sr g) z%Module for differentiation using CSE.)cseMatrix Derivative MatrixBase)iterablec ^ ^ U U 4Sjm Sm [U5nUVVs/sHup4UT "XB54PM nnnUVVs/sH+nURUVs/sH nT "Xr5PM sn5PM- nnnXX4$s snnfs snfs snnf)a This function is designed to postprocess the output of a common subexpression elimination (CSE) operation. Specifically, it removes any CSE replacement symbols from the arguments of ``Derivative`` terms in the expression. This is necessary to ensure that the forward Jacobian function correctly handles derivative terms. Parameters ========== replacements : list of (Symbol, expression) pairs Replacement symbols and relative common subexpressions that have been replaced during a CSE operation. reduced_expressions : list of SymPy expressions The reduced expressions with all the replacements from the replacements list above. Returns ======= processed_replacements : list of (Symbol, expression) pairs Processed replacement list, in the same format of the ``replacements`` input list. processed_reduced : list of SymPy expressions Processed reduced list, in the same format of the ``reduced_expressions`` input list. c>[U[5(aT"X5$UR(dU$URVs/sH nT"X!5PM nnUR"U6$s snfN) isinstancerargsfunc)node repl_dictargnew_args replace_alltraverses P/var/www/auris/envauris/lib/python3.13/site-packages/sympy/simplify/_cse_diff.pyr-_remove_cse_from_derivative..traverse&sY dJ ' 't/ /yyK8< B HS, Byy(##CsA#cUnURnUVs0sHoDU;dM XAU_M nnU(dU$URU5nMEs snfr ) free_symbolsxreplace)rrresultrk symbols_dicts rr0_remove_cse_from_derivative..replace_all.sX!..L5AT\)^OA|O\LT __\2F Ts A  A )dict __class__) replacementsreduced_expressionsrrep_symsub_expprocessed_replacementsred_expexpprocessed_reducedrrs @@r_remove_cse_from_derivativer's>$\"I!- , G (7./ , +*G wGw8C3wGH* " 44 HsA3A>A9" A>9A>c[US[5(d [S5eUSRSS:Xd!USRSS:Xd [S5e[ U5(d [S5e[U[5(d [ U5nURSS:XdURSS:Xd [S5e[ X5upU(a[[ [U65up4O[ /5[ /5pC[U5[U5[US5pvnUSRRXv[US5VV V V s0sH7up[U5H"upU RU 5=n S:wdMX4U _M$ M9 sn n n n5n U(d/U //4$[ R"Xu[USV s/sHoU R4PM sn 5VV VV Vs0sHAunup[U5H)upX;dM U RU5=n S:wdM%X4U _M+ MC snn nn n5n[U5nUVs/sHoRU-PM nn[ R"SU[U5V V s0sH&upUSRU 5=n S:wdM!SU 4U _M( sn n 5n[!SU5GH*n[ R"SU[!US-5V s0sH2n X:UU;dMXHRX:5=n S:wdM-SU 4U _M4 sn 5n[ R"SU[U5V V s0sH%upXHRU 5=n S:wdM SU 4U _M' sn n 5nUR"R%5(a:UR'U5R)U5n[ R*"UU5nGM[ R*"UU5nGM- UR'U5R)U 5nUSRU5/nUUU4$s sn n n nfs sn fs snn nn nfs snfs sn n fs sn fs sn n f)a Core function to compute the Jacobian of an input Matrix of expressions through forward accumulation. Takes directly the output of a CSE operation (replacements and reduced_expr), and an iterable of variables (wrt) with respect to which to differentiate the reduced expression and returns the reduced Jacobian matrix and the ``replacements`` list. The function also returns a list of precomputed free symbols for each subexpression, which are useful in the substitution process. Parameters ========== replacements : list of (Symbol, expression) pairs Replacement symbols and relative common subexpressions that have been replaced during a CSE operation. reduced_expr : list of SymPy expressions The reduced expressions with all the replacements from the replacements list above. wrt : iterable Iterable of expressions with respect to which to compute the Jacobian matrix. Returns ======= replacements : list of (Symbol, expression) pairs Replacement symbols and relative common subexpressions that have been replaced during a CSE operation. Compared to the input replacement list, the output one doesn't contain replacement symbols inside ``Derivative``'s arguments. jacobian : list of SymPy expressions The list only contains one element, which is the Jacobian matrix with elements in reduced form (replacement symbols are present). precomputed_fs: list List of sets, which store the free symbols present in each sub-expression. Useful in the substitution process. rz``expr`` must be of matrix typez)``expr`` must be a row or a column matrixz(``wrt`` must be an iterable of variablesz(``wrt`` must be a row or a column matrix)r r TypeErrorshaperrr'mapziplenrfrom_dok enumeratediffrsetrange_repnnzmultiplyaddvstack)r reduced_exprwrtr!sub_exprl_subl_wrtl_redirjw diff_valuef1fssf2 rep_sym_setprecomputed_fsc_matrix bi_matrix ai_matrix ci_matrixjacobians r_forward_jacobian_cserOEs3X l1oz 2 29:: O ! !! $ )\!_-B-B1-E-JCDD C==BCC Z ( (Sk IIaLA 1!2BCC!<\!XL\(:;"2Jr h-S3|A3G%E a " " + +E",q/2 2!#ffQi' A- QFJ & 2  B B4| (lSTo(VoQ^^)>    !**8488CI}}Xy9H}}Xy9H"{{8$((,HQ))(34H > 11_ )W G M %\ %RsT.P4 P4 P<.QQ* QQ  Q. Q1QQ! QQ4 QcB[U5up#[X#U5up$nX$U4$)a  Function to compute the Jacobian of an input Matrix of expressions through forward accumulation. Takes a sympy Matrix of expressions (expr) as input and an iterable of variables (wrt) with respect to which to compute the Jacobian matrix. The matrix is returned in reduced form (containing replacement symbols) along with the ``replacements`` list. The function also returns a list of precomputed free symbols for each subexpression, which are useful in the substitution process. Parameters ========== expr : Matrix The vector to be differentiated. wrt : iterable The vector with respect to which to perform the differentiation. Can be a matrix or an iterable of variables. Returns ======= replacements : list of (Symbol, expression) pairs Replacement symbols and relative common subexpressions that have been replaced during a CSE operation. The output replacement list doesn't contain replacement symbols inside ``Derivative``'s arguments. jacobian : list of SymPy expressions The list only contains one element, which is the Jacobian matrix with elements in reduced form (replacement symbols are present). precomputed_fs: list List of sets, which store the free symbols present in each sub-expression. Useful in the substitution process. )rrO)exprr:rr9rNrIs r!_forward_jacobian_norm_in_cse_outrRs.L"%TL-B<_b-c*LN > 11cv[U5up#U(a[[[U65upEO [/5n[ X#U5up&nU(dUS$[ U5n[ U5H4upU V s0sHoX_M n n XU RU 5XU 'M6 USRU5$s sn f)a Function to compute the Jacobian of an input Matrix of expressions through forward accumulation. Takes a sympy Matrix of expressions (expr) as input and an iterable of variables (wrt) with respect to which to compute the Jacobian matrix. Explanation =========== Expressions often contain repeated subexpressions. Using a tree structure, these subexpressions are duplicated and differentiated multiple times, leading to inefficiency. Instead, if a data structure called a directed acyclic graph (DAG) is used then each of these repeated subexpressions will only exist a single time. This function uses a combination of representing the expression as a DAG and a forward accumulation algorithm (repeated application of the chain rule symbolically) to more efficiently calculate the Jacobian matrix of a target expression ``expr`` with respect to an expression or set of expressions ``wrt``. Note that this function is intended to improve performance when differentiating large expressions that contain many common subexpressions. For small and simple expressions it is likely less performant than using SymPy's standard differentiation functions and methods. Parameters ========== expr : Matrix The vector to be differentiated. wrt : iterable The vector with respect to which to do the differentiation. Can be a matrix or an iterable of variables. See Also ======== Direct Acyclic Graph : https://en.wikipedia.org/wiki/Directed_acyclic_graph r)rr,rr-rOrr0r) rQr:rr9r!_rNrIsub_repr?ikrAsub_dicts r_forward_jacobianrYsV"%TLl!34 *-B<_b-c*LN  +< G>*+-.2awzM2.%aj1::8D + A;   ((/s3B6N) __doc__sympyrrrrsympy.utilities.iterablesrr'rOrRrYrSrr^s)+55.;5|t2n)2X;)rS