U 9%e3,@sdZddlmZddlmZddlmZmZddlm Z ddl m Z m Z ddl mZm Z mZmZdd lmZdd lmZdd lmZGd d d e Zddee<ddZGddde Zddee<GdddeZGdddeZdS)zModule for SymPy containers (SymPy objects that store other SymPy objects) The containers implemented in this module are subclassed to Basic. They are supposed to work seamlessly within the SymPy framework. ) OrderedDict) MutableSet)AnyCallable)Basic)default_sort_keyordered)_sympifysympify_sympy_converter SympifyError)Kind)iterable)as_intcseZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ e Z fddZ fddZddZddZddZddZeddd Zd&d"d#Zed$d%ZZS)'Tuplea Wrapper around the builtin tuple object. Explanation =========== The Tuple is a subclass of Basic, so that it works well in the SymPy framework. The wrapped tuple is available as self.args, but you can also access elements or slices with [:] syntax. Parameters ========== sympify : bool If ``False``, ``sympify`` is not called on ``args``. This can be used for speedups for very large tuples where the elements are known to already be SymPy objects. Examples ======== >>> from sympy import Tuple, symbols >>> a, b, c, d = symbols('a b c d') >>> Tuple(a, b, c)[1:] (b, c) >>> Tuple(a, b, c).subs(a, d) (d, b, c) cOs.|ddrdd|D}tj|f|}|S)Nr Tcss|]}t|VqdSN)r .0argrT/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/sympy/core/containers.py 6sz Tuple.__new__..)getr__new__)clsargskwargsobjrrrr4s z Tuple.__new__cs<t|tr2|t}tfddt|DSj|S)Nc3s|]}j|VqdSrr)rjselfrrr=sz$Tuple.__getitem__..) isinstancesliceindiceslenrranger)r"ir%rr!r __getitem__:s zTuple.__getitem__cCs t|jSr)r&rr!rrr__len__@sz Tuple.__len__cCs ||jkSrr)r"itemrrr __contains__CszTuple.__contains__cCs t|jSr)iterrr!rrr__iter__FszTuple.__iter__cCs:t|trt|j|jSt|tr2t|j|StSdSrr#rrtupleNotImplementedr"otherrrr__add__Is   z Tuple.__add__cCs:t|trt|j|jSt|tr2t||jStSdSrr/r2rrr__radd__Qs   zTuple.__radd__cCsBz t|}Wn$tk r0tdt|YnX|j|j|S)Nz3Can't multiply sequence by non-integer of type '%s')r ValueError TypeErrortypefuncr)r"r3nrrr__mul__Ys  z Tuple.__mul__cs t|trt|S|j|kSr)r#rsuper__eq__rr2 __class__rrr=bs  z Tuple.__eq__cs t|trt|S|j|kSr)r#rr<__ne__rr2r>rrr@gs  z Tuple.__ne__cCs t|jSr)hashrr!rrr__hash__lszTuple.__hash__cstfdd|jDS)Nc3s|]}|VqdSr) _to_mpmath)raprecrrrpsz#Tuple._to_mpmath..)r0r)r"rFrrErrCoszTuple._to_mpmathcCst|j|jkSrr rr2rrr__lt__rsz Tuple.__lt__cCst|j|jkSrrGr2rrr__le__usz Tuple.__le__)returncCs |j|S)z&Return number of occurrences of value.)rcount)r"valuerrr tuple_countzszTuple.tuple_countNcCsF|dkr|dkr|j|S|dkr2|j||S|j|||SdS)z2Searches and returns the first index of the value.N)rindex)r"rLstartstoprrrrN~s  z Tuple.indexcCstdd|jDS)ao The kind of a Tuple instance. The kind of a Tuple is always of :class:`TupleKind` but parametrised by the number of elements and the kind of each element. Examples ======== >>> from sympy import Tuple, Matrix >>> Tuple(1, 2).kind TupleKind(NumberKind, NumberKind) >>> Tuple(Matrix([1, 2]), 1).kind TupleKind(MatrixKind(NumberKind), NumberKind) >>> Tuple(1, 2).kind.element_kind (NumberKind, NumberKind) See Also ======== sympy.matrices.common.MatrixKind sympy.core.kind.NumberKind css|] }|jVqdSr)kind)rr(rrrrszTuple.kind..) TupleKindrr!rrrrQsz Tuple.kind)NN)__name__ __module__ __qualname____doc__rr)r*r,r.r4r5r;__rmul__r=r@rBrCrHrIintrMrNpropertyrQ __classcell__rrr>rrs(   rcCst|Srr)tuprrrr]csfdd}|S)a` Decorator that converts any tuple in the function arguments into a Tuple. Explanation =========== The motivation for this is to provide simple user interfaces. The user can call a function with regular tuples in the argument, and the wrapper will convert them to Tuples before handing them to the function. Explanation =========== >>> from sympy.core.containers import tuple_wrapper >>> def f(*args): ... return args >>> g = tuple_wrapper(f) The decorated function g sees only the Tuple argument: >>> g(0, (1, 2), 3) (0, (1, 2), 3) cs<g}|D](}t|tr&|t|q||q||Sr)r#r0appendr)rZkw_argsZnewargsrmethodrr wrap_tupless   z"tuple_wrapper..wrap_tuplesr)rarbrr`r tuple_wrappers rccseZdZUdZddZddZddZdd Zd d Zd d Z ddZ ddZ dddZ ddZ ddZeddZfddZejZeegefed<ZS)Dictax Wrapper around the builtin dict object. Explanation =========== The Dict is a subclass of Basic, so that it works well in the SymPy framework. Because it is immutable, it may be included in sets, but its values must all be given at instantiation and cannot be changed afterwards. Otherwise it behaves identically to the Python dict. Examples ======== >>> from sympy import Dict, Symbol >>> D = Dict({1: 'one', 2: 'two'}) >>> for key in D: ... if key == 1: ... print('%s %s' % (key, D[key])) 1 one The args are sympified so the 1 and 2 are Integers and the values are Symbols. Queries automatically sympify args so the following work: >>> 1 in D True >>> D.has(Symbol('one')) # searches keys and values True >>> 'one' in D # not in the keys False >>> D[1] one cGst|dkr6t|dttfr6dd|dD}n2t|r`tdd|Dr`dd|D}ntdt|}t j |ft |}||_ t||_ |S) NrrcSsg|]\}}t||qSrr[rkvrrr sz Dict.__new__..css|]}t|dkVqdS)N)r&rrrrrszDict.__new__..cSsg|]\}}t||qSrr[rerrrrhsz x[y])r r KeyErrorror"keyrrrr) s  zDict.__getitem__cCs tddS)NzSymPy Dicts are Immutable)NotImplementedError)r"rrrLrrr __setitem__szDict.__setitem__cCs |jS)zDReturns a set-like object providing a view on dict's items. )rorkr!rrrrksz Dict.itemscCs |jS)z$Returns the list of the dict's keys.)rokeysr!rrrrusz Dict.keyscCs |jS)z&Returns the list of the dict's values.)rovaluesr!rrrrv!sz Dict.valuescCs t|jS)zx.__iter__() <==> iter(x))r-ror!rrrr.%sz Dict.__iter__cCs |jS)zx.__len__() <==> len(x))ror*r!rrrr*)sz Dict.__len__NcCs4z t|}Wntk r$|YSX|j||S)z:Returns the value for key if the key is in the dictionary.)r r ror)r"rrdefaultrrrr-s   zDict.getcCs.z t|}Wntk r"YdSX||jkS)z6D.__contains__(k) -> True if D has a key k, else FalseF)r r rorqrrrr,5s  zDict.__contains__cCst|j|jkSrrGr2rrrrH=sz Dict.__lt__cCstt|jtdS)N)rr)r0sortedrrr!rrr _sorted_args@szDict._sorted_argscs"t|tr|t|kSt|Sr)r#rjrdr<r=r2r>rrr=Ds  z Dict.__eq__rB)N)rSrTrUrVrr)rtrkrurvr.r*rr,rHrYryr=rrBrr__annotations__rZrrr>rrds %     rdcCs t|Sr)rdrk)drrrr]Lr^c@sheZdZdddZddZddZdd Zd d Zdd dZddZ ddZ ddZ ddZ ddZ dS) OrderedSetNcCs&|rtdd|D|_nt|_dS)Ncss|]}|dfVqdSrr)rr+rrrrQsz&OrderedSet.__init__..)rmap)r"rrrr__init__OszOrderedSet.__init__cCs t|jSr)r&r}r!rrrr*UszOrderedSet.__len__cCs ||jkSrr}rqrrrr,XszOrderedSet.__contains__cCsd|j|<dSrrrqrrradd[szOrderedSet.addcCs|j|dSr)r}poprqrrrdiscard^szOrderedSet.discardTcCs|jj|ddS)N)lastr)r}popitem)r"rrrrraszOrderedSet.popccs|jEdHdSr)r}rur!rrrr.dszOrderedSet.__iter__cCs.|jsd|jjfSd|jjt|jfS)Nz%s()z%s(%r))r}r?rSlistrur!rrr__repr__gszOrderedSet.__repr__cs|fdd|DS)Ncsg|]}|kr|qSrrrvalr3rrrhmsz+OrderedSet.intersection..r>r2rrr intersectionlszOrderedSet.intersectioncs|fdd|DS)Ncsg|]}|kr|qSrrrrrrrhpsz)OrderedSet.difference..r>r2rrr differenceoszOrderedSet.differencecCs|D]}||qdSr)r)r"rrrrrupdaterszOrderedSet.update)N)T)rSrTrUr~r*r,rrrr.rrrrrrrrr|Ns  r|cs(eZdZdZfddZddZZS)rRad TupleKind is a subclass of Kind, which is used to define Kind of ``Tuple``. Parameters of TupleKind will be kinds of all the arguments in Tuples, for example Parameters ========== args : tuple(element_kind) element_kind is kind of element. args is tuple of kinds of element Examples ======== >>> from sympy import Tuple >>> Tuple(1, 2).kind TupleKind(NumberKind, NumberKind) >>> Tuple(1, 2).kind.element_kind (NumberKind, NumberKind) See Also ======== sympy.core.kind.NumberKind MatrixKind sympy.sets.sets.SetKind cstj|f|}||_|Sr)r<r element_kind)rrrr>rrrszTupleKind.__new__cCs d|jS)Nz TupleKind{})formatrr!rrrrszTupleKind.__repr__)rSrTrUrVrrrZrrr>rrRvs rRN)rV collectionsrcollections.abcrtypingrrbasicrZsortingrr r r r r Zsympy.core.kindrZsympy.utilities.iterablesrZsympy.utilities.miscrrr0rcrdrjr|rRrrrrs"       $s (