\hNzSrSSKJr SSKJrJrJrJrJr SSK J r J r SSK J r SSKJr SSKJr SSKJrJr SS KJrJrJrJrJr SS KJrJrJrJrJ r J!r! SS K"J#r# SS K$J%r% SS K&J'r'J(r(J)r)J*r* SSK+J,r, \,RZ\,R\4\ S4/r/Sr0Sr1Sr2Sr3Sr4"SS5r5"SS5r6Sr7SSjr8S Sjr9S!Sjr:Sr;g)"z2Tools for doing common subexpression elimination. ) defaultdict)BasicMulAddPowsympify)Tuple OrderedSet) factor_terms)S)ordered)symbolsSymbol) MatrixBaseMatrixImmutableMatrix SparseMatrixImmutableSparseMatrix) MatrixExpr MatrixSymbolMatMulMatAddMatPowInverse) MatrixElement)RootOf)numbered_symbolssifttopological_sortiterable)cse_optsNc,[U5n/n[U5HBunup4[U5H+unupgX7R;dMURX%45 M- MD [ [ [ U55U45Vs/sHoUPM sn$s snf)aSort replacements ``r`` so (k1, v1) appears before (k2, v2) if k2 is in v1's free symbols. This orders items in the way that cse returns its results (hence, in order to use the replacements in a substitution option it would make sense to reverse the order). Examples ======== >>> from sympy.simplify.cse_main import reps_toposort >>> from sympy.abc import x, y >>> from sympy import Eq >>> for l, r in reps_toposort([(x, y + 1), (y, 2)]): ... print(Eq(l, r)) ... Eq(y, 2) Eq(x, y + 1) )r enumerate free_symbolsappendrrangelen) rEc1k1v1c2k2v2is O/var/www/auris/envauris/lib/python3.13/site-packages/sympy/simplify/cse_main.py reps_toposortr3+s(  A A!! HR%aLLB__$"")%+E#a&M1+=> ?>QaD> ?? ?sBc[US5nXSVs/sHo3RPM sn-nUSn[U5U/$s snf)aoMove expressions that are in the form (symbol, expr) out of the expressions and sort them into the replacements using the reps_toposort. Examples ======== >>> from sympy.simplify.cse_main import cse_separate >>> from sympy.abc import x, y, z >>> from sympy import cos, exp, cse, Eq, symbols >>> x0, x1 = symbols('x:2') >>> eq = (x + 1 + exp((x + 1)/(y + 1)) + cos(y + 1)) >>> cse([eq, Eq(x, z + 1), z - 2], postprocess=cse_separate) in [ ... [[(x0, y + 1), (x, z + 1), (x1, x + 1)], ... [x1 + exp(x1/x0) + cos(x0), z - 2]], ... [[(x1, y + 1), (x, z + 1), (x0, x + 1)], ... [x0 + exp(x0/x1) + cos(x1), z - 2]]] ... True cTUR=(a URR$N) is_Equalitylhs is_Symbol)ws r2cse_separate..\s!--;AEEOO;TF)rargsr3)r)edr:s r2 cse_separaterAHsL( Q;>> from sympy import cse >>> from sympy.simplify.cse_main import cse_release_variables >>> from sympy.abc import x, y >>> eqs = [(x + y - 1)**2, x, x + y, (x + y)/(2*x + 1) + (x + y - 1)**2, (2*x + 1)**(x + y)] >>> defs, rvs = cse_release_variables(*cse(eqs)) >>> for i in defs: ... print(i) ... (x0, x + y) (x1, (x0 - 1)**2) (x2, 2*x + 1) (_3, x0/x2 + x1) (_4, x2**x0) (x2, None) (_0, x1) (x1, None) (_2, x0) (x0, None) (_1, x) >>> print(rvs) (_0, _1, _2, _3, _4) z_:%dcR>[UU4SjUSRT-55*$)Nc3h># UH'nTTRU5R5v M) g7fr6)index count_ops).0r1pss r2 :cse_release_variables....s0-+AQWWQZ=2244+s/2r)sumr%)xin_userHrIs r2r;'cse_release_variables..s+s-1""V+---r=keyr!rN) ziprr(listsetr'sortedpopr%extendstrr&reverse) r)r?esymssymsr1rv_pcrIrNrHs `@@r2cse_release_variablesr_bsnD t 7DAq FSVO $E ;D QA VF QA"'A-0-QA$-A06! -./GA :DFA B A A q& UUW R__ $ II&*<=* A; IItxxz2& ' IIqtRj !!  Q q&JJL 9) 1>s 2F F c6UHup#UcM U"U5nM U$)aLPreprocess an expression to optimize for common subexpression elimination. Parameters ========== expr : SymPy expression The target expression to optimize. optimizations : list of (callable, callable) pairs The (preprocessor, postprocessor) pairs. Returns ======= expr : SymPy expression The transformed expression. expr optimizationspreposts r2preprocess_for_csergs%$#  ?t9D# Kr=cH[U5Hup#UcM U"U5nM U$)aPostprocess an expression after common subexpression elimination to return the expression to canonical SymPy form. Parameters ========== expr : SymPy expression The target expression to transform. optimizations : list of (callable, callable) pairs, optional The (preprocessor, postprocessor) pairs. The postprocessors will be applied in reversed order to undo the effects of the preprocessors correctly. Returns ======= expr : SymPy expression The transformed expression. )reversedrbs r2postprocess_for_cserjs+(m,   :D- Kr=cJ\rSrSrSrSrSrSrSrS Sjr S S jr S r S r g)FuncArgTrackerzq A class which manages a mapping from functions to arguments and an inverse mapping from arguments to functions. cT0Ul/Ul/Ul/Ul[ U5H}up#[ 5nUR HCnURU5nURU5 URURU5 ME URRU5 M gr6) value_numbersvalue_number_to_valuearg_to_funcsetfunc_to_argsetr$r r>get_or_add_value_numberaddr&)selffuncsfunc_ifunc func_argsetfunc_arg arg_numbers r2__init__FuncArgTracker.__init__s %'"! %e,LF$,K II!99(C  +##J/33F;&    & &{ 3-r=c\[U5Vs/sHo RUPM sn$s snf)zP Return the list of arguments in sorted order according to their value numbers. )rUrp)ruargsetargns r2get_args_in_value_order&FuncArgTracker.get_args_in_value_orders* >DF^L^T**40^LLLs)c[UR5nURRX5nX2:Xa>URR U5 UR R [ 55 U$)z1 Return the value number for the given argument. )r(ro setdefaultrpr&rqr )ruvaluenvalues value_numbers r2rs&FuncArgTracker.get_or_add_value_numbers`d(()))44UD  "  & & - -e 4    & &z| 4r=clURUH!nURURU5 M# g)zC Remove the function func_i from the argument to function mapping. N)rrrqremove)rurwargs r2stop_arg_tracking FuncArgTracker.stop_arg_trackings2&&v.C    $ + +F 3/r=c[S5nU(dU$UVs/sHo@RUPM nn[U[S9nUH%nXgLaM UHnX:dM X8==S- ss'M M' [ Xc/[S9un n U H nX8S:aM X;dMX8==S- ss'M" UR 5V V s0sHupU S:dM X_M sn n $s snfs sn n f)zReturn a dict whose keys are function numbers. The entries of the dict are the number of arguments said function has in common with ``argset``. Entries have at least 2 items in common. All keys have value at least ``min_func_i``. cg)Nrrarar=r2r;:FuncArgTracker.get_common_arg_candidates..sr=rPr!)rrqmaxr(rUitems) rur min_func_i count_maprfuncsetslargest_funcsetfuncsetrwsmaller_funcs_containerlarger_funcs_containerkvs r2get_common_arg_candidates(FuncArgTracker.get_common_arg_candidatess  *  8>?'',?hC0G)!'%*%" $*!-$ ! .F 1$/!Q&!."+!2=!2a1f!2==9@8>sC8 CCNc[U5n[SUR[U555nUbXB-nUHnX@RU-nM U$)z Return a set of functions each of which whose argument list contains ``argset``, optionally filtered only to contain functions in ``restrict_to_funcset``. c3$# UHov M g7fr6ra)rGfis r2rJ7FuncArgTracker.get_subset_candidates..>s:82B8s)iterr rqnext)rurrestrict_to_funcsetiargindicesrs r2get_subset_candidates$FuncArgTracker.get_subset_candidates6sg F|:,,T$Z8::  *  *GC **3/ /Gr=cR[U5nURUnXC- H!nURURU5 M# X4- H!nURUR U5 M# URUR 5 URUR U5 g)z0 Update a function with a new set of arguments. N)r rrrqrrtclearupdate)rurw new_argsetnew_argsold_args deleted_arg added_args r2update_func_argset!FuncArgTracker.update_func_argsetIsj)&&v.#.K    , 3 3F ;/!,I    * . .v 6- F#))+ F#**84r=)rqrrrpro)rr6) __name__ __module__ __qualname____firstlineno____doc__r|rrsrrrr__static_attributes__rar=r2rlrls, 4(M 4&>P& 5r=rlc:\rSrSrSrSrSr\S5r\r Sr g) UnevaluatediYcXlX lgr6rxr>)rurxr>s r2r|Unevaluated.__init__[s   r=czSRURSRSUR555$)NzUneval<{}>({})z, c38# UHn[U5v M g7fr6)rX)rGas r2rJ&Unevaluated.__str__..as$?YSVVYs)formatrxjoinr>rus r2__str__Unevaluated.__str___s3&& 499$?TYY$??A Ar=c:UR"URSS06$)NevaluateFrrs r2as_unevaluated_basic Unevaluated.as_unevaluated_basiccsyy$))4e44r=c[5R"URVs/sHoRPM sn6$s snfr6)rTunionr>r%)rurs r2r%Unevaluated.free_symbolsfs+u{{TYY?Y^^Y?@@?s<)r>rxN) rrrrr|rrpropertyr%__repr__rrar=r2rrYs/A5AAHr=rc ^[USS9n[U5n[5n[[ U55GH.nUR UR UUS-S9m[[TR5U4SjS95nU(GaURSS9nUR URUR U5n[ U5S::aMSUR URU5n U (a[[XRU55n URU 5n URXY[U /5-5 URU5 OURX5n UR URU5n URX|[U /5-5 URU5 UR!X5HPn UR U RU5nURX[U /5-5 URU 5 MR U(aGMXT;a-[UURUR U55X!U'UR#U5 GM1 g) a/ Recognize and extract common subexpressions of function arguments within a set of function calls. For instance, for the following function calls:: x + z + y sin(x + y) this will extract a common subexpression of `x + y`:: w = x + y w + z sin(w) The function we work with is assumed to be associative and commutative. Parameters ========== func_class: class The function class (e.g. Add, Mul) funcs: list of functions A list of function calls. opt_subs: dict A dictionary of substitutions which this function may update. c,[UR5$r6)r(r>)fs r2r;#match_common_args..s AFF r=rPr!)rc>TUU4$r6ra)rcommon_arg_candidates_countss r2r;rs;A>Br=F)lastN)rUrlr r'r(rrrkeysrV intersection differencerrrsrrtrr) func_classrvopt_subs arg_trackerchangedr1common_arg_candidatesjcom_argsdiff_icom_funccom_func_numberdiff_jrdiff_krs @r2match_common_argsrmsG: 53 4E 'KlG 3u: '2'L'L**1-!a%(M(A$ !+6,113B,D!E$%))u)5A"11!4AA..q13H8}! !//2==hGF&"$G$G$QS"-"E"Eh"O..q:FW;X2XY A#."E"Eeh"O //2==hGF  * *1z?BS7T.T U KKN 665$33A6AA(K..q:FW;X2XY A 5K$#V >> from sympy.simplify.cse_main import opt_cse >>> from sympy.abc import x >>> opt_subs = opt_cse([x**-2]) >>> k, v = list(opt_subs.keys())[0], list(opt_subs.values())[0] >>> print((k, v.as_unevaluated_basic())) (x**(-2), 1/(x**2)) c>[U[[45(dgUR(dUR(ag[ U5(a[ [TU55 gUT ;aU$T RU5 [ [TUR55 [U[5(dUR5(ay[U[5(a[SUR56nOU*nUR(d6[[[RU45TU'T RU5 Un[U[[ 45(a=[#UR5S:XaTRU5 gTRU5 g[U[[$45(a=[#UR5S:XaTRU5 gTRU5 g[U[&5(ag[U[([*45(aMUR,UR.p2UR5(a [[([)X#*5S45TU'ggg)Nc3&# UHo*v M g7fr6ra)rGr1s r2rJ.opt_cse.._find_opts..s 7YYsr!) isinstancerris_Atomis_Orderr rSmaprtr>rcould_extract_minus_signrrr NegativeOnerr(rrrrbaseexp) rcneg_exprrr _find_optsaddscollapsible_subexpmulsr seen_subexps r2ropt_cse.._find_optss$ 455  <<4==  D>> Z& '  ; K STYY '($ ++0M0M0O0O$$$ 7TYY 78 5##!,S1==(2K!L) dS&M * *499~""&&t, sFm , ,499~""&&t, g & &  sFm , , 488#++--!,S3tT?B2G!H.-r=rF)csetr!r)r)r rTrrrr>rirgetargs_cncrxrr(rtrrr)exprsorderr?rIedgescommutative_mulsmr^ncc_mulnew_objrrrrrrs @@@@@@r2opt_csers:H [U[[45(dg[U[5(ag[U[5(ajUR(d,UR (d[U[ [45(a-UR(aTRUR5 g[U5(aUnOZUT;a,THnX R;dM O TRU5 gTRU5 UT;aTUnURn[[TU55 gr6)rrrrrrrrr9rtnamer r%r>rSr) rcr>ign_find_repeatedexcluded_symbolsignorerr to_eliminates r2r  tree_cse.._find_repeatedds$ 455  dF # #  dE " "  4, !>??~~ $$TYY/  D>>D{"!C///"!$$T* OOD !x~99D S &'r=c3J># UHoRT;dMUv M g7fr6)r )rG_r s r2rJtree_cse..sD'QVV3C%Cqq's# #c>[U[[45(dU$UR(dU$[ U5(a1URVs/sH nT "U5PM nnUR "U6$UT ;aT U$UnUT ;aT UnT S:wa[U[ [45(a4UR5upEUS/:XaUnOk[[U55U-nOS[U[[45(a[[UR55nOURnO URn[[T U55n[U[5(dX&:waUR "U6nOUnUT;ae[T5n[U["5(a+[%UR&UR(UR*5nUT U'T R-X45 U$U$s snf![a [!S5ef=f)Nnoner!z$Symbols iterator ran out of symbols.)rrrr>r rxrrrrSr rrrr StopIteration ValueErrorrrr rowscolsr&)rcrr orig_exprr^rr>new_exprsym_rebuildrr replacementssubsrrs r2rtree_cse.._rebuilds$ 455KyyK D>>15;# H;99h' ' 4<:  8 D>D F?$f .. 8D +b0DD3-00GDII./yy99DHd+, dK ( (H,<yy(+HH  $ I7m)Z00"388Y^^NN$"DO    0JO_>> from sympy import cse, SparseMatrix >>> from sympy.abc import x, y, z, w >>> cse(((w + x + y + z)*(w + y + z))/(w + x)**3) ([(x0, y + z), (x1, w + x)], [(w + x0)*(x0 + x1)/x1**3]) List of expressions with recursive substitutions: >>> m = SparseMatrix([x + y, x + y + z]) >>> cse([(x+y)**2, x + y + z, y + z, x + z + y, m]) ([(x0, x + y), (x1, x0 + z)], [x0**2, x1, y + z, x1, Matrix([ [x0], [x1]])]) Note: the type and mutability of input matrices is retained. >>> isinstance(_[1][-1], SparseMatrix) True The user may disallow substitutions containing certain symbols: >>> cse([y**2*(x + 1), 3*y**2*(x + 1)], ignore=(y,)) ([(x0, x + 1)], [x0*y**2, 3*x0*y**2]) The default return value for the reduced expression(s) is a list, even if there is only one expression. The `list` flag preserves the type of the input in the output: >>> cse(x) ([], [x]) >>> cse(x, list=False) ([], x) )rrd postprocessrrbasic)cls)_cse_homogeneousrintfloatrrrrrr&r flatrrtodokrbasic_optimizationsrgrrrrr#rjr$rr as_immutable)rrrdr%rrrScopytempr?r!rrrsubtreer1rrrs r2cser2s` #A A%#u&&%%,-- D D  a&/2 3 3 KKqvvx( ) L*?@ A A KKqwwy01 2 KKN  E  ' !+ DII5a'95MI"v.w-},H#+=8+0#:L E(46(4 -gEF(46,-+):+-%  a&/2 3 3%affaffm6FGM !_--#0#3#@#@#B  . L*?@ A AQVVQVVR0A%(1!)!233NN$ M !** | 33QJ$6-s!J55J:Kc [U[5(a$[[U540UD6up#U[ U54$[U[ [ [45(a![U40UD6up#U[U5"U54$[U[5(aQ[ UR55n[UVs/sHoPUPM sn40UD6up&[[XF55nX#4$[U40UD6ununX#4$s snf![a /U4s$f=f)a Same as ``cse`` but the ``reduced_exprs`` are returned with the same type as ``exprs`` or a sympified version of the same. Parameters ========== exprs : an Expr, iterable of Expr or dictionary with Expr values the expressions in which repeated subexpressions will be identified kwargs : additional arguments for the ``cse`` function Returns ======= replacements : list of (Symbol, expression) pairs All of the common subexpressions that were replaced. Subexpressions earlier in this list might show up in subexpressions later in this list. reduced_exprs : list of SymPy expressions The reduced expressions with all of the replacements above. Examples ======== >>> from sympy.simplify.cse_main import cse >>> from sympy import cos, Tuple, Matrix >>> from sympy.abc import x >>> output = lambda x: type(cse(x, list=False)[1]) >>> output(1) >>> output('cos(x)') >>> output(cos(x)) cos >>> output(Tuple(1, x)) >>> output(Matrix([[1,0], [0,1]])) >>> output([1, x]) >>> output((1, x)) >>> output({1, x}) )rrXr(rreprrStuplerTr2typedictrrR TypeError)rkwargsrr!rrvaluess r2r(r(qs\%&6 EN'&$'&# T-000%$s+,,&)%&:6&:# T%[777%EJJL!"d#;d!Hd#;FvF S./ **+),U)=f)=& &}**$< 5ys2C6"C;;D  D ) canonical)Nr;ra)NNNr;raT)rKs#443-"&-AAAA<*##!(((*;*;<$d+-@:!4@L04|5|5~([)|yxN'b>B+/V4r@+r=