\hI! %SSKJr SSKrSSKJr SSKJr SSKJr SSK J r SSK J r SSK r SSKJr \"S 5r\(Ga\R"r\R&rSS KJr SS KJr SS KJr \"\S S5r\c \R8r0\ R:\R<_\ R>\R@_\ RB\RD_\ RF\RH_\ RJ\RL_\ RN\RN_\ RP\RP_\ RR\RR_\ RT\RT_\ RV\RV_\ RX\RZ_\ R\\R\_\ R^\R`_\ Rb\Rb_\ Rd\Rf_\ Rh\Rj_\ Rl\Rl_0\ Rn\Rp_\ Rr\Rr_\ Rt\Rv_\ Rx\Rx_\ Rz\R|_\ R~\R_\ R\R_\ R\R_\ R\R_\ R\R_\ R\R_\ R\R_\ R\R_\ R\R_\ R\R_\ R\R_\ R\R_E\ R\R\ R\R\ R\R\ R\R\ R\R\ R\R\ R\R\ RRRS\ R\"\R<5\ R\"\R@5\ R\R\ R\R\ R\R\ R\"SSS/50Ero"SS\5rp0rqS\rS'SSjrsSSjrtSSSSS.Sjjrug)) annotationsN)Any) import_module)Printer)sympy_deprecation_warning) is_sequence)partialaesara)nlinalg)Elemwise) DimShuffle true_dividec.[RSS5$Nr)aetcomplexQ/var/www/auris/envauris/lib/python3.13/site-packages/sympy/printing/aesaracode.pyrGsS[[15Er)FFrc^\rSrSrSrSrU4SjrSSjrSSjrSr Sr S r S r S r S r\=rrS rSrSrSrSrSrSrSrSrSrSrSrSSjrSrU=r$) AesaraPrinterRa  .. deprecated:: 1.14. The ``Aesara Code printing`` is deprecated.See its documentation for more information. See :ref:`deprecated-aesaraprinter` for details. Code printer which creates Aesara symbolic expression graphs. Parameters ========== cache : dict Cache dictionary to use. If None (default) will use the global cache. To create a printer which does not depend on or alter global state pass an empty dictionary. Note: the dictionary is not copied on initialization of the printer and will be updated in-place, so using the same dict object when creating multiple printers or making multiple calls to :func:`.aesara_code` or :func:`.aesara_function` means the cache is shared between all these applications. Attributes ========== cache : dict A cache of Aesara variables which have been created for SymPy symbol-like objects (e.g. :class:`sympy.core.symbol.Symbol` or :class:`sympy.matrices.expressions.MatrixSymbol`). This is used to ensure that all references to a given symbol in an expression (or multiple expressions) are printed as the same Aesara variable, which is created only once. Symbols are differentiated only by name and type. The format of the cache's contents should be considered opaque to the user. _aesaracT>URS05Ul[TU] "U0UD6 g)Ncache)poprsuper__init__)selfargskwargs __class__s rr AesaraPrinter.__init__ts'ZZ,  $)&)rcRUc URnU[U5URX44$)zGet the cache key for a SymPy object. Parameters ========== s : sympy.core.basic.Basic SymPy object to get key for. name : str Name of object, if it does not have a ``name`` attribute. )nametyper")r!sr'dtype broadcastables r_get_keyAesaraPrinter._get_keyxs) <66Dd1gqvvu<))D)3KK.v.)D8}EsAc 4[UR55$rE)floatevalf)r!nr#s r _print_NumberAesaraPrinter._print_NumbersQWWYrc dURS05RU5nURXSS9$)Nr8NNr0r:)r!Xr#r*s r_print_MatrixSymbol!AesaraPrinter._print_MatrixSymbols3 8R(,,Q/""1"NNrc [[S5(d [S5e[RUR 5VVs/sH&nUVs/sHo@R "U40UD6PM snPM( snn5$s snfs snnf)N stacklistsz>Matrix translation not yet supported in this version of Aesara)hasattrrNotImplementedErrorrZtolistrG)r!rVr#LrJs r_print_DenseMatrix AesaraPrinter._print_DenseMatrixsxsL))%OQ Q~~XXZ 45 51C[[ ' '1 5   5 s A= A8)A= 8A= c URVs/sHo0R"U40UD6PM nnUSnUSSHn[RXV5nM U$s snfr)r"rGrdot)r!rHr#rJrKresultchilds r _print_MatMulAesaraPrinter._print_MatMulsX:>))D)3KK.v.)D!ab\EWWV+F" EsAc URVs/sHo0R"U40UD6PM nnSn[US[5(a8USS:a/[ US5Hn[ R XTS5nM U$[S5es snf)Nrrz^Only non-negative integer powers of matrices can be handled by Aesara at the moment)r"rG isinstanceintrangerrbr\)r!rHr#rJrKrcis r _print_MatPowAesaraPrinter._print_MatPows:>))D)3KK.v.)D hqk3 ' 'HQK!O8A;'!5(  &'HI I EsB c UR"UR40UD6nUR"[UR640UD6nUR"[UR640UD6nX4U4$rE)rGparentslicerowslicecolslice)r!rHr#rorqrrs r_print_MatrixSlice AesaraPrinter._print_MatrixSlices_T[[3F3;;udmm4??;;udmm4??())rc xURRup4[U5VVs/sH>n[U5Vs/sH$nUR"URXV440UD6PM& snPM@ nnn[R "S/UVs/sHn[R "S/UQ76PM snQ76$s snfs snnfs snfr)blocksr1rjrGrjoin) r!rHr#nrowsncolsrcrvrows r_print_BlockMatrix AesaraPrinter._print_BlockMatrixs{{(( "'u/!-A"'u/!-A;;t{{140;F;!-/!- /xxB&A&3SXXa.#.&ABB//BsB1+B, %B1!B7 ,B1c [URURUR4Vs/sH7n[ U[ R 5(aUR"U40UD6OUPM9 sn6$s snfrE)rpstartstopsteprhsympyBasicrG)r!rHr#rks r _print_sliceAesaraPrinter._print_slicesp"&**dii!CE!CA&a55{{1//;<=!CEF FEs>A-c "[R$rE)mathpir!rHr#s r _print_PiAesaraPrinter._print_Pis wwrc SSKnURSRupEUR"U40UD6nUR"U40UD6n[UR5S:Xa [R XgUR 5$UR"[R"URSS640UD6n[R XgU5$r) numpyr"rGlenrswitchnanr Piecewise) r!rHr#npecondp_condp_e p_remainings r_print_PiecewiseAesaraPrinter._print_Piecewises))A,##T,V,kk!&v& tyy>Q ::f2662 2kk%//499QR="ALVL zz&{33rc [UR"UR40UD6UR"UR40UD65$rE)rrGpqrs r_print_RationalAesaraPrinter._print_Rationals84;;tvv88;;tvv88: :rc UR$rE)rrs r_print_IntegerAesaraPrinter._print_Integers vv rc pUR"[R"URSS-540UD6$r)rGrgammar"rs r_print_factorialAesaraPrinter._print_factorials,{{5;;tyy|a'78CFCCrc SSKJn UR"UR40UD6nURH2nUR"U40UD6nU"XE[ R U55nM4 U$)Nr)Rop)aesara.gradientrrGrH variablesr ones_like)r!derivr#rrvvars r_print_DerivativeAesaraPrinter._print_DerivativesY' [[ .v .??C++c,V,CRcmmC01B# rcU$rEr)r!rHs r emptyPrinterAesaraPrinter.emptyPrinters rc6Uc0nUc0nURXUS9$)aXConvert a SymPy expression to a Aesara graph variable. The ``dtypes`` and ``broadcastables`` arguments are used to specify the data type, dimension, and broadcasting behavior of the Aesara variables corresponding to the free symbols in ``expr``. Each is a mapping from SymPy symbols to the value of the corresponding argument to ``aesara.tensor.var.TensorVariable``. See the corresponding `documentation page`__ for more information on broadcasting in Aesara. .. __: https://aesara.readthedocs.io/en/latest/reference/tensor/shapes.html#broadcasting Parameters ========== expr : sympy.core.expr.Expr SymPy expression to print. dtypes : dict Mapping from SymPy symbols to Aesara datatypes to use when creating new Aesara variables for those symbols. Corresponds to the ``dtype`` argument to ``aesara.tensor.var.TensorVariable``. Defaults to ``'floatX'`` for symbols not included in the mapping. broadcastables : dict Mapping from SymPy symbols to the value of the ``broadcastable`` argument to ``aesara.tensor.var.TensorVariable`` to use when creating Aesara variables for those symbols. Defaults to the empty tuple for symbols not included in the mapping (resulting in a scalar). Returns ======= aesara.graph.basic.Variable A variable corresponding to the expression's value in a Aesara symbolic expression graph. )r8r9)rG)r!rHr8r9s rdoprintAesaraPrinter.doprints-R >F  !N{{4~{NNr)rNNNrU) __name__ __module__ __qualname____firstlineno____doc__ printmethodr r,r5r=rBrLrRrWr__print_ImmutableMatrix_print_ImmutableDenseMatrixrerlrsr}rrrrrrrrr__static_attributes__ __classcell__)r$s@rrrRs>K*=$.E P   O `). Defaults to the module-level global cache. dtypes : dict Passed to :meth:`.AesaraPrinter.doprint`. broadcastables : dict Passed to :meth:`.AesaraPrinter.doprint`. Returns ======= aesara.graph.basic.Variable A variable corresponding to the expression's value in a Aesara symbolic expression graph. z9 The aesara_code function is deprecated. 1.14deprecated-aesaraprinterdeprecated_since_versionactive_deprecations_targetz"aesara is required for aesara_code)rsettings)rr ImportErrorrrr)rHrr#s r aesara_coderHsS8 "(#=  6>?? } ur 2 : :4 J6 JJrc Ub[RUSU-5$UbJ[UR55nUR 5VVs0sHupVUSU-SXF- --_M snn$UbU$0$s snnf)a Get value of ``broadcastables`` argument to :func:`.aesara_code` from keyword arguments to :func:`.aesara_function`. Included for backwards compatibility. Parameters ========== inputs Sequence of input symbols. dim : int Common number of dimensions for all inputs. Overrides other arguments if given. dims : dict Mapping from input symbols to number of dimensions. Overrides ``broadcastables`` argument if given. broadcastables : dict Explicit value of ``broadcastables`` argument to :meth:`.AesaraPrinter.doprint`. If not None function will return this value unchanged. Returns ======= dict Dictionary mapping elements of ``inputs`` to their "broadcastable" values (tuple of ``bool``\ s). F)T)dictfromkeysmaxvaluesitems)inputsdimdimsr9maxdimr)ds r dim_handlingrus> }}VX^44 T[[]#  $ x!|g44 4$  ! I s A1rrr9c :^^[SSSS9 [(d [S5eURS05nURS05n[ XXES9n[ [ XxUS 9n [[X55n [[X55n U V s/sHMn [U [RRR5(aU O[RU 5PMO n n [U 5S :XaU S n [R "X40UD6mTR"V s/sH%n [U R$R&5S :HPM' sn mU(a[)T5(d TTlT$UU4S jnTUlTR.UlTUlU$s sn fs sn f) ao Create a Aesara function from SymPy expressions. The inputs and outputs are converted to Aesara variables using :func:`.aesara_code` and then passed to ``aesara.function``. Parameters ========== inputs Sequence of symbols which constitute the inputs of the function. outputs Sequence of expressions which constitute the outputs(s) of the function. The free symbols of each expression must be a subset of ``inputs``. scalar : bool Convert 0-dimensional arrays in output to scalars. This will return a Python wrapper function around the Aesara function object. cache : dict Cached Aesara variables (see :class:`AesaraPrinter.cache `). Defaults to the module-level global cache. dtypes : dict Passed to :meth:`.AesaraPrinter.doprint`. broadcastables : dict Passed to :meth:`.AesaraPrinter.doprint`. dims : dict Alternative to ``broadcastables`` argument. Mapping from elements of ``inputs`` to integers indicating the dimension of their associated arrays/tensors. Overrides ``broadcastables`` argument if given. dim : int Another alternative to the ``broadcastables`` argument. Common number of dimensions to use for all arrays/tensors. ``aesara_function([x, y], [...], dim=2)`` is equivalent to using ``broadcastables={x: (False, False), y: (False, False)}``. Returns ======= callable A callable object which takes values of ``inputs`` as positional arguments and returns an output array for each of the expressions in ``outputs``. If ``outputs`` is a single expression the function will return a Numpy array, if it is a list of multiple expressions the function will return a list of arrays. See description of the ``squeeze`` argument above for the behavior when a single output is passed in a list. The returned object will either be an instance of ``aesara.compile.function.types.Function`` or a Python wrapper function around one. In both cases, the returned value will have a ``aesara_function`` attribute which points to the return value of ``aesara.function``. Examples ======== >>> from sympy.abc import x, y, z >>> from sympy.printing.aesaracode import aesara_function A simple function with one input and one output: >>> f1 = aesara_function([x], [x**2 - 1], scalar=True) >>> f1(3) 8.0 A function with multiple inputs and one output: >>> f2 = aesara_function([x, y, z], [(x**z + y**z)**(1/z)], scalar=True) >>> f2(3, 4, 2) 5.0 A function with multiple inputs and multiple outputs: >>> f3 = aesara_function([x, y], [x**2 + y**2, x**2 - y**2], scalar=True) >>> f3(2, 3) [13.0, -5.0] See also ======== dim_handling z= The aesara_function function is deprecated. rrrz&Aesara is required for aesara_functionrr8r)rr8r9rrc>T"U6n[U5(a/[U5VVs/sHup#TU(aUSOUPM snn$US$s snnf)Nr)r enumerate)r"outrkofuncis_0ds rwrapper aesara_function..wrapper'sRDk s  9B3HU1XAbE1,H Hr7NIsA )rr rrrr rlistmaprhgraphbasicVariableras_tensor_variablerfunctionoutputsvariabler+anyaesara_function __wrapped__r)rrscalarrrr9r#rr8codetinputstoutputsoutputrrrrs @@rrrsr "(#=  6BCC JJw #E ZZ" %F!dN ;e"0 2D3t$%GC&'H}EF}Erx*VV\\-?-?-H-HIIsOeOeflOmm}EHF 8}A; ??7 7 7D9= FAS)) *a / FE U# GllGO"G N9F Gs AF,FrErr)v __future__rrtypingrsympy.externalrsympy.printing.printerrsympy.utilities.exceptionsrsympy.utilities.iterablesrr functoolsr r raesr2r aesara.tensorr aesara.tensor.elemwiser r getattrrtrue_divAddaddMulmulAbsabssignsgnceilingceilfloorlogexpsqrtcosacosarccossinasinarcsintanatanarctanatan2arctan2coshacosharccoshsinhasinharcsinhtanhatanharctanhrerealimimagrJangleerfrloggammagammalnPowpowEqeqStrictGreaterThangtStrictLessThanltLessThanle GreaterThangeAnd bitwise_andOr bitwise_orNotinvertXor bitwise_xorMaxmaximumMinminimum conjugateconjcorenumbers ImaginaryUnitMatAddHadamardProductTracetrace DeterminantdetInversematrix_inverse TransposerFrr__annotations__rrrrrrrQs=" (*@1  x  --C --C%/1 #}d3Kll 2 IIsww2 IIsww2 IIsww2 JJ 2 MM388 2 KK 2 IIsww2 IIsww2 JJ2 IIsww2 JJ 2 IIsww2 JJ 2 IIsww2 JJ 2 KK!2" JJ#2$ KK%2& JJ'2( KK)2* JJ+2, KK-2. HHchh/20 HHchh122 IIsyy324 IIsww526 KK728 NNCKK92: IIsww;2< HHcff=2>  # #SVV?2@  #&&A2B NNCFFC2D   svvE2F IIs HHcnn IIszz IIs IIs{{ IIs{{ OOSXX JJ   , ,.E LL(377+  ! !8CGG#4 KK    MM711 OOZA?c2GjpOGpOf " n!*KZ,^O tDOr