o ei@@sUddlmZ ddlZddlZddlZddlZddlZddlZddlZddl Z ddlm Z m Z ddl m Z mZmZddlZddlmmZddlmZmZmZmZmZmZmZmZddlmZeriddlmZe e!Z"ej#e!dZ$e%Z&d e'd <e(e)Be*BdBZ+gd Z,dd l-m.Z/d dZ0GdddZ1GdddZ2Gddde2e*Z3idej4dej5dej6dej7dej7dej8dej9dej:dej;dej<dej=d ej>d!d"d#d$ej?d%ej@d&ejAd'ejBid(ejCd)ejDd*ejEd+ejFd,ejFd-ejGd.ejHd/ejHd0ejId1ejJd2ejKd3ed4ed5ed6ed7ed8ejLd9ejLiZMhd:ZNd;d<ZOd=ZPePD]&ZQd>eQZRd?eRZSeTe1eReOeQeUeeSeMeR<eN6eRe,VeRqBd!hZWeNeWBZXhd@ZYhdAZZdhZ[eYe[BZ\hdBZ]dd+hZ^dd+dCdDZ_hdEZ`ePD] ZQd>eQZRe`6eRqhdFZahdGZbdHdIZcdJdKZddLdMZedNdOZfdPdQZgdRdSZhdTdUZidVdWZjdXdYZkdZd[Zld\d]Zm ^dd_d`ZndadbZodcddZpdedfZqidej6d2ejKd(ejCd'efd/egd.ehdeideod+ejd,epd-eqd8ecd9eddeed%ekd1elZrdgdhZsdidjZtdkdlZudmdnZvdodpZwdqdrZxdsdtZydudvZzdwdxZ{dydzZ|d{d|Z}d}d~Z~ddZe je!ZddZePD]ZQdeQZeeQZee_e_!eTeeeq[[[Q[ddZdddZddZddZierid7ejdej4dewd)exd eyd&ezd$e{de|detdeud3edevd*ejEd6e}d5e~d4edeeedZePD]ZQd>eQZReUedeQeeR<q[Q[R[P[ddZddZddZddZddZddZddZddZeeeeeedZddZddZddZddZddZeD] \ZZeeeq#eD] \ZZeeeq2ddZeD]9ZeeYvrQeeeqCee]vr]eeeqCee[vsgeeZvrleeeeeeee_vr{eeeqC[[dS)) annotationsN) lru_cacheupdate_wrapper)Optional TYPE_CHECKINGUnion) sym_floatsym_itesym_maxsym_minsym_notSymBoolSymFloatSymInt)dtrace_structured)ShapeEnvsym_nodeobject_NO_HINT)SymNodemethod_to_operator magic_methods DynamicInt) py_sym_typescCs(|turtS|tur tS|turtS|SN)boolr intrfloatr)trh/var/www/addictedbytheproject.nl/epg/venv/lib/python3.10/site-packages/torch/fx/experimental/sym_node.py _to_symtypeAsr!c@s@eZdZUdZdZded<   dddd Zdd dZdddZdddZ e ddZ e ddZ ddZ dddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zdd:d;Zddd?Zddd@dAZ ddBdCZ!ddDdEZ"ddFdGZ#ddHdIZ$ddJdKZ%ddLdMZ&ddNdOZ'ddPdQZ(ddRdSZ)ddTdUZ*ddVdWZ+ddXdYZ,ddZd[Z-dd\d]Z.dd^d_Z/dd`daZ0ddbdcZ1ddddeZ2ddfdgZ3ddhdiZ4ddjdkZ5ddldmZ6ddndoZ7ddpdqZ8ddrdsZ9ddtduZ:ddvdwZ;ddxdyZdd~dZ?dddZ@dddZAdddZBdddZCdddZDddZEddZFddZGddZHddZIddZJdddZKddZLddZMddZNdddZOdddZPddZQddZRddZSddZTddZUddZVddZWddZXddZYddZZddZ[ddZ\dS)rz This is a type erased SymInt/SymFloat which we use to do actual operations. End users don't touch this. Magic methods are NOT defined on this object. Fr_optimized_summationNhint!Optional[Union[int, float, bool]]c s|_|_|_|_fdd}|turd}n>|durTt||us7t|t|us7td|dt|jrSjjrS|} || krSt|d| dj dn|}|_ |_ jocjj} | og|_ dS)NcsPddlm}|jr dSjjjdd}|dur&t|ts$|n|}|S)Nr)has_free_unbacked_symbolsT) compute_hint)%torch.fx.experimental.symbolic_shapesr%expr shape_env_maybe_evaluate_static isinstanceSymTypespytype)r%r#selfrr r&s  z&SymNode.__init__..compute_hintzCannot create SymNode of type z with incompatible hint of type z != z (for )) _exprr)r-r"rtyper!AssertionError_translation_validation_enabledr(_hintconstantfx_node) r/r(r)r-r#r6r7optimized_summationr& computed_hinttx_validation_enrr.r __init__]s6   zSymNode.__init__r)rreturncCst|j||j|j|j|jSr)rr1r-r5r6r7)r/r)rrr with_shape_envszSymNode.with_shape_envothercCs<|j|jko|j|jko|j|jko|j|jko|j|jkSr)r1r-r5r6r7r/r>rrr _value_eqs     zSymNode._value_eqrcCst|j|j|j|j|jfSr)hashr1r-r5r6r7r.rrr _value_hashszSymNode._value_hashcCs|j|jSr)r)replacer1r.rrr r(sz SymNode.exprcCs|jSrr5r.rrr r#sz SymNode.hintcCs |jduSrrDr.rrr has_hint zSymNode.has_hintcsfddlm}jdur0dur)|jfddjjD}tj|SjjSjS)Nrfree_unbacked_symbolscs&i|]}||vr njj|qSr)r)backed_var_to_val.0sfallbackr/unbacked_symbolsrr s z(SymNode.require_hint..) r'rHr5r( free_symbolsrxreplacer) size_hint)r/rNrH replacementsrrMr require_hints   zSymNode.require_hintcCs|jjr t|jSdSr)r( is_numberrr.rrr maybe_as_ints zSymNode.maybe_as_intcCs$ddl}t|j|jrt|jSdSNr)sympyr+r(Floatrr/rYrrr maybe_as_floats zSymNode.maybe_as_floatcCs,ddl}|j|jur dS|j|jurdSdS)NrTF)rYr(truefalser[rrr maybe_as_bools   zSymNode.maybe_as_boolcC |jtuSr)r-rr.rrr is_intrFzSymNode.is_intcCr`r)r-rr.rrr is_floatrFzSymNode.is_floatcCr`r)r-rr.rrr is_bool rFzSymNode.is_boolcCs"|jduot|jto|jjSr)r5r+rnode is_nested_intr.rrr re s   zSymNode.is_nested_intcCBt|turtdt|ddl}t|||jt|||dS)NExpected int, got rr6r7)r2rr3rYrIntegerr)r/numrYrrr wrap_int zSymNode.wrap_intcCrf)NzExpected float, got rrh)r2rr3rYrrZr)rjrrr wrap_floatrmzSymNode.wrap_floatcCsHt|turtdt|ddl}t|r|jn|j|jt|||dS)NzExpected bool, got rrh)r2rr3rYrr]r^r)rjrrr wrap_bool&s zSymNode.wrap_boolcC|Srrr.rrr clone4z SymNode.clonecCs|jSrr(r.rrr str7z SymNode.strcC|Srrtr.rrr __str__:ruzSymNode.__str__cCsd|jd|jd|jg}|jdur|d|j|jdur+|d|j|jdur9|d|jd|dS) NzSymNode(z , shape_env=z , pytype=zhint=z constant=zfx_node=z, r0)r1r)r-r5appendr6r7join)r/reprrr __repr__=s   zSymNode.__repr__ builtins.strcCrvrrwr.rrr _graph_reprIszSymNode._graph_reprcCrvr)_absr.rrr absOruz SymNode.abscCrvr)_posr.rrr posRruz SymNode.poscC ||Sr)_roundr/ndigitsrrr roundUrFz SymNode.roundcCrvr)_truncr.rrr truncXruz SymNode.trunccCrr)_addr?rrr add[rFz SymNode.addcCrr)_subr?rrr sub^rFz SymNode.subcCrr)_mulr?rrr mularFz SymNode.mulcCrr)_modr?rrr moddrFz SymNode.modcCrr) _float_powr?rrr float_powgrFzSymNode.float_powcCrr)_pow_by_naturalr?rrr pow_by_naturaljrFzSymNode.pow_by_naturalcCrr)_and_r?rrr and_mrFz SymNode.and_cCrr)_or_r?rrr or_prFz SymNode.or_cCrr)_float_truedivr?rrr float_truedivsrFzSymNode.float_truedivcCrr) _int_truedivr?rrr int_truedivvrFzSymNode.int_truedivcCrr) _int_floordivr?rrr int_floordivyrFzSymNode.int_floordivcCrr)_lshiftr?rrr lshift|rFzSymNode.lshiftcCrr)_rshiftr?rrr rshiftrFzSymNode.rshiftcCrvr)_sym_notr.rrr r ruzSymNode.sym_notcCrr)_eqr?rrr eqrFz SymNode.eqcCrr)_ner?rrr nerFz SymNode.necCrr)_gtr?rrr gtrFz SymNode.gtcCrr)_ltr?rrr ltrFz SymNode.ltcCrr)_ler?rrr lerFz SymNode.lecCrr)_ger?rrr gerFz SymNode.gecCrvr)_floorr.rrr floorruz SymNode.floorcCrvr) _is_integerr.rrr is_integerruzSymNode.is_integercCrvr) _sym_floatr.rrr rruzSymNode.sym_floatcCrvr)_sym_intr.rrr sym_intruzSymNode.sym_intcCrvr)_ceilr.rrr ceilruz SymNode.ceilcCrvr)_negr.rrr negruz SymNode.negcCrr)_sym_minr?rrr r rFzSymNode.sym_mincCrr)_sym_maxr?rrr r rFzSymNode.sym_maxcC |||Sr)_sym_ite)r/then_valelse_valrrr r  zSymNode.sym_itecCrr)_is_contiguousr/sizesstridesrrr is_contiguousrzSymNode.is_contiguouscCrr)_is_channels_last_contiguous_2drrrr is_channels_last_contiguous_2drz&SymNode.is_channels_last_contiguous_2dcCrr)_is_channels_last_contiguous_3drrrr is_channels_last_contiguous_3drz&SymNode.is_channels_last_contiguous_3dcCrr)_is_channels_last_strides_2drrrr is_channels_last_strides_2drz#SymNode.is_channels_last_strides_2dcCrr)_is_channels_last_strides_3drrrr is_channels_last_strides_3drz#SymNode.is_channels_last_strides_3dcCrr)'_is_non_overlapping_and_dense_indicatorrrrr &is_non_overlapping_and_dense_indicatorrz.SymNode.is_non_overlapping_and_dense_indicatorcCrr)rr?rrr sym_orrFzSymNode.sym_orcCrr)rr?rrr sym_andrFzSymNode.sym_andcCrr) _bitwise_andr?rrr bitwise_andrFzSymNode.bitwise_andcCrr) _bitwise_orr?rrr bitwise_orrFzSymNode.bitwise_orcCrr) _bitwise_xorr?rrr bitwise_xorrFzSymNode.bitwise_xorcCrr)rr?rrr truedivrFzSymNode.truedivcCrr)rr?rrr floordivrFzSymNode.floordivcCrr)rr?rrr powrFz SymNode.powcCs|||t|dS)N)rrto_noderrrr is_non_overlapping_and_denses z$SymNode.is_non_overlapping_and_densecC |ddSNr) guard_intr.rrr int_rz SymNode.int_c Csddl}ddlm}m}|r!t||tjtdd|DfiSdd|D}|j|}g}d}|D]} | j dur<n | | j q3t |}|j tjtdd|Df\} } t||j t|| dS) Nrget_proxy_modehandle_sym_dispatchcss|]}t|VqdSr wrap_noderKarrr sz"SymNode.sym_sum..cSg|]}|jqSrrsrrrr z#SymNode.sym_sum..css|]}|jVqdSrr7rrrr r sr)rY"torch.fx.experimental.proxy_tensorrrrtorchsym_sumtupleAddr#rysumr)_create_fx_call_functionrr) r/argsrYrrexprsout size_hintsout_hintrr7_rrr rs0  zSymNode.sym_sumcCs|j||Sr)r)evaluate_sym_node)r/size_obliviousrrr evaluatezSymNode.evaluatecC0|}zt|WStytd|w)NzFailed to convert to int: %s)rr Exceptionlogwarningr/filelinerrrr r   zSymNode.guard_intcCr)NzFailed to convert to float: %s)rrrrrrrrr guard_floatr zSymNode.guard_floatcCr)NFailed to convert to bool: %srrrrrrrrr guard_bool)r zSymNode.guard_boolcCsRddlm}|r||js|jjs|||S|jj|j|d||jdS)NrrG:r) r'rHrEr(r)+prefer_deferred_runtime_asserts_over_guardsrguard_or_defer_runtime_assertr7)r/rrrHrrr expect_true3s  zSymNode.expect_truecC(ddlm}|std|t|S)Nr)statically_known_trueExpected bool type)r'rrcr3r )r/rrrrrr rE  zSymNode.statically_known_truecCs4|jdd}zt|WStytd|w)aN Like guard_bool, but if we encounter unbacked symbols, if those symbols are size-like, we will treat them as >= 2 for the purposes of the analysis. This CHANGES the runtime semantics, but all size-oblivious sites have been audited to ensure that the runtime semantics don't change in a material way. Acceptable runtime semantic changes are, e.g., squeeze() no longer dropping an unbacked one size, or a tensor reporting as non-contiguous even if it's contiguous if it would have been reported contiguous due to being empty. T)rr r rrrr guard_size_obliviousLs    zSymNode.guard_size_obliviouscCr)Nr)guard_or_falser)r'rrcr3r )r/rrrrrr r`rzSymNode.guard_or_falsecCr)Nr) guard_or_truer)r'rrcr3r )r/rrrrrr rgrzSymNode.guard_or_truecCrr)rr.rrr bool_nrz SymNode.bool_cCdS)NTrr.rrr is_symbolicqrrzSymNode.is_symboliccCsdSrrr.rrr nested_inttrrzSymNode.nested_intcCr)NFrr.rrr is_constantwrrzSymNode.is_constant)NNF)r#r$)r)rr<r)r>rr<r)r<rr)r<r})r<r)F)]__name__ __module__ __qualname____doc__r"__annotations__r;r=r@rBpropertyr(r#rErUrWr\r_rarbrcrerlrnrorqrtrxr|r~rrrrrrrrrrrrrrrrrr rrrrrrrrrrrrr r r rrrrrrrrrrrrrrrrrrrr rrrrrrrrrrrrrr rNs   U                                                  %    rcseZdZfddZZS)_DynamicScalarcs$|turtdtj|g|RS)Nz9_DynamicScalar is an abstract base class, use DynamicInt.)r% TypeErrorsuper__new__)clsr __class__rr r(|sz_DynamicScalar.__new__)rr r!r( __classcell__rrr*r r%{sr%cs8eZdZdZfddZddZddZdd ZZS) ra User API for marking dynamic integers in `torch.compile`. Intended to be compatible with both compile and eager mode. Example usage:: fn = torch.compile(f) x = DynamicInt(4) fn(x) # compiles x as a dynamic integer input; returns f(4) cs2t|tstdt|t|t|}|S)Nrg)r+rr3r2r'r()r)valobjr*rr r(s zDynamicInt.__new__cCsd|jdS)Nz DynamicInt(r0)realr.rrr r|rzDynamicInt.__repr__cCst|j|Srrr/r?rrr __floordiv__rzDynamicInt.__floordiv__cCst||jSrr0r?rrr __rfloordiv__rzDynamicInt.__rfloordiv__) rr r!r"r(r|r1r2r,rrr*r rs  rrrrandrrrrrrrrrcCrvr)rxrrr sr6rrrrrrrorrrrrrrrrr r r r rr> rrrrrrrr rcfdd}|S)Ncst|dS)N_sym_)getattrr.namerr fnsz_get_sym_node_fn..fnrr<r=rr;r _get_sym_node_fns r?) sqrtcoscoshsinsinhtantanhasinacosatanlog2sym_r>r7r3r r >rrr>rrsym_log2rxor)rrr>rrrr>rrrr> rrrrrrr7r3r rrcCddlm}|||S)Nr) FloatTrueDiv)torch.utils._sympy.functionsrO)rbrOrrr _sympy_float_truediv"  rRcCrN)Nr) IntTrueDiv)rPrT)rrQrTrrr _sympy_int_truediv(rSrUcCrN)Nr)FloorDiv)rPrV)rrQrVrrr _sympy_floordiv.rSrWcCs0ddlm}m}|jr|jr|||S|||S)NrMod PythonMod)rPrYrZis_nonnegative)rrQrYrZrrr _sympy_mod4s   r\cCrN)Nr) PowByNatural)rPr])rrQr]rrr _sympy_pow_by_natural=rSr^cCrN)Nr)FloatPow)rPr_)rrQr_rrr _sympy_float_powCrSr`cCddl}|||SrX)rYAndrrQrYrrr _sympy_andI rdcCrarX)rYOrrcrrr _sympy_orOrergcCrN)Nr)LShift)rPrh)rrQrhrrr _sympy_lshiftUrSricCrN)Nr)RShift)rPrj)rrQrjrrr _sympy_rshift[rSrkcCst|dkr |gSddlm}m}||d||kr ||gS||d||kr/|g|Sdt|d}}||kra||d}||||}|dkrPdS|dkrY|d}n|d}||ks<||||S)zs If new_arg is found in ordered_args None is returned, else the new ordered_args with new_arg inserted r) _args_sortkeyBasicrN)lensympy.core.basicrlrmcompareinsert) ordered_argsnew_argsort_keyrmlowhighmidcompare_resultrrr _binary_search_insert_argas&      r{Fc shddlddlm}fdd}ddlm}|||O}|||O}|r~|r~||jd||jdkr<||j|jS||jd||jdkrR||j|jSt|jdkr~t|jdkr~t|j}|jD] }t||}|durunqh|dur~||S|r|j rtt|j|}|dur||S|r|j rtt|j|}|dur||S ||} || | fS) a Custom optimization for Add used to optimize incremental binary summations of certain properties. The idea is when we know the expression is a summation of unique symbols all we need to know is the correct order of symbols, and no other optimizations are needed. We pass evaluate=false, with the correct order of args and save the following. 1. Avoid running other optimizations when the Add is constructed. 2. Manually figure out the order of the args for the new expression in log(n) comparisons instead of nLog(n) (comparing terms is expensive and shows in the profiles). The function returns a tuple of (1) a boolean that indicates whether the output is a summation of unique symbols, (2) the result sympy expression. rN)rlcs(|durtdjj|dd}d|fS)Nzordered_args is NoneT)is_commutative)r3r _from_args)rtresultrYrr make_optimizedsz&_optimized_add..make_optimized)_is_symbols_binary_summationrnro) rYrqrlrPr_argsrplistr{ is_symbolr) lhsrhslhs_is_optimized_summationrhs_is_optimized_summationsortkeyrrnew_argsrr~rrr _optimized_adds<           rcCrN)Nr)BitwiseFn_bitwise_and)rPr)rrQrrrr rrSrcCrN)Nr)BitwiseFn_bitwise_or)rPr)rrQrrrr rrSrcCrN)Nr)BitwiseFn_bitwise_xor)rPr)rrQrrrr rrSrcCsddl}t||jr3|j}t|dkr3t|d|jr3|djr3||d}|d|kr3||dSt||jr@|||ksFt||jrK||S||S)Nrror)rYr+MulrrprZrri)rr=rYaacoefrrr _floor_ceil_helpers &     rcCddlm}||S)Nr) FloorToInt)rPr)rrrrr _sympy_floor rcCr)Nr) TruncToInt)rPr)rrrrr _sympy_truncrrcCr)Nr) CeilToInt)rPr)rrrrr _sympy_ceil rrcCrarX)rYEqrcrrr _sympy_eqrercCrarX)rYNercrrr _sympy_nerercCrarX)rYGtrcrrr _sympy_gtrercCrarX)rYLtrcrrr _sympy_lt%rercCrarX)rYLercrrr _sympy_le+rercCrarX)rYGercrrr _sympy_ge1rercCrN)Nr)Min)rPr)rrQrrrr _sympy_min7rSrcCrN)NrMax)rPr)rrQrrrr _sympy_max=rSrcCsddl}|||f|dfS)NrT)rY Piecewise)rrfrYrrr _sympy_iteCsrcr8)Ncs"ddl}t|jjjd|S)NrOpaqueUnaryFn_)rPr:utils_sympy functions)rrr;rr r=Msz_get_sym_math_fn..fnrr>rr;r _get_sym_math_fnLs r_sympy_cCsddl}||SrX)rYAbsrrYrrr _sympy_abs^s rcCs*ddlm}m}|dur||S|||S)Nr) RoundDecimal RoundToInt)rPrr)numberrrrrrr _sympy_roundds rcCrNr)ToFloat)rPr)rrrrr _sympy_sym_floatms rcCs*ddl}ddlm}|||||Sr)rYrPrrr)rrYrrrr _sympy_is_integerus r)rrcCs$t|}t||tt|dddS)Nrrn)rpsympy_is_contiguous_genericrrange)rrdimrrr sympy_is_contiguoussrcCsddl}t|}t||kr|jS|j}|jj}|D]}|||||jj||||BM}|||9}qt|D]}|||||jjO}q;|SrX) rYrpr^r]SOnerrZero)rr dim_orderrYrrzdrrr rs ( rcCt||gdSN)rrorrrrrrr $sympy_is_channels_last_contiguous_2drcCrN)rrrorrrrrr $sympy_is_channels_last_contiguous_3drrc Csddl}ddlm}t|}|t|kr|jS|jj}|j}|||ddM}|D]+}||||d|||k@M}|dkrJ||||dM}|||||d}q*|S)Nrrr) rYrPrrpr^rrr]r) rrrrYrrmr rrrr &sympy_is_channels_last_strides_generics    rcCrrrrrrr !sympy_is_channels_last_strides_2drrcCrrrrrrr !sympy_is_channels_last_strides_3drrcCsddlm}|g||RS)Nr)!IsNonOverlappingAndDenseIndicator)rPr)rrrrrr -_sympy_is_non_overlapping_and_dense_indicators r)rrrrrrcCsVt|tr|jSt|tur||St|tur||St|tur)| |St Sr) r+r,rdr2rrorrlrrnNotImplemented)r/rkrrr rs       rcCsXt|tr |jdur |jS|rt|S|rt|S|r%t|St d|)Nzunrecognized return type ) r+rr6rarrbrrcr r3r4rrr rsrcCst|Sr)METHOD_TO_OPERATORmethodrrr r rurc stdtvrd}n}ddd}fdd}|fd d }|fd d }tvr>ttd||dSd krTfdd}ttd||dSdkrkdfdd }ttd||dSttd||dS)Nrr<set[str]cSsJddl}|jj|jj|jjj|g}ddl}dd|D|jj BdhBS)NrcSsh|]}t|qSr)inspectgetfile)rKrrrr 8z@_make_node_magic..uninteresting_files..z) r_dynamo eval_framerfx experimentalrtorch._dynamo.guardsguardsuninteresting_files)rmodsrrr r,s  z-_make_node_magic..uninteresting_filescstdfdd }|S)Ncsj|dur |n||tjjjr3|dur||gn|gd fdd tdfdddS) Nr< Optional[int]cs`ddl}|jdur dSt|tkrdSt|j|j|jfr!dS|j|j|jfvr,dSt|SrX) rYr6idr+r(rirZr]r^)rrY)r~rr get_idJs zM_make_node_magic..capture_provenance..wrapper..get_idexpression_createdc s@ttddDfddDtdtddS)NcSg|]}t|qSrrwrrrr r^zc_make_node_magic..capture_provenance..wrapper....cs g|] }|dur|qSrr)rKi)rrr r_sr)rr~ result_id arguments argument_ids user_stackstack)rtr structuredget_user_stackget_framework_stackr)rrrr~rr r6Zs  zO_make_node_magic..capture_provenance..wrapper..) metadata_fn)r<r)r_logging _internalGET_DTRACE_STRUCTUREDrr?)r=r)rrr~r wrapper>s    z=_make_node_magic..capture_provenance..wrapperr) functoolswraps)r=rr)r=r capture_provenance=s*z,_make_node_magic..capture_provenancec sddlm}m}t}t}|jdur|jdur||j|j}|r1t|||t|t|fiSt|t s?t dt |d}zdkr{ddl m }m}|j} |jjs^| |jjdkrs|jjsk| |jjdkrs||j|j} nv||j|j} nndkrt|j|j|j|j\}} n\dvrddl} dd lm} m} |jjo| |j| j}|jjo| |j| j}|r|jjs|r|jjr| j| j| j| j | j!| j"d}||j|jdd } n|j|j} n|j|j} Wnt#yt$%d |j|jwt&'d |j|j| t(vrt)}nt*vrt+}n|j,t)us$|j,t)ur't)}n|j,}|durC|turC|durCt|t-sC||}|j.||j/|j/f\}}t | |j||||d }|S)NrrzExpected SymNode, got FrrXr)rrrrrr)symbol_is_typeSymT)rfailed to eval %s(%s, %s)z%s %s %s -> %s)r7r8)0rrrrrr#rrr+rr3r2rPrYrZr)r(r[ bound_sympylowerrr"rYtorch.utils._sympy.symbolrrr UNBACKED_INTrVrrrrrrrrr sym_node_logdebugalways_float_magic_methodsralways_bool_magic_methodsrr-r,rr7)r/r>rroprr8rYrZr)rrYrrlhs_is_unbackedrhs_is_unbacked rel_classr-r7rr~funcrrr binary_magic_implks            z+_make_node_magic..binary_magic_implc sddlm}m}t}|rt|||t|fiS|j}dks&dkr,|j|}z|}Wnt yAt d|wt d||t}|jdurV||j}tvr]t}ntvrdt}n tvrkt}n|j}|j||jf\}} t||j|||dS)Nrrrceilingzfailed to eval %s(%s)z %s %s -> %sr)rrrrrrr(r)_simplify_floor_divrrrr r rr#always_int_magic_methodsrrrr rr-rr7r) r/rrrr(rrr-r7rrrr unary_magic_impls4     z*_make_node_magic..unary_magic_implr c sddlm}m}|jr|jn|j}|r&t||tt|t|t|fiSz |j|j|j}WntyEt d|j|j|jw|j t|j |j |j f\}}t||j |j||dS)Nrrzfailed to eval %s(%s, %s, %s)r)rrrr#rr rr(rrrr)rr7rr-) pred_node then_node else_noderrrrr7rrrr sym_ite_impls@   z&_make_node_magic..sym_ite_implrc sddlm}m}tj}|rt|||t||fiS|j}z||}Wnty5t d||w|dur=t }n|j }d}|j durM||j |}|jg} |durZ| ||j|t| \} } t||j||| dS)Nrrz!failed to eval %s(%s, ndigits=%s)r)rrrbuiltinsrrrr(rrrrr-r#r7ryr)rrr) r/rrrrr(rr-rrr7rrrr round_impl;s0     z$_make_node_magic..round_impl)r<rr)r2magic_methods_on_operator_with_trailing_underscore unary_methodssetattrr) rr method_attrrrrrrrrrr _make_node_magic$s&    .{$()r$csXfdd}ttd|fdd}ttjts*ttjt|dSdS)Nc sddlm}m}ttjt}|r(t|||dd|Ddd|DfiSdd|D}dd|D}z||}WntyMt d||wg} d} |D]} | j dur]n | | j qTg} |D]} | j durqn | | j qh|| | }  drt} nt} t||j| | S) NrrcSrrrrJrrr rxrzH_make_node_sizes_strides..sizes_strides_impl..cSrrrsrJrrr r|rcSrrrsrJrrr r}rr _indicator)rrrr:sysmodulesrrrrrr#ryendswithrrrr))r/rrrrr size_exprs stride_exprsrrrrL stride_hintsr-rrr sizes_strides_impllsF     z4_make_node_sizes_strides..sizes_strides_implrcsddlddlm}t||D]"ttr2ttj fdd|Dfdd|DSqdkr<|||St fdd|Dfdd|DS) Nr)!eval_is_non_overlapping_and_densecg|]}tj|qSrrrdrKrQrrr rzH_make_node_sizes_strides..sizes_strides_user..cr.rr/r0r1rr rr2rcg|]}|qSrsympifyrrrr rrcr3rr4rrrr rr) rYr'r- itertoolschainr+rrr:rdr)rrr-rrr sizes_strides_users&    z4_make_node_sizes_strides..sizes_strides_user)r"rhasattrr&r'r)rrr,r8rrr _make_node_sizes_stridesis 0r:c stvr dndddddtvrdd nd d fd d fd d}fdd}fdd}dd}tvr\||dd|dStvrpt|}||t||dSdkrfdd}||dd|dSdkrdfdd }||dd|dS} tvrt} ||d| d|tvr||d| d|dSdS)NrKr52Union[SymInt, int, SymFloat, float, SymBool, bool]cSsLt|tttfr |St|tr|jddSt|tr"|jddSt d)Nrrz*expect to be called with constant SymBools) r+rrrrrdrr rr3r4rrr get_constants  z&_make_user_magic..get_constantcSs2t|tttfr dSt|tttfr|jSdS)NTF) r+rrrrrr rdrr4rrr rs  z%_make_user_magic..is_constantcSs"t|trt|jt|S|S)z;Implements True+True=2, which works in python but not sympy)r+r rrdrlrr4rrr promotes z!_make_user_magic..promotecSrprrr4rrr r=rrcs\dvr||fSt|ttjf}t|ttjf}|s|r*|s#t|}|s*t|}||fS)N)rrrrrrrr r rrrrrr)r+rrrr)r/r>f_selff_otherrrr promote2s  z"_make_user_magic..promote2cs2|}|rt|Stt|jSr)rrr:rdr.)r<rrr#r=rr r0sz*_make_user_magic..unary_magic_implcst|ttttttfs tSt d|||}|}||\}}|r1t ||S|r9|}t |j |}|turEtSt t|j |}|rW|S|S)NzMAGIC %s %s %s)r+rrrrrr rr r rrrdrr:r/r> other_noderetr<rrr#r=r@rr r6s z+_make_user_magic..binary_magic_implcst|ttttttfs tS|}|}||\}}|r)t||S|r1|}t |j |}|tur=tSt t ||j }|rO|S|Sr) r+rrrrrr rrrrdrr:rArDrr rbinary_magic_implGs z,_make_user_magic..rbinary_magic_implcs4t||fdd}|turtt|dSdS)z Registers the SymNode magic method on SymInt/Float/Bool, and optionally registers a corresponding wrapped method on DynamicInt. cs<dd|D}tt|}t|trt|tst|S|S)NcSs g|] }t|tr |jn|qSr)r+rr/)rKr5rrr rbs zP_make_user_magic..setattrs..dynamic_int_impl..)r:rr+rr)rrattrrr dynamic_int_implas z<_make_user_magic..setattrs..dynamic_int_implN)r"rr) user_typerG symnode_implrHrrFr setattrsWs  z"_make_user_magic..setattrs__r cs|j}t||}t||}|tus|turtSt|tr't|tr'|j|jks+tdtt|j||}|j r?|S|S)Nz9then_node and else_node must be SymNodes with same pytype) rdrrr+rr-r3rr:r)predrrrrrrC)r<r#rr sym_ite_magic_implrs   z,_make_user_magic..sym_ite_magic_implrcs,|r t||Stt|j|Sr)rrrr:rdr)r<rrrr round_magic_implsz*_make_user_magic..round_magic_impl__r)r5r;r)r bool_becomes_int_magic_methodsunary_magic_methodsunary_nonmagic_methodsr:r bitwise_opsreflectable_magic_methods) rrIrrrErKorigrNrO method_namerrDr _make_user_magics>   !  * rX)FFr) __future__rrrrr6loggingmathoperatorr&rrtypingrrrrtorch._logging.structuredrrrr r r r r rrtorch._loggingrr'r getLoggerrrgetArtifactLoggerr rrr#rrrHintType__all__ torch.typesrr,r!rr%rrrrrrrrrrrrrrrrrrrrrMrrrrrrrRr? math_op_namesr<sym_name priv_sym_namer"r:ryrSr!only_bool_magic_methodsrQalso_bool_magic_methodsbool_magic_methodsonly_float_magic_methodsr rTr rrrRrUrWr\r^r`rdrgrirkr{rrrrrUrrrrrrrrrrrrrr'current_modulerpriv_sympy_namer=r!rrrrinvertrrrrrrrrrsizes_strides_methodsrrrr$r:itemsrrrXrrrr sD (     1      !"#&      # D                (  GWP