o o hnz@svdZddlmZddlmZmZmZmZmZddl m Z m Z ddl m Z ddlmZddlmZddlmZmZdd lmZmZmZmZmZdd lmZmZmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,e,j-e,j.fe dfgZ/ddZ0ddZ1ddZ2ddZ3ddZ4GdddZ5GdddZ6dd Z7d,d"d#Z8d-d%d&Z9  'd.d(d)Z:d*d+Z;dS)/z3 Tools for doing common subexpression elimination. ) defaultdict)BasicMulAddPowsympify)Tuple OrderedSet) factor_terms)S)ordered)symbolsSymbol) MatrixBaseMatrixImmutableMatrix SparseMatrixImmutableSparseMatrix) MatrixExpr MatrixSymbolMatMulMatAddMatPowInverse) MatrixElement)RootOf)numbered_symbolssifttopological_sortiterable)cse_optsNcsrtg}tD]\}\}}tD]\}\}}||jvr&|||fqq fddttt|fDS)a(Sort 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) cg|]}|qSr#.0irr#k/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/sympy/simplify/cse_main.py Ez!reps_toposort..)r enumerate free_symbolsappendrrangelen)r(Ec1k1v1c2k2v2r#r'r) reps_toposort+s "r8cCs8t|dd}|dd|dD}|d}t||gS)aMove 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 cSs|jo|jjSN) is_Equalitylhs is_Symbol)wr#r#r)\szcse_separate..cSg|]}|jqSr#args)r%r=r#r#r)r*]z cse_separate..TF)rr8)r(edr#r#r) cse_separateHs rEcs8|s|fSt|\tdt}t|tttfddttDttfddd\t7g}td}|dkr}|j@}|ro| d dt|t dD|t|kr| |fn | ||f|8|d8}|dksV| ||fS) a Return tuples giving ``(a, b)`` where ``a`` is a symbol and ``b`` is either an expression or None. The value of None is used when a symbol is no longer needed for subsequent expressions. Use of such output can reduce the memory footprint of lambdified expressions that contain large, repeated subexpressions. Examples ======== >>> 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_:%dcsg|] }||fqSr#r#r$)rCsymsr#r)r*sz)cse_release_variables..cs$tfdd|dj@D S)Nc3s"|] }|VqdSr9)index count_opsr$)psr#r) sz:cse_release_variables....r)sumr-)x)in_userIrJr#r)r>s  z'cse_release_variables..keyr rcSsg|]}|dfqSr9r#r%rJr#r#r)r*r+) zipr r0listsetr/sortedpopr-extendstrr.reverse)r(rCesymsrvr&_pcr#)rCrNrIrJrFr)cse_release_variablesbs:"      r^cCs"|D] \}}|dur||}q|S)a} Preprocess 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. Nr#expr optimizationsprepostr#r#r)preprocess_for_cses rdcCs&t|D] \}}|dur||}q|S)a)Postprocess 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. N)reversedr_r#r#r)postprocess_for_cses rfc@sLeZdZdZddZddZddZdd Zdd d ZdddZ ddZ d S)FuncArgTrackerz} A class which manages a mapping from functions to arguments and an inverse mapping from arguments to functions. cCspi|_g|_g|_g|_t|D]%\}}t}|jD]}||}|||j||q|j |qdSr9) value_numbersvalue_number_to_valuearg_to_funcsetfunc_to_argsetr,r rAget_or_add_value_numberaddr.)selffuncsfunc_ifunc func_argsetfunc_arg arg_numberr#r#r)__init__s   zFuncArgTracker.__init__csfddt|DS)zh Return the list of arguments in sorted order according to their value numbers. cg|]}j|qSr#)ri)r%argnrnr#r)r*z:FuncArgTracker.get_args_in_value_order..)rU)rnargsetr#rxr)get_args_in_value_ordersz&FuncArgTracker.get_args_in_value_ordercCs>t|j}|j||}||kr|j||jt|S)zA Return the value number for the given argument. )r0rh setdefaultrir.rjr )rnvaluenvalues value_numberr#r#r)rls  z&FuncArgTracker.get_or_add_value_numbercCs$|j|D] }|j||qdS)zS Remove the function func_i from the argument to function mapping. N)rkrjremove)rnrpargr#r#r)stop_arg_trackingsz FuncArgTracker.stop_arg_trackingrc stdd}|s |Sfdd|D}t|td}|D]}||ur"q|D]}||kr2||d7<q$qt||gtd\}} |D]}||dkrIq@|| vrU||d7<q@dd|DS) aReturn 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``. cSsdS)Nrr#r#r#r#r)r>sz:FuncArgTracker.get_common_arg_candidates..crvr#)rjr%rrxr#r)r*ryz.rOr cSsi|] \}}|dkr||qS)r#)r%kvr#r#r) 4sz.)rmaxr0rUitems) rnrz min_func_i count_mapfuncsetslargest_funcsetfuncsetrpsmaller_funcs_containerlarger_funcs_containerr#rxr)get_common_arg_candidatess4   z(FuncArgTracker.get_common_arg_candidatesNcCsPt|}tdd|jt|D}|dur||M}|D] }||j|M}q|S)z Return a set of functions each of which whose argument list contains ``argset``, optionally filtered only to contain functions in ``restrict_to_funcset``. css|]}|VqdSr9r#)r%fir#r#r)rK>s z7FuncArgTracker.get_subset_candidates..N)iterr rjnext)rnrzrestrict_to_funcsetiargindicesrr#r#r)get_subset_candidates6s z$FuncArgTracker.get_subset_candidatescCspt|}|j|}||D] }|j||q ||D] }|j||q|j||j||dS)z@ Update a function with a new set of arguments. N)r rkrjrrmclearupdate)rnrp new_argsetnew_argsold_args deleted_arg added_argr#r#r)update_func_argsetIs   z!FuncArgTracker.update_func_argsetrr9) __name__ __module__ __qualname____doc__rur{rlrrrrr#r#r#r)rgs  ( rgc@s4eZdZddZddZddZeddZeZd S) UnevaluatedcCs||_||_dSr9rqrA)rnrqrAr#r#r)ru[s zUnevaluated.__init__cCs d|jddd|jDS)NzUneval<{}>({})z, css|]}t|VqdSr9)rXr%ar#r#r)rKasz&Unevaluated.__str__..)formatrqjoinrArxr#r#r)__str___szUnevaluated.__str__cCs|j|jddiS)NevaluateFrrxr#r#r)as_unevaluated_basiccsz Unevaluated.as_unevaluated_basiccCstjdd|jDS)NcSr?r#)r-rr#r#r)r*hrBz,Unevaluated.free_symbols..)rTunionrArxr#r#r)r-fszUnevaluated.free_symbolsN) rrrrurrpropertyr-__repr__r#r#r#r)rYs rcst|ddd}t|}t}tt|D]}|j|j||ddttfddd}|r|jdd}|j| |j|}t|dkrKq1|j| |} | rst || |} | | } ||| t| gB||n| ||} |j| |} ||| t| gB|||||D]} |j|  |}|| |t| gB|| q|s3||vrt || |j||||<||qd S) aw 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. cSs t|jSr9)r0rA)fr#r#r)r>s z#match_common_args..rOr )rcs ||fSr9r#)rcommon_arg_candidates_countsr#r)r>s F)lastN)rUrgr r/r0rrkkeysrV intersection differencerr{rlrrmrr) func_classroopt_subs arg_trackerchangedr&common_arg_candidatesjcom_argsdiff_icom_funccom_func_numberdiff_jrdiff_kr#rr)match_common_argsmsV          + r canonicalc sPittttfdd|D] }t|ttfr(|qfddD}tt|fD]}|jd|jd|<q:t}D]I}|j dd\}}|r|j |}|r|dkrm|j |} nt|t r|j |g|Rd di} n |j ||j |dd } | |<t |dkr| |qPtttt|S) a=Find optimization opportunities in Adds, Muls, Pows and negative coefficient Muls. Parameters ========== exprs : list of SymPy expressions The expressions to optimize. order : string, 'none' or 'canonical' The order by which Mul and Add arguments are processed. For large expressions where speed is a concern, use the setting order='none'. Returns ======= opt_subs : dictionary of expression substitutions The expression substitutions which can be useful to optimize CSE. Examples ======== >>> 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)) cst|ttfs dS|js|jrdSt|rtt|dS|vr$|S|tt|j t|t sa| rat|t rJt dd|j D}n| }|jsatt tj|f|<||}t|t tfr}t|j dkrv|dS|dSt|t tfrt|j dkr|dS|dSt|trdSt|ttfr|j|j}}| rttt|| df|<dSdSdS)Ncss|]}| VqdSr9r#r$r#r#r)rKsz.opt_cse.._find_opts..r ) isinstancerris_Atomis_OrderrrSmaprmrArcould_extract_minus_signrrr NegativeOnerr0rrrrbaseexp)r`neg_exprrr _find_optsaddscollapsible_subexpmulsr seen_subexpr#r)rsF     zopt_cse.._find_optscs(g|]}|jdvr||jdfqSrr@rQ)rr#r)r**s zopt_cse..rF)csetr r)r)r rTrrrrergetrAargs_cncrqrr0rmrrr) exprsorderrCedgescommutative_mulsmr]ncc_mulnew_objr#rr)opt_cses>5       rr#csdurit tt fdd|D] }t|tr'|qfdd D gi fddg}|D]}t|trQ|}n|}||qE|fS)aPerform raw CSE on expression tree, taking opt_subs into account. Parameters ========== exprs : list of SymPy expressions The expressions to reduce. symbols : infinite iterator yielding unique Symbols The symbols used to label the common subexpressions which are pulled out. opt_subs : dictionary of expression substitutions The expressions to be substituted before any CSE action is performed. order : string, 'none' or 'canonical' The order by which Mul and Add arguments are processed. For large expressions where speed is a concern, use the setting order='none'. ignore : iterable of Symbols Substitutions containing any Symbol from ``ignore`` will be ignored. Ncst|ttfs dSt|trdSt|tr-|js"|js"t|ttfr-|jr+ |j dSt |r4|}n'|vrKD] }||j vrCnq: |dS ||vrX|}|j }tt|dSr9)rrrrrrrrr<rmnamerr-rArSr)r`rAign)_find_repeatedexcluded_symbolsignorerr to_eliminater#r)rds8       z tree_cse.._find_repeatedc3s|] }|jvr|VqdSr9)r)r%_)rr#r)rKsztree_cse..cslt|ttfs |S|js|St|r!fdd|jD}|j|S|vr)|S|}|vr3|}dkrht|ttfrU|\}}|dgkrL|}nt t ||}nt|t t frdt t |j}n|j}n|j}t t |}t|ts{||kr|j|}n|}|vrzt}Wn tytdwt|trt|j|j|j}||<||f|S|S)Ncsg|]}|qSr#r#r)_rebuildr#r)r*r+z.tree_cse.._rebuild..noner z$Symbols iterator ran out of symbols.)rrrrArrqrrrrSr rrrr StopIteration ValueErrorrrrrowscolsr.)r`r orig_exprr]rrAnew_exprsym)rrr replacementssubsr rr#r)rsP        ztree_cse.._rebuild)rTrrr.)rr rrrrC reduced_exprs reduced_er#) rrrrrrrrrr rr)tree_cseGs*$ 9   rTcs|s t|||||dSt|ttfrt|}t|ttfr!|g}|}g}|D]+} t| ttfr:| t | q't| t t frM| t | q'| | q'|}~dur]gndkrctfdd|D} |durvttd}nt|}t| |} t| || ||\} } |}t| D]\} \}}t|}||f| | <qfdd| D} t|D]N\} } t| ttfrt| j| j| | | | <t| tr| | | | <qt| t t frt | j| ji}| | D]\}}|||<qt| t r|}|| | <q|dur| | fS|| | S)as Perform common subexpression elimination on an expression. Parameters ========== exprs : list of SymPy expressions, or a single SymPy expression The expressions to reduce. symbols : infinite iterator yielding unique Symbols The symbols used to label the common subexpressions which are pulled out. The ``numbered_symbols`` generator is useful. The default is a stream of symbols of the form "x0", "x1", etc. This must be an infinite iterator. optimizations : list of (callable, callable) pairs The (preprocessor, postprocessor) pairs of external optimization functions. Optionally 'basic' can be passed for a set of predefined basic optimizations. Such 'basic' optimizations were used by default in old implementation, however they can be really slow on larger expressions. Now, no pre or post optimizations are made by default. postprocess : a function which accepts the two return values of cse and returns the desired form of output from cse, e.g. if you want the replacements reversed the function might be the following lambda: lambda r, e: return reversed(r), e order : string, 'none' or 'canonical' The order by which Mul and Add arguments are processed. If set to 'canonical', arguments will be canonically ordered. If set to 'none', ordering will be faster but dependent on expressions hashes, thus machine dependent and variable. For large expressions where speed is a concern, use the setting order='none'. ignore : iterable of Symbols Substitutions containing any Symbol from ``ignore`` will be ignored. list : bool, (default True) Returns expression in list or else with same type as input (when False). 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 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) )r ra postprocessrrNbasiccg|]}t|qSr#)rdr%rCrar#r)r*Fryzcse..)clscrr#)rfrrr#r)r*[s)_cse_homogeneousrintfloatrrrrrr.rflatrrtodokrbasic_optimizationsrrrrrr,rfrr as_immutable)rr rarrrrScopytemprCrrrr&rsubtreerrrr#rr)csesnP          rc sttrttfi|\}}|t|fSttttfr1tfi|\}}|t |fStt rXt }tfdd|Dfi|\}}t t ||}||fSztfi|\}\}W||fSt yugfYSw)aM 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}) cr"r#r#)r%rrr#r)r*r+z$_cse_homogeneous..)rrXrrreprrStuplerTrtypedictrrR TypeError)rkwargsrrrvaluesr#r r)rrs* .   " r)r)Nrr#)NNNrr#T)sB         F ^ |