\hA- SrSSKJr SSKJr SSKJr SSKJr SSK J r J r SSK J r Jr SSKJrJrJr SS KJrJr SS KJrJrJrJr SS KJr SS KJr SS KJ r SSK!J"r"J#r# SSK$J%r%J&r& SSK'J(r( SSK)J*r* SSK+J,r, "SS5r-"SS\-5r.Sr/\."SS5r0\"SS/S9r1\"SS/S9r2\"S5r3\"S 5r4\"S!S"/S9r5\."\"\45\4- \"\455r6\."\"\5\4-5\4- \5\"\5\4-5-5r7\6\74r8\."\3\ "\45-\ "S#5- \3\"\45-S$S%9r9\."\ "S#5\"\45-\ "\455r:\."S&S'5r;"S(S)\.5r<\<"\ \5r=\<"\\%5r>\<"\ \&5r?\."S*S+5r@S,S-.S.jrAS/rBS0rC\."\B\C5rD\."\ "\ "\35\ "\45-5\""\3\455rE\."\ "\ "S#\35\ "S#\45-5\#"\3\45\ "S#5-5rF\=\@\0\9\:4rG\G\E\F4-\8-rH\>\?4rIg1)2a Classes and functions useful for rewriting expressions for optimized code generation. Some languages (or standards thereof), e.g. C99, offer specialized math functions for better performance and/or precision. Using the ``optimize`` function in this module, together with a collection of rules (represented as instances of ``Optimization``), one can rewrite the expressions for this purpose:: >>> from sympy import Symbol, exp, log >>> from sympy.codegen.rewriting import optimize, optims_c99 >>> x = Symbol('x') >>> optimize(3*exp(2*x) - 3, optims_c99) 3*expm1(2*x) >>> optimize(exp(2*x) - 1 - exp(-33), optims_c99) expm1(2*x) - exp(-33) >>> optimize(log(3*x + 3), optims_c99) log1p(x) + log(3) >>> optimize(log(2*x + 3), optims_c99) log(2*x + 3) The ``optims_c99`` imported above is tuple containing the following instances (which may be imported from ``sympy.codegen.rewriting``): - ``expm1_opt`` - ``log1p_opt`` - ``exp2_opt`` - ``log2_opt`` - ``log2const_opt`` ) expand_log)S)Wild)sign)explog)MaxMin)cossinsinc)Qask)log1plog2exp2expm1) MatrixSolve)UnevaluatedExpr)Pow) logaddexp logaddexp2)cosm1powm1)Mul) MatrixSymbol)siftc(\rSrSrSrSSjrSrSrg) Optimization4zAbstract base class for rewriting optimization. Subclasses should implement ``__call__`` taking an expression as argument. Parameters ========== cost_function : callable returning number priority : number NcXlX lgN cost_functionpriority)selfr$r%s O/var/www/auris/envauris/lib/python3.13/site-packages/sympy/codegen/rewriting.py__init__Optimization.__init__@s * c([XRS9$)N)key)minr$)r&argss r'cheapestOptimization.cheapestDs4//00r*r#)N)__name__ __module__ __qualname____firstlineno____doc__r(r/__static_attributes__r*r'rr4s 1r*rc2^\rSrSrSrU4SjrSrSrU=r$) ReplaceOptimHa|Rewriting optimization calling replace on expressions. Explanation =========== The instance can be used as a function on expressions for which it will apply the ``replace`` method (see :meth:`sympy.core.basic.Basic.replace`). Parameters ========== query : First argument passed to replace. value : Second argument passed to replace. Examples ======== >>> from sympy import Symbol >>> from sympy.codegen.rewriting import ReplaceOptim >>> from sympy.codegen.cfunctions import exp2 >>> x = Symbol('x') >>> exp2_opt = ReplaceOptim(lambda p: p.is_Pow and p.base == 2, ... lambda p: exp2(p.exp)) >>> exp2_opt(2**x) exp2(x) c >>[TU]"S0UD6 XlX lg)Nr8)superr(queryvalue)r&r>r?kwargs __class__s r'r(ReplaceOptim.__init__hs "6"  r*cNURURUR5$r")replacer>r?)r&exprs r'__call__ReplaceOptim.__call__ms||DJJ 33r*)r>r?) r2r3r4r5r6r(rFr7 __classcell__rAs@r'r:r:Hs> 44r*r:c[USSS9H-nU"U5nURcUnMURX5nM/ U$)aApply optimizations to an expression. Parameters ========== expr : expression optimizations : iterable of ``Optimization`` instances The optimizations will be sorted with respect to ``priority`` (highest first). Examples ======== >>> from sympy import log, Symbol >>> from sympy.codegen.rewriting import optims_c99, optimize >>> x = Symbol('x') >>> optimize(log(x+3)/log(2) + log(x**2 + 1), optims_c99) log1p(x**2) + log2(x + 3) cUR$r")r%)opts r'optimize..ss||r*T)r,reverse)sortedr$r/)rE optimizationsoptimnew_exprs r'optimizerTqsH* +CTR;    &D>>$1D S Kr*cFUR=(a URS:H$)N)is_Powbaseps r'rMrMsahh&166Q;&r*c,[UR5$r")rrrYs r'rMrMs d155kr*dcUR$r")is_Dummyxs r'rMrMsQZZr*) propertiesucTUR(+=(a UR(+$r") is_numberis_Addr_s r'rMrMs_%EQXX%Er*vwncUR$r"rdr_s r'rMrMsQ[[r*rVc&URS5$)NcUR=(a URR=(d; [U[[ 45=(a UR SR(+$Nr)rWr is_negative isinstancerrr.rdes r'rM..sH &QUU&& D q3+ & Bqvvay/B/B+B Dr*)count)rEs r'rMrMsSWS]S]ETr*r$c[U[5=(au URSR=(aU [ URSR5S:H=(a) [ SURSR55$)NrrVc3B# UHn[U[5v M g7fr")ror).0ts r' ..sB>az!S))>s)rorr.relenallls r'rMrMsiz!S!C66!9##Cqvvay~~&!+CB166!9>>BBCr*c ,[URSRVs/sHoRSPM sn6[[[ URSRVs/sHoRSPM sn655-$s snfs snfrm)r r.rrr )r~rqs r'rMrMsi  0AffQi 01 c#166!9>>:>aq >:;<= > 0:s B &BcH^\rSrSrSrSU4SjjrSrSrU4SjrSr U=r $) FuncMinusOneOptima}Specialization of ReplaceOptim for functions evaluating "f(x) - 1". Explanation =========== Numerical functions which go toward one as x go toward zero is often best implemented by a dedicated function in order to avoid catastrophic cancellation. One such example is ``expm1(x)`` in the C standard library which evaluates ``exp(x) - 1``. Such functions preserves many more significant digits when its argument is much smaller than one, compared to subtracting one afterwards. Parameters ========== func : The function which is subtracted by one. func_m_1 : The specialized function evaluating ``func(x) - 1``. opportunistic : bool When ``True``, apply the transformation as long as the magnitude of the remaining number terms decreases. When ``False``, only apply the transformation if it completely eliminates the number term. Examples ======== >>> from sympy import symbols, exp >>> from sympy.codegen.rewriting import FuncMinusOneOptim >>> from sympy.codegen.cfunctions import expm1 >>> x, y = symbols('x y') >>> expm1_opt = FuncMinusOneOptim(exp, expm1) >>> expm1_opt(exp(x) + 2*exp(5*y) - 3) expm1(x) + 2*expm1(5*y) cr>^^Sm[TU]SURUU4SjS9 XlTUlX0lg)N cUR$r")rerps r'rM,FuncMinusOneOptim.__init__..s188r*cN>UR5TURT5-- $r") count_opsrs)rEfunc_m_1weights r'rMrs DNN4DvdjjYaNbGb4br*rt)r=r(replace_in_Addfuncr opportunistic)r&rrrrrAs ` @r'r(FuncMinusOneOptim.__init__s; +T-@-@'b  d   *r*ct^[URSSS9up#[U5n[UU4SjSS9upVXEU4$)NcUR$r"rjargs r'rM4FuncMinusOneOptim._group_Add_terms..scmmr*Tbinaryc:>URTR5$r")hasrrr&s r'rMrs377499;Mr*)rr.sum)r&addnumbersnon_numnumsumterms_with_funcothers` r'_group_Add_terms"FuncMinusOneOptim._group_Add_termss@*CDQW!%g/MVZ![--r*c^TRU5up#nUS:XaU$//peUGH2nUR(aF[URU4SjSS9up[ U5S:Xa[ U 5S:Xa USU SpO1Sn O.UR TR :XaU[ RpOSn U bU R(a[U 5[U5*:XakTR(a[X-5[U5:n OX-S:Hn U (a2X)- nURU TR"WR6-5 GM!URU5 GM5 UR "U/UQUQUQ76$)z0passed as second argument to Basic.replace(...) rc6>URTR:H$r")rrs r'rM2FuncMinusOneOptim.replace_in_Add..ssxx499?Tr*Trr1N)ris_Mulrr.r{rrOnerdrrabsappendr) r&rqrrother_non_num_terms substituted untouched with_funcrcoeff do_substitutes ` r'r FuncMinusOneOptim.replace_in_AddsA7;7L7LQ7O4!4 Q;H!#RY(I"9>>3T]ab t9>c%jAo"&q'58% E499,'e U__ef 9U%%$' $5F $CM$)LA$5M OF&&uT]]DII-F'FG   Y '-)0vvfM{MYM9LMMr*c~>[TU]U5n[TU]UR55nURX#5$r")r=rFfactorr/)r&rEalt1alt2rAs r'rFFuncMinusOneOptim.__call__ s6w%w .}}T((r*)rrr)T) r2r3r4r5r6r(rrrFr7rHrIs@r'rrs$$L+. N@))r*rc"[U[5$r")rorrps r'rMrMs jC r*c[UR[S55R[[S-5[ [55$)Nc4[UR55$r")rrrs r'rMrrsSZZ\*r*r1)rrDr_urr}s r'rMrMs7j *ws2a4y%)$%r*cUR$r") is_symbol)bs r'rMrMs r*)base_reqc*^^[UU4SjS5$)aCreates an instance of :class:`ReplaceOptim` for expanding ``Pow``. Explanation =========== The requirements for expansions are that the base needs to be a symbol and the exponent needs to be an Integer (and be less than or equal to ``limit``). Parameters ========== limit : int The highest power which is expanded into multiplication. base_req : function returning bool Requirement on base for expansion to happen, default is to return the ``is_symbol`` attribute of the base. Examples ======== >>> from sympy import Symbol, sin >>> from sympy.codegen.rewriting import create_expand_pow_optimization >>> x = Symbol('x') >>> expand_opt = create_expand_pow_optimization(3) >>> expand_opt(x**5 + x**3) x**5 + x*x*x >>> expand_opt(x**5 + x**3 + sin(x)**3) x**5 + sin(x)**3 + x*x*x >>> opt2 = create_expand_pow_optimization(3, base_req=lambda b: not b.is_Function) >>> opt2((x+1)**2 + sin(x)**2) sin(x)**2 + (x + 1)*(x + 1) c>UR=(aN T"UR5=(a5 URR=(a [ UR5T:*$r")rWrXr is_Integerr)rqrlimits r'rM0create_expand_pow_optimization..Bs<!((\x/\AEE4D4D\QUUW\I\\r*cURS:a-[[UR/UR7-SS065$S[[UR/UR*-SS065- $)NrevaluateFr1)rrrrXrYs r'rMrCsbHIPQ OC166(AEE6/CUC D G ocQVVHaeeVOEuEF F Gr*)r:)rrs``r'create_expand_pow_optimizationrsF \   r*cbUR(a[UR5S:XaURupUR(afURSS:XaSUR n[ U[5(a2[[[R"UR 555$g)NrVr1F) is_MatMulr{r. is_InverseshaperrorboolrrfullrankrEleftrightinv_args r'_matinv_predicaterIso ~~#dii.A-ii  ??u{{1~2hhG'<00C 488 4566 r*cLURupURn[X25$r")r.rrrs r'_matinv_transformrTs!))KDhhG w &&r*N)Jr6sympy.core.functionrsympy.core.singletonrsympy.core.symbolr$sympy.functions.elementary.complexesr&sympy.functions.elementary.exponentialrr(sympy.functions.elementary.miscellaneousr r (sympy.functions.elementary.trigonometricr r r sympy.assumptionsrrsympy.codegen.cfunctionsrrrrsympy.codegen.matrix_nodesrsympy.core.exprrsympy.core.powerrsympy.codegen.numpy_nodesrrsympy.codegen.scipy_nodesrrsympy.core.mulr"sympy.matrices.expressions.matexprrsympy.utilities.iterablesrrr:rTexp2_opt_dr_v_w_n sinc_opt1 sinc_opt2 sinc_optslog2_opt log2const_optlogsumexp_2terms_optr expm1_opt cosm1_opt powm1_opt log1p_optrrr matinv_opt logaddexp_optlogaddexp2_opt optims_c99 optims_numpy optims_scipyr8r*r'rs_@+""5=?EE$==2+ ;2;*11(&4<&4R< &   #/01 #EFG #Y #Y #012 GBJR   2JrM2d2b5k>   " 3r7 3q6)2d2h;G SVDH_c"g6 #D X) X)v c5 ) c5 ) c5 )  %  7L( V ' +-> ? SRR19R3DE c#a*SBZ"78*R:LSQRV:STHh F ]N<