\h-SrSSKJr SSKJr SSKJrJrJrJ r J r "SS\ 5r "SS \ \ S 9r"S S \5r\"5r"S S\5r\"5r"SS\5r\"5r"SS5rg)ax Module to efficiently partition SymPy objects. This system is introduced because class of SymPy object does not always represent the mathematical classification of the entity. For example, ``Integral(1, x)`` and ``Integral(Matrix([1,2]), x)`` are both instance of ``Integral`` class. However the former is number and the latter is matrix. One way to resolve this is defining subclass for each mathematical type, such as ``MatAdd`` for the addition between matrices. Basic algebraic operation such as addition or multiplication take this approach, but defining every class for every mathematical object is not scalable. Therefore, we define the "kind" of the object and let the expression infer the kind of itself from its arguments. Function and class can filter the arguments by their kind, and behave differently according to the type of itself. This module defines basic kinds for core objects. Other kinds such as ``ArrayKind`` or ``MatrixKind`` can be found in corresponding modules. .. notes:: This approach is experimental, and can be replaced or deleted in the future. See https://github.com/sympy/sympy/pull/20549. ) defaultdict)cacheit) Dispatcherambiguity_warn#ambiguity_register_error_ignore_dup str_signatureRaiseNotImplementedErrorc,^\rSrSrSrU4SjrSrU=r$)KindMeta$z Metaclass for ``Kind``. Assigns empty ``dict`` as class attribute ``_inst`` for every class, in order to endow singleton-like behavior. c.>0US'[TU]XX#5$)N_instsuper__new__)clsclsnamebasesdct __class__s G/var/www/auris/envauris/lib/python3.13/site-packages/sympy/core/kind.pyrKindMeta.__new__+sG wsU88__name__ __module__ __qualname____firstlineno____doc__r__static_attributes__ __classcell__rs@rr r $s 99rr c,^\rSrSrSrU4SjrSrU=r$)Kind0a Base class for kinds. Kind of the object represents the mathematical classification that the entity falls into. It is expected that functions and classes recognize and filter the argument by its kind. Kind of every object must be carefully selected so that it shows the intention of design. Expressions may have different kind according to the kind of its arguments. For example, arguments of ``Add`` must have common kind since addition is group operator, and the resulting ``Add()`` has the same kind. For the performance, each kind is as broad as possible and is not based on set theory. For example, ``NumberKind`` includes not only complex number but expression containing ``S.Infinity`` or ``S.NaN`` which are not strictly number. Kind may have arguments as parameter. For example, ``MatrixKind()`` may be constructed with one element which represents the kind of its elements. ``Kind`` behaves in singleton-like fashion. Same signature will return the same object. c>XR;aURUnU$[TU] U5nX RU'U$N)rrr)rargsinstrs rr Kind.__new__KsA 99 99T?D 7?3'D"IIdO rrrr$s@rr&r&0s4rr&) metaclassc2^\rSrSrSrU4SjrSrSrU=r$)_UndefinedKindTz Default kind for all SymPy object. If the kind is not defined for the object, or if the object cannot infer the kind from its arguments, this will be returned. Examples ======== >>> from sympy import Expr >>> Expr().kind UndefinedKind c">[TU]U5$r)rrrs rr_UndefinedKind.__new__aws##rcg)N UndefinedKindrselfs r__repr___UndefinedKind.__repr__dsrr rrrr r!rr9r"r#r$s@rr/r/Ts $rr/c2^\rSrSrSrU4SjrSrSrU=r$) _NumberKindja Kind for all numeric object. This kind represents every number, including complex numbers, infinity and ``S.NaN``. Other objects such as quaternions do not have this kind. Most ``Expr`` are initially designed to represent the number, so this will be the most common kind in SymPy core. For example ``Symbol()``, which represents a scalar, has this kind as long as it is commutative. Numbers form a field. Any operation between number-kind objects will result this kind as well. Examples ======== >>> from sympy import S, oo, Symbol >>> S.One.kind NumberKind >>> (-oo).kind NumberKind >>> S.NaN.kind NumberKind Commutative symbol are treated as number. >>> x = Symbol('x') >>> x.kind NumberKind >>> Symbol('y', commutative=False).kind UndefinedKind Operation between numbers results number. >>> (x+1).kind NumberKind See Also ======== sympy.core.expr.Expr.is_Number : check if the object is strictly subclass of ``Number`` class. sympy.core.expr.Expr.is_number : check if the object is number without any free symbol. c">[TU]U5$r)rr2s rr_NumberKind.__new__r4rcg)N NumberKindrr7s rr9_NumberKind.__repr__srrr;r$s@rr=r=js0b$rr=c2^\rSrSrSrU4SjrSrSrU=r$) _BooleanKinda  Kind for boolean objects. SymPy's ``S.true``, ``S.false``, and built-in ``True`` and ``False`` have this kind. Boolean number ``1`` and ``0`` are not relevant. Examples ======== >>> from sympy import S, Q >>> S.true.kind BooleanKind >>> Q.even(3).kind BooleanKind c">[TU]U5$r)rr2s rr_BooleanKind.__new__r4rcg)N BooleanKindrr7s rr9_BooleanKind.__repr__srrr;r$s@rrErEs$rrEcT\rSrSrSrS SjrSrSrSr\ S5r \ S 5rS r g) KindDispatchera Dispatcher to select a kind from multiple kinds by binary dispatching. .. notes:: This approach is experimental, and can be replaced or deleted in the future. Explanation =========== SymPy object's :obj:`sympy.core.kind.Kind()` vaguely represents the algebraic structure where the object belongs to. Therefore, with given operation, we can always find a dominating kind among the different kinds. This class selects the kind by recursive binary dispatching. If the result cannot be determined, ``UndefinedKind`` is returned. Examples ======== Multiplication between numbers return number. >>> from sympy import NumberKind, Mul >>> Mul._kind_dispatcher(NumberKind, NumberKind) NumberKind Multiplication between number and unknown-kind object returns unknown kind. >>> from sympy import UndefinedKind >>> Mul._kind_dispatcher(NumberKind, UndefinedKind) UndefinedKind Any number and order of kinds is allowed. >>> Mul._kind_dispatcher(UndefinedKind, NumberKind) UndefinedKind >>> Mul._kind_dispatcher(NumberKind, UndefinedKind, NumberKind) UndefinedKind Since matrix forms a vector space over scalar field, multiplication between matrix with numeric element and number returns matrix with numeric element. >>> from sympy.matrices import MatrixKind >>> Mul._kind_dispatcher(MatrixKind(NumberKind), NumberKind) MatrixKind(NumberKind) If a matrix with number element and another matrix with unknown-kind element are multiplied, we know that the result is matrix but the kind of its elements is unknown. >>> Mul._kind_dispatcher(MatrixKind(NumberKind), MatrixKind(UndefinedKind)) MatrixKind(UndefinedKind) Parameters ========== name : str commutative : bool, optional If True, binary dispatch will be automatically registered in reversed order as well. doc : str, optional NcHXlX0lX l[U5Ulgr))namedoc commutativer _dispatcher)r8rPrRrQs r__init__KindDispatcher.__init__s &%d+rc SUR-$)Nz)rPr7s rr9KindDispatcher.__repr__s 499,,rc^^^TRSS5nU(dTR(a[nO[nTR US9 [ T5S:Xd&[ S[ T5<S[T5<S35eUUU4SjnU$) z Register the binary dispatcher for two kind classes. If *self.commutative* is ``True``, signature in reversed order is automatically registered as well. on_ambiguityN)rYz+Only binary dispatch is supported, but got z types: .c>TRR"TU40TD6 TR(a1TRR"[[ T55U40TD6 ggr))rSaddrRtuplereversed)funckwargsr8typess r_"KindDispatcher.register.._sP     7 7  $$U8E?%;TLVL r)poprRrrupdatelen RuntimeErrorr )r8rar`rYrbs``` rregisterKindDispatcher.register sqzz.$7 B -  < 05zQE M%0   MrcUR(a [U5nO&/nSnUHnXELdM URU5 UnM UR"U40UD6$r))rR frozensetappenddispatch_kinds)r8r*r`kindsprevas r__call__KindDispatcher.__call__%sU   dOEED=LLOD""53F33rc F[U5S:Xa)Uun[U[5(d[SU-5eU$[ U5HupE[U[5(d[SU-5eUS:XaUnM2Wn[ U5[ U5pXepUR RXx5n U c.UR(aUR RX5n XpU c[nOU "X5n[U[5(aM[SRXeU55e W$)Nrz%s is not a kind.rz=Dispatcher for {!r} and {!r} must return a Kind, but got {!r}) rf isinstancer&rg enumeratetyperSdispatchrRr6format) r8rnr`resultikind prev_kindt1t2k1k2r_s rrmKindDispatcher.dispatch_kinds1s u:?GFfd++"#6#?@@M&FAdD))"#6#=>>Av" i$t*B"B''008# UHnS[U5-v M g7f)z<%s>N)r ).0sigs r )KindDispatcher.__doc__..ns M-*rs6$-- 9t 9!6X!HT& 6$6p] 4,n F!F!r