[^(hT ddlZddlZddlZddlZddlmZmZmZmZm Z m Z ddl m Z m Z ddlZddlmZddlmZddlmZddlmZddlmZmZmZdd lmZdd lmZmZdd lm Z dd l!m"Z"dd l#m$Z$ddl%m&Z&ddl'm(Z(erddl)m*Z*e deZ+e dZ,gdZ-dej&de.fdZ/dee e,ge+fdee e,ge e+ej`fffdZ1dee.dee.dee.fdZ2dejfdejfdejffd Z4Gd!d"ejjZ6Gd#d$ejjZ7Gd%d&ejjZ8Gd'd(ejjZ9Gd)d*ejjZ:Gd+d,e6Z;Gd-d.ejjZ<Gd/d0ejjZ=Gd1d2ejjZ>Gd3d4ejjZ?Gd5d6ejjZ@Gd7d8eeZAGd9d:eAeZBGd;dZEGd?d@ejjZFGdAdBejjZGGdCdDejjZHGdEdFejjZIGdGdHejjZJGdIdJejjZKGdKdLejjZLGdMdNejjZMGdOdPejjZNGdQdRejjZOGdSdTejjZPdUZQeQdVZReQdWZSeQdXZTeQdYZUeQdZZVeQd[ZWeQd\ZXeQd]ZYeQd^ZZeQd_Z[eQd`Z\eQdaZ]eQdbZ^eQdcZ_ddZ`e`dedfZae`dgdhZby)iN)CallableOptional SupportsFloat TYPE_CHECKINGTypeVarUnion) TypeVarTupleUnpack)Ssympify)Expr) Application)_torf fuzzy_andfuzzy_or) equal_valued) LatticeOp ShortCircuit)ordered)walk) PRECEDENCE)sift)int_oo)Iterable_T)bound_Ts)FloorDivModularIndexingWhere PythonModModCleanDiv CeilToInt FloorToIntCeilDiv IntTrueDiv FloatTrueDivLShiftRShift!IsNonOverlappingAndDenseIndicator TruncToFloat TruncToInt RoundToInt RoundDecimalToFloatFloatPow PowByNaturalIdentityexprreturnc|jxrnt|jdk(xrT|jdjxr9|jdjxr|jd|jduS)Nrr)is_Addlen_args is_symbol)r6s Z/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torch/utils/_sympy/functions.py_is_symbols_binary_summationr?Ysr  /  Oq  / JJqM # # / JJqM # # / JJqMA . fctjdttdtt t jfffd }|S)Nargsr7c|}td|Dr8t|tjstjt |}|S)Nc3PK|]}t|tj ywN) isinstancesympyFloat.0as r> z-_keep_float..inner..js8az!U[[)8$&)anyrGrHrIfloat)rCrrAs r>innerz_keep_float..innergsD$%tH 848 8 u{{B  E!H%Ar@) functoolswrapsr rrrrHrI)rArRs` r> _keep_floatrUdsF__QVC[U2u{{?%; Lr@xycd||fvry||k(SrF)rVrWs r>fuzzy_eqrZss 1v~ 6Mr@pqcdtjdtfddtjdtffd }tj||||}||z ||z }}t t tjjtjj|}tjj|}|D]tfd|Ds|z}|S)a Fast path for sympy.gcd, using a simple factoring strategy. We try to rewrite p and q in the form n*e*p1 + n*e*p2 and n*e*q0, where n is the greatest common integer factor and e is the largest syntactic common factor (i.e., common sub-expression) in p and q. Then the gcd returned is n*e, cancelling which we would be left with p1 + p2 and q0. Note that further factoring of p1 + p2 and q0 might be possible with sympy.factor (which uses domain-specific theories). E.g., we are unable to find that x*y + x + y + 1 is divisible by x + 1. More generally, when q is of the form q1 + q2 (instead of being already factored) it might be necessary to fall back on sympy.gcd. rVr7ctjj|Dcgc]6}t|ttj frt t |8}}tj|Scc}wrF) rHMul make_argsrGintIntegerabsmathprod)rVarginteger_coefficientss r>integer_coefficientz0simple_floordiv_gcd..integer_coefficientscyy**1-+ #U]]34 CM+ + yy-.. + s;A4r6cttjj|}t j t j|SrF)maprHAddr`rSreducerdgcd)r6integer_factorsrhs r>integer_factorz+simple_floordiv_gcd..integer_factors:), !4!4T!:* /::r@c3&K|]}|v ywrFrY)rK base_splitrVs r>rMz&simple_floordiv_gcd..s=:qJ=s) rHBasicrardrmlistrjr_r`rkall)r[r\rorm base_splits divisor_splitrhrVs @@r>simple_floordiv_gcdrwys"/u{{/s/;U[[;S; xxq)>!+<=C s7AGqA15 EII  !4!4Q!782K.3YY-@-@-CM  == ='C Jr@c <eZdZUdZdZeedfed<dZeed<dZ e ed<e d e jfd Ze d e jfd Zd e j j"d efd Zede j*de j*d ee jdffdZdZy)r a We maintain this so that: 1. We can use divisibility guards to simplify FloorDiv(a, b) to a / b. 2. Printing out the expression is nicer (compared to say, representing a//b as (a - a % b) / b) NB: This is Python-style floor division, round to -Inf r9.nargs# precedenceT is_integerr7c |jdSNrrCselfs r>basez FloorDiv.baseyy|r@c |jdSNrrrs r>divisorzFloorDiv.divisorrr@printerc|j|jtddz }|j|jtddz }d|d|dS)NAtom?(z//) parenthesizerrrrrrrs r> _sympystrzFloorDiv._sympystrsW##DIIz&/AC/GH&&t||Z5G#5MN4&7)1%%r@rrNcV|jr td|tt tjtj fvr>|tt tjtj fvrtj S|tj us|tj urtj S|jrtj jS|jrt|dr|S|jr"t|drtj|dSt|tjrt|tjr|tt tjtj fvs.|tt tjtj fvrt|t|z }|tjk(rtS|tj k(rt Stj |rtj Stj"tj$|St|tj"rDt|tj"r*tj"t'|t'|zSt|t(r)t)|j*d|j*d|zSt|tj"rd}g}tj,j/|D]*}||z }|js|j1|||z },t3|dk7r%t)|tj,|ddiz ||zS t5||}t|dr0t|tj,rtj6||}t|ds8t)tj8||z tj8||z S y#tj:$rYywxYw)Ndivision by zerorrevaluateF)is_zeroZeroDivisionErrorrrHoonanr Zeror}rr_rGNumberrPrdinfisnanrbfloorrar rCrkr`appendr;rwrmsimplifyPolynomialError) clsrrrQ quotientstermstermquotientrms r>evalz FloorDiv.evals ??#$67 7 FVGUXXy9 9g  G HH XXI J ? 99  599 599 499  <<77<<  ??|GQ7K ??|GR899T2& & tU\\ *7ELL1&%((UXXI>>vw588)DDd eGn,ADHH} txxiwAyy }}TZZ]33 dEMM *z'5==/Q==Tc'l!:; ; dH %DIIaL$))A,*@A A gu}} -IE ++D1 *'>&&LL&)I  *5zQTEIIu$Eu$EEwO  %dG4CC# 7EII(Fiig.Q'NN4#:.w}0M($$   sB PP('P(c|j|jtddz }|j|jtddz }d|d|dS)Nrrzfloor(/rrrs r>_ccodezFloorDiv._ccode&sW##DIIz&/AC/GH&&t||Z5G#5MNvQwiq))r@)__name__ __module__ __qualname____doc__rztuplera__annotations__r|r}boolpropertyrHrrrrprinting StrPrinterstrr classmethodrbrrrrYr@r>r r s"E5c?!JJ ekk&!:!:&s&P==P+0==P u{{D !PPd*r@r c eZdZUdZdZeedfed<dZe ed<dZ eed<e d e jd e jd e jd ee jfd Zd ee fdZd ee fdZy)r!zK ModularIndexing(a, b, c) => (a // b) % c where % is the C modulus .rzTr}r{r|rrmodulusr7cr|dk(s|dk(rtjjSt|tjrrzModularIndexing.eval5s 191 77<<  tU]] +7EMM27EMM2GOw. . !|iig.!8*tcz2w}5 dEII &-/I!%L  /99T7W#4579JJ"47D1H"43&tyy|U]]C IIaL1, (- !((. / 9~TYY/L&s9~wHH dH %"499Q<11GQ Q9$$   s_eval_is_nonnegativez$ModularIndexing._eval_is_nonnegativejs.yy!}1((!*:*:;;r@cf|jdd\}}t|j|jSr)rCrZ is_positivers r>_eval_is_positivez!ModularIndexing._eval_is_positivens*yy!}1 q}}55r@N)rrrrrzrrarr}rr|rrHrbrrrrrrrYr@r>r!r!,s"E5c?!JJ2==2+0==2CH==2 %++ 22h6r@r!c eZdZUdZdZeedfed<dZeed<de e fdZ de e fd Z de e fd Z ed ej d ej d ej de ej fdZy)r"z# Good ol' ternary operator r.rzr{r|r7cn|jdjr|jdjrdSdSNrr9TrCr}rs r>_eval_is_integerzWhere._eval_is_integer{s.yy|..499Q<3J3JtTPTTr@cn|jdjr|jdjrdSdSr)rCrrs r>rzWhere._eval_is_nonnegative~s9yy|**tyy|/J/J   r@cn|jdjr|jdjrdSdSrrCrrs r>rzWhere._eval_is_positives.yy|//DIIaL4L4LtVRVVr@cr[r\cX|tjk(r|S|tjk(r|SyrF)rHtruefalse)rrr[r\s r>rz Where.evals(  ?H %++ Hr@N)rrrrrzrrarr|rrrrrrrHrrrrYr@r>r"r"ss"E5c?!JU(4.U htn W8D>W  % 05  %++ r@r"ceZdZUdZeedfed<dZeed<dZe ed<e de jd e jd e e jfd Zd e e fd Zd e e fd Zy)r#ry.rzr{r|Tr}r[r\r7cB|jr td|tjus ||| fvs|dk(rtjS|jr|jr||zS|jr=|dk(r8|j rtjS|j rtjS||z }|jrtjS||k}|jrt|r|jr|Stj||dk(rtjSy)NModulo by zerorr9r)rrr r is_Numberis_evenis_oddOner} is_BooleanrrrHr$rr[r\rQlesss r>rzPythonMod.evals 99#$45 5 ;!A2w,!q&66M ;;1;;q5L ;;16yyvv xxuu  E <<66M 1u ??tDzammH 99Q?a 66Mr@c<|jdjrdSdSNrTrrs r>rzPythonMod._eval_is_nonnegativeyy|//t9T9r@c<|jdjrdSdSr)rC is_negativers r>_eval_is_nonpositivezPythonMod._eval_is_nonpositiverr@N)rrrrzrrarr|r}rrrHrrrrrrYr@r>r#r#s!E5c?!JJ*UZZ*EJJ*8EJJ3G**Z:htn::htn:r@r#c8eZdZUdZdZeed<dZdZe dZ y)r$ryr{r|Tc$|jr td|tjus ||| fvs|dk(rtjS|jr)|jr|dk\sJ||dk\sJ|||zS|jr=|dk(r8|j rtjS|j rtjS||z }|jrtjS||k}|jrt|r|jr|Syyy)Nrrrr9) rrr rrrrrr}rrrrs r>rzMod.evals 99#$45 5 ;!A2w,!q&66M ;;1;;6 1 66 1 6q5L ;;16yyvv xxuu  E <<66M 1u ??tDzammH/r$r$s- EJJN))r@r$ceZdZdZy)r%zZ Div where we can assume no rounding. This is to enable future optimizations. N)rrrrrYr@r>r%r%sr@r%c eZdZdZedZy)r&Tc|tjtfvrtS|tj t fvrt St|tjr1tj t jt|SyrF) rHrrrGrrbrdceilrPrnumbers r>rzCeilToInt.evalse ehh' 'M uxxi&) )7N fell +==5=!9: : ,r@Nrrrr}rrrYr@r>r&r& sJ;;r@r&c eZdZdZedZy)r'TcN|tjtfvrtS|tj tfvrt St|tjr|St|tj r1tjt jt|SyrF) rHrrrGrbrrdrrPrs r>rzFloorToInt.evalst ehh' 'M uxxi( (7N femm ,M fell +==E&M!:; ; ,r@NrrYr@r>r'r'sJ<__new__zCeilDiv.__new__1sT}}T"--( 99T7 #w .D'* *DGaK0': :r@N)rrrrr}rrYr@r>r(r(*sJ;r@r(c eZdZdZedZy)r+Tc2|dkr td|d|zzSNrznegative shift countr9) ValueErrorrrshifts r>rz LShift.eval=s# 1934 4ahr@NrrYr@r>r+r+:sJr@r+c eZdZdZedZy)r,Tc@|dkr tdt|d|zSr)rr rs r>rz RShift.evalGs& 1934 4ah''r@NrrYr@r>r,r,DsJ((r@r,ceZdZdZedeeejjjfdZ e d$deeejjjdeeejjjfdZ edZ edZed Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%d Z&d!Z'd"Z(d#Z)y)% MinMaxBasec&ddlm}|jd|j}d|D}|sdn|j |}|rC t |j |}|&|j|fi|}|j|fi|}t |}|s |jSt|dk(rt|jStj|gt!|i|}||_||_|S#t$r|jcYSwxYw)Nr)global_parametersrc32K|]}t|ywrFr )rKrfs r>rMz%MinMaxBase.__new__..Ss6 6sr)sympy.core.parametersrpopr"_satisfy_unique_summations_symbols frozenset_new_args_filterrzero_collapse_arguments_find_localzerosidentityr;rsrrr_argsetunique_summations_symbols)r original_args assumptionsrrrCr objs r>rzMinMaxBase.__new__Os;??:/@/I/IJ6 6  77 F "  !!5!5d!;< )0.s..tC{C,s++D@K@<<  t9>:>># #ll3>>+> (A% 3  xx sC88DDr7c*t|dk7ryt|dtr |d|dfn |d|df\}}t|syt|r|j |St|tr"t |dd}||j |g|Sy)a One common case in some models is building expressions of the form max(max(max(a+b...), c+d), e+f) which is simplified to max(a+b, c+d, e+f, ...). For such expressions, we call the Max constructor X times (once for each nested max) and the expression gets flattened. An expensive cost in constructing those expressions is running _collapse_arguments and _find_localzeros. However, those two optimizations are unnecessary when the args to max are all of the form a+b, c+d, ..etc where each term uses a unique set of symbols. This function is used to detect such properties of the expressions we are building and if so inform that we do not need to run those optimizations. To detect those, we store a property in the expression that tells that this expression is a min/max operation over terms that use unique symbols "unique_summations_symbols". This property also memoize the set of symbols used in all the terms to make it faster to detect this property inductively. When we apply max to add a new term, all we need to do is check if the new term uses unique symbols (with respect to existing terms and itself). Example: t = Max(a+b, c+d) ==> satisfies the property Max(t, h+j) ==> h,j not in [a,b,c,d] => satisfy the property. The function returns None if the new expression does not satisfy the unique_summations_symbols property. Otherwise, it returns a new set of unique symbols. r9Nrrr )r;rGrr?_unique_symbolsgetattr)rrClhsrhslhs_unique_summations_symbolss r>rz-MinMaxBase._satisfy_unique_summations_symbols|s< t9>$q':.!Wd1g q'47# c ,C0 ( ,&&t, , c: &,30$- )-8**C52OPPr@N initial_setc| tn|}|D]`}|jD]K}t|tjj j sy||vry|j|Mb|S)z Return seen_symbols if all atoms in all args are all unique symbols, else returns None. initial_set can be used to represent initial value for seen_symbols N)setatomsrGrHcoresymbolSymboladd)rrCr seen_symbolsrfelements r>rzMinMaxBase._unique_symbolsst!, 3su  .C99; .!'5::+<+<+C+CD , $$W-  . .r@c |s|Stt|}turtnt|djrggfx}\}}|D]X}t |ttD]>}|j djs|t|tj|@Ztj}|D])}|j d}|js||kdk(s(|}+tj} |D])}|j d}|js|| kDdk(s(|} +tur!|D]} | jsn7| |kdk(s| }n)tk(r |D]} | jsn | | kDdk(s| } d} tur|tjk7r$t|} n| tjk7rt| } | `tt|D]I}||} t| s| j d} tk(r| | kDn| | kdk(s;j||<Kfdt|D](\}} ||dzdDcgc] }||  c}||dzd*fd}t|dkDr||}|Scc}w)a}Remove redundant args. Examples ======== >>> from sympy import Min, Max >>> from sympy.abc import a, b, c, d, e Any arg in parent that appears in any parent-like function in any of the flat args of parent can be removed from that sub-arg: >>> Min(a, Max(b, Min(a, c, d))) Min(a, Max(b, Min(c, d))) If the arg of parent appears in an opposite-than parent function in any of the flat args of parent that function can be replaced with the arg: >>> Min(a, Max(b, Min(c, d, Max(a, e)))) Min(a, Max(b, Min(a, c, d))) rTNc Tt|ttfs|S||jv}|s1|j|jDcgc] }|| c}ddiSt|r7|j|jDcgc]}||k7s ||c}ddiS|Scc}wcc}w)NrF)rGMinMaxrCfunc)airLcondirdos r>r%z*MinMaxBase._collapse_arguments..dosb3*- zGMinMaxBase._collapse_arguments..factor_minmax..3s:c5#9r@T)binaryrF)rrrC intersectionrsrtr)rCis_other other_argsremaining_argsrfarg_setscommonnew_other_argsarg_set arg_sets_diffsother_args_diffother_args_factoredrr(s r> factor_minmaxz5MinMaxBase._collapse_arguments..factor_minmax2s9H)-dHT)J &J 2<<#CHH rzMinMaxBase._collapse_argumentss0KGDM" #:EE 7  "$b& (FZT4 =ac*=Avvay..z!S1299!<= =LLE FF1I;;AI$#6E ,,C FF1I;;AG#4C cz$C==e , # $ "C==c d*! " AczCLL(EA $}s4y)3AQA!!U+VVAY(- R!V26!"'*llDG3 dO @DAq15a!eg?2RAY?DQM @ :0 t9q= &D I@s9I2c#LK|D]}t|tr&|jdus|jr|jst d|d||j k(r t|||jk(rr|j|k(r|jEd{|y7 w)z Generator filtering args. first standard filter, for cls.zero and cls.identity. Also reshape ``Max(a, Max(b, c))`` to ``Max(a, b, c)``, and check arguments for comparability FzThe argument 'z' is not comparable.N) rGris_extended_realr8r9rrrrr!rC)r arg_sequencerfs r>rzMinMaxBase._new_args_filterOs  CsD)''50MM#*;*; >#6J!KLLchh"3'' $S88## ! $sBB$B" B$c t}d}|D]\}|jr=||}|tur t||})|tur t ||}>t d||j|^||St|dk(r|hSt|dk(rOtt|}|dvr|jr |tur|S|hS|dk(r|jr |tur|S|hS|j||S)a Sequentially allocate values to localzeros. When a value is identified as being more extreme than another member it replaces that member; if this is never true, then the value is simply appended to the localzeros. Unlike the sympy implementation, we only look for zero and one, we don't do generic is connected test pairwise which is slow Nz impossible rr)gr) rrr maxrminAssertionErrorrr;nextiterrr)rvaluesoptions other_values num_valuerf other_values r>rzMinMaxBase._find_localzerosjsu   &C}}$ #Icz$' 3$7 $' 3$7 ,{3%-@AA  % &    |  !;  |  !tL12KH$)C)C'*cz|B {BA~+"9"9'*cz|B {B#r@c:td|jDS)Nc34K|]}|jywrF) is_algebraicrKr$s r>rMz&MinMaxBase...(HA(HrrCr4s r>r)zMinMaxBase.5(H(H#Hr@c:td|jDS)Nc34K|]}|jywrF)is_antihermitianrUs r>rMz&MinMaxBase...- -rWrXrYs r>r)zMinMaxBase.u-$%FF-(r@c:td|jDS)Nc34K|]}|jywrF)is_commutativerUs r>rMz&MinMaxBase...++rWrXrYs r>r)zMinMaxBase.U+"#&&+&r@c:td|jDS)Nc34K|]}|jywrF) is_complexrUs r>rMz&MinMaxBase...&Dq||&DrWrXrYs r>r)zMinMaxBase.&DQVV&D!Dr@c:td|jDS)Nc34K|]}|jywrF) is_compositerUs r>rMz&MinMaxBase...rVrWrXrYs r>r)zMinMaxBase.rZr@c:td|jDS)Nc34K|]}|jywrF)rrUs r>rMz&MinMaxBase...#>!AII#>rWrXrYs r>r)zMinMaxBase.e#>qvv#>>r@c:td|jDS)Nc34K|]}|jywrF) is_finiterUs r>rMz&MinMaxBase...s%Baakk%BrWrXrYs r>r)zMinMaxBase.s%B166%B Br@c:td|jDS)Nc34K|]}|jywrF) is_hermitianrUs r>rMz&MinMaxBase...rVrWrXrYs r>r)zMinMaxBase.rZr@c:td|jDS)Nc34K|]}|jywrF) is_imaginaryrUs r>rMz&MinMaxBase...rVrWrXrYs r>r)zMinMaxBase.rZr@c:td|jDS)Nc34K|]}|jywrF) is_infiniterUs r>rMz&MinMaxBase...'F! 'FrWrXrYs r>r)zMinMaxBase.%'Fqvv'F"Fr@c:td|jDS)Nc34K|]}|jywrF)r}rUs r>rMz&MinMaxBase...rhrWrXrYs r>r)zMinMaxBase.rir@c:td|jDS)Nc34K|]}|jywrF) is_irrationalrUs r>rMz&MinMaxBase...)Ja!//)JrWrXrYs r>r)zMinMaxBase.E)J166)J$Jr@c:td|jDS)Nc34K|]}|jywrFrrUs r>rMz&MinMaxBase...r}rWrXrYs r>r)zMinMaxBase.r~r@c:td|jDS)Nc34K|]}|jywrF) is_nonintegerrUs r>rMz&MinMaxBase...rrWrXrYs r>r)zMinMaxBase.rr@c:td|jDS)Nc34K|]}|jywrFrrUs r>rMz&MinMaxBase...rcrWrXrYs r>r)zMinMaxBase.rdr@c:td|jDS)Nc34K|]}|jywrF)is_nonpositiverUs r>rMz&MinMaxBase...rcrWrXrYs r>r)zMinMaxBase.rdr@c:td|jDS)Nc34K|]}|jywrF) is_nonzerorUs r>rMz&MinMaxBase...rhrWrXrYs r>r)zMinMaxBase.rir@c:td|jDS)Nc34K|]}|jywrF)rrUs r>rMz&MinMaxBase...s"<188"r)zMinMaxBase.sU"rMz&MinMaxBase...$@AQZZ$@rWrXrYs r>r)zMinMaxBase.u$@$@@r@c:td|jDS)Nc34K|]}|jywrFrrUs r>rMz&MinMaxBase...r}rWrXrYs r>r)zMinMaxBase.r~r@c:td|jDS)Nc34K|]}|jywrF)is_primerUs r>rMz&MinMaxBase...rrWrXrYs r>r)zMinMaxBase.rr@c:td|jDS)Nc34K|]}|jywrF) is_rationalrUs r>rMz&MinMaxBase...r}rWrXrYs r>r)zMinMaxBase.r~r@c:td|jDS)Nc34K|]}|jywrF)is_realrUs r>rMz&MinMaxBase...rorWrXrYs r>r)zMinMaxBase.rpr@c:td|jDS)Nc34K|]}|jywrF)rErUs r>rMz&MinMaxBase...r^rWrXrYs r>r)zMinMaxBase.r_r@c:td|jDS)Nc34K|]}|jywrF)is_transcendentalrUs r>rMz&MinMaxBase...s. !.rWrXrYs r>r)zMinMaxBase.s.%&VV.)r@c:td|jDS)Nc34K|]}|jywrF)rrUs r>rMz&MinMaxBase...rorWrXrYs r>r)zMinMaxBase.rpr@rF)*rrrrrrrrHrrrrrrrr_eval_is_algebraic_eval_is_antihermitian_eval_is_commutative_eval_is_complex_eval_is_composite _eval_is_even_eval_is_finite_eval_is_hermitian_eval_is_imaginary_eval_is_infiniter_eval_is_irrational_eval_is_negative_eval_is_nonintegerrr_eval_is_nonzero _eval_is_odd_eval_is_polarr_eval_is_prime_eval_is_rational _eval_is_real_eval_is_extended_real_eval_is_transcendental _eval_is_zerorYr@r>rrNs+Z5 #ejj''../ 055nJN (UZZ->->-E-E)F G #ejj''../ 0$EEN4,,\IEH>MBOHHFDJFJEM?Mr@rcReZdZdZej ZejZdZ dZ dZ y)r z= Return, if possible, the maximum value of the list. c:td|jDS)Nc34K|]}|jywrFrrJs r>rMz(Max._eval_is_positive..9! 9rWrrCrs r>rzMax._eval_is_positive9tyy999r@c:td|jDS)Nc34K|]}|jywrFrrJs r>rMz+Max._eval_is_nonnegative..srzMax._eval_is_nonnegatives<$))<<rMz(Max._eval_is_negative..:1:rWrrCrs r>rzMax._eval_is_negative: :::r@N) rrrrr InfinityrNegativeInfinityrrrrrYr@r>r r s, ::D!!H:=;r@r cReZdZdZej ZejZdZ dZ dZ y)rz= Return, if possible, the minimum value of the list. c:td|jDS)Nc34K|]}|jywrFrrJs r>rMz(Min._eval_is_positive..rrWrrs r>rzMin._eval_is_positiverr@c:td|jDS)Nc34K|]}|jywrFrrJs r>rMz+Min._eval_is_nonnegative..s=a))=rWrrs r>rzMin._eval_is_nonnegatives=499===r@c:td|jDS)Nc34K|]}|jywrFrrJs r>rMz(Min._eval_is_negative..rrWrrs r>rzMin._eval_is_negativerr@N) rrrrr rrrrrrrrYr@r>rrs,  DzzH;>:r@rcLd}|dkr| }|dzdk(rdnd}|t||zS)Nrrr9r) _safe_pow)rexpsigns r>safe_powrs8 D axu!GqLqb )D#& &&r@c|dkr td|dk(ryt||dz}|turtS||z}|tjkDrtS|dzdk(r||z}|tjkDrtS|S)NrzExponent must be non-negative.rr9)rrrsysmaxsize)rexponenthalf_expresults r>rrs!|9::1}h!m,H6  F   !|q$ CKK M Mr@c0eZdZUdZdZeed<edZy)r4T2r|ct|tjrLt|tjr2t||}|t tfvr|Stj|St|tjrtj ||S|ttj fvr/|jrtS|jrtjSyyrF) rGrHrbrrPowrrrzoo)rrrrQs r>rzPowByNatural.eval s dEMM *z#u}}/Ms#AfWf%%==# # c5== )99T3' ' 6588$ $"" !!yy " %r@N) rrrr}r|rarrrrYr@r>r4r4s#JJ!!r@r4c0eZdZUdZdZeed<edZy)r3T<r|ct|tjrEt|tjr*tjt |t |zSyyrF)rGrHrrIrP)rrrs r>rz FloatPow.eval(sD dELL )jell.K;;uT{eCj89 9/L )r@N rrrrr|rarrrrYr@r>r3r3#s#GJ::r@r3c0eZdZUdZdZeed<edZy)r*Tr{r|c|jr tdt|tjrEt|tjr*tj t |t |z SyyNr)rrrGrHrrIrPrs r>rzFloatTrueDiv.eval>sW ??#$67 7 dELL )j%,,.O;;uT{U7^;< </P )r@NrrYr@r>r*r*9s#GJ==r@r*c0eZdZUdZdZeed<edZy)r)Tr{r|cd|jr tdt|tjrt|tjr|t t tj tj fvs.|t t tj tj fvr*tjt|t|z St|tjrEt|tjr*tjt|t|z Syyr) rrrGrHrrrrIrPrbrars r>rzIntTrueDiv.evalWs ??#$67 7 tU\\ *7ELL1&%((UXXI>>vw588)DD ;;uT{U7^;< < dEMM *z'5==/Q;;s4y3w<78 80R *r@NrrYr@r>r)r)Rs#GJ99r@r)c eZdZdZedZy)r-Tc t|dzdk(sJt|dz}|d|}||d}ddlm}td|Dr7||Dcgc] }t |c}|Dcgc] }t |c}S|dk(r0|dj r |ddk(ry|dj r |ddkrytd|Dr|dk7sJt tt ||tjd\}}td|dd Dr?|dd d z}||Dcgc] }t |c}|Dcgc] }t |c}Sycc}wcc}wcc}wcc}w) Nr9r)!eval_is_non_overlapping_and_densec3PK|]}t|tj ywrFrGrHrbrJs r>rMz9IsNonOverlappingAndDenseIndicator.eval..s:z!U]]+:rNrc3PK|]}t|tj ywrFrrJs r>rMz9IsNonOverlappingAndDenseIndicator.eval..s=z!U]]+=rN)keyc3PK|]}t|tj ywrFrrJs r>rMz9IsNonOverlappingAndDenseIndicator.eval..sFA:a/FrNr)*) r;%torch.fx.experimental.symbolic_shapesrrtrarzipsortedoperator itemgetter) rrCdimsizesstridesrrLs_sizes s_stridess r>rz&IsNonOverlappingAndDenseIndicator.evaltst4y1}!!!$i1nQs st*  :T: :4!&'AQ'')BQ#a&)B  !8qz## aQx!!eAhl =W= =!8O8"%E7+1D1DQ1GH" GYF"FF!#2,.9%,-SV- /J1A/JG()B@./Js E"E E7E NrrYr@r>r-r-qsJ00r@r-c eZdZdZedZy)r.Tct|tjr1tjt j t |SyrF)rGrHrrIrdtruncrPrs r>rzTruncToFloat.evals5 fell +;;tzz%-89 9 ,r@NrrrrrrrYr@r>r.r.sG::r@r.c eZdZdZedZy)r/Tc|tjtfvrtS|tj t fvrt St|tjr1tj t jt|SyrF) rHrrrGrrbrdr rPrs r>rzTruncToInt.evalse ehh' 'M uxxi&) )7N fell +==E&M!:; ; ,r@NrrYr@r>r/r/sJ<rzRoundToInt.evalsW UXX M ehhY 7N fell +==uV}a!89 9 ,r@NrrYr@r>r0r0sJ::r@r0c eZdZdZedZy)r1Tct|tjrLt|tjr1tjt t |t|SyyrF)rGrHrrbrIrrPra)rrndigitss r>rzRoundDecimal.evalsF fell + 7EMM0R;;uU6]CLAB B1S +r@Nr rYr@r>r1r1sGCCr@r1c eZdZdZedZy)r2Tc"|tjtj fvr|St|tjrtjt |S|t urtjS|t urtj SyrF)rHrrGrbrIrarrs r>rz ToFloat.evalsk ehh * *M femm ,;;s6{+ + V 88O fW HH9  r@Nr rYr@r>r2r2sG  r@r2c,eZdZdZdZdZdZdZdZy)r5z4 Prevents expansion and other optimizations c(d|jddS)Nz Identity(rrrrs r>__repr__zIdentity.__repr__s499Q<.**r@c4|jdjSr)rCrrs r>rzIdentity._eval_is_realsyy|###r@c4|jdjSrrrs r>rzIdentity._eval_is_integer syy|&&&r@c |jdSrr)rhintss r>_eval_expand_identityzIdentity._eval_expand_identityrr@N) rrrrr|rrrrrYr@r>r5r5s"J+$'r@r5cdGfddtj}dz}||_||_|S)Nc,eZdZdZWZefdZy)+make_opaque_unary_fn..OpaqueUnaryFna Unlike the builtin sympy functions on real numbers like sympy.sqrt, these equivalents do not do any nontrivial reasoning besides constant propagation. This helps avoid performing transformations that are valid for real numbers but are invalid for floating point; in particular, while we are willing to make optimizations that change numerics for Tensor compute, we are NOT willing to make optimziations that change numerics for size compute. cjt|tjtjfr3 tjt t t |S|tjtj tjtj tt fvrc|turtj}|t urtj }dk(rtj|dSt t|Sy#t$rt t|cYSwxYw)Nlog2r9) rGrHrbrIrrdrP OverflowErrorrrrlog)rrLnames r>rz0make_opaque_unary_fn..OpaqueUnaryFn.eval!s!emmU[[9: 3 ;;':wtT':58'DEE uxx%((EII z6F7SS;A< A6> 99Q?*+wud+A..%3/75$/223s1DD21D2N)rrrr_torch_handler_namerr)r%sr> OpaqueUnaryFnr s" #    r@r'OpaqueUnaryFn_)rHFunctionrr)r%r'nms` r>make_opaque_unary_fnr+s6##J D BM!#M r@sqrtcoscoshsinsinhtantanhasinacosatanrr$asinhr"cdk(r tdndk(r tdntdGfddtj}dz|_|S) N bitwise_and BitwiseAnd bitwise_or BitwiseOrz unrecognized c:eZdZUWZWZeed<efdZy))make_opaque_bitwise_fn..BitwiseFnr|c|jr#|jrtt||S|jrtj|rdnd}|jrtj|rdnd}t |tjt fr\t |tjt frrz.make_opaque_bitwise_fn..BitwiseFn.eval]s|| 6wx6q!<<||MMq!a0||MMq!a0!emmS12zEMM3'8}}%DWX|%DSVSQRV%TUUr@N) rrrr&r|rarrr)r%precr@sr> BitwiseFnr=Ys%" C    r@rB BitwiseFn_)rrJrHr)r)r%r@rBrAs`` @r>make_opaque_bitwise_fnrDQsc },'  +&}TF344ENN$&,I r@r8and_r:or_)crSrdrrtypingrrrrrrtyping_extensionsr r rHr sympy.corer sympy.core.exprrsympy.core.functionrsympy.core.logicrrrsympy.core.numbersrsympy.core.operationsrrsympy.core.sortingrsympy.core.traversalrsympy.printing.precedencersympy.utilities.iterablesrnumbersrcollections.abcrrr__all__rr?rIrUrZrrrwr)r r!r"r#r$r%r&r'r(r+r,rr rrrr4r3r*r)r-r.r/r0r1r2r5r+OpaqueUnaryFn_sqrtOpaqueUnaryFn_cosOpaqueUnaryFn_coshOpaqueUnaryFn_sinOpaqueUnaryFn_sinhOpaqueUnaryFn_tanOpaqueUnaryFn_tanhOpaqueUnaryFn_asinOpaqueUnaryFn_acosOpaqueUnaryFn_atanOpaqueUnaryFn_expOpaqueUnaryFn_logOpaqueUnaryFn_asinhOpaqueUnaryFn_log2rDBitwiseFn_bitwise_andBitwiseFn_bitwise_orrYr@r>rfst  SS2  +77+9&%0*( T'5B 4uzzd  r!"  vc{mU2u{{?334 8D>htn )5;;)5;;)5;;)|r*u~~r*jD6ennD6NENNB8:8:x1%..1hx ; ; < < ;enn ; U^^(U^^(p?yp?f ;*k;$:*k:$'4!5>>!6 :u~~ :,=5>>=299>44p :5>> : < < : :<C5>>C enn  u~~**\*&1(/)&1(/)&1(/)&1)&1)&1)&1(/(/*73)&1</}fE-lEBr@