wg)sddlmZddlmZmZddlmZmZddlm Z ddl m Z ddl m Z mZddlmZmZdd lmZmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZm Z ddl!m"Z"ddl#Z#ddl$Z%ddl&Z&ddl'm(Z(ddl)m*Z*GddeZ+dZ,d%dZ-de.dfdZ/e/Z0GddeeZ1Gdde1Z2Gdde1Z3e%jhd Z5e1d!d&d"Z6d#Z7d$Z8y)') annotations) StdFactKB_assume_defined)BasicAtom)cacheit)Tuple)Expr AtomicExpr) AppliedUndef FunctionClass) NumberKind UndefinedKind) fuzzy_bool)S)ordered)sympify)Boolean)sift is_sequence) filldedentN)product)Anyc&eZdZdZdZdZdZdZy)Stra. Represents string in SymPy. Explanation =========== Previously, ``Symbol`` was used where string is needed in ``args`` of SymPy objects, e.g. denoting the name of the instance. However, since ``Symbol`` represents mathematical scalar, this class should be used instead. namec t|ts tdtt |zt j |fi|}||_|S)Nname should be a string, not %s) isinstancestr TypeErrorreprtyper __new__r)clsrkwargsobjs V/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/sympy/core/symbol.pyr&z Str.__new__'sE$$=T$Z@PPQ Qll3)&) c|jfSNrselfs r*__getnewargs__zStr.__getnewargs__. |r+c|jfSr-rr.s r*_hashable_contentzStr._hashable_content1r1r+N)__name__ __module__ __qualname____doc__ __slots__r&r0r3r+r*rrs Ir+rcttt|jdd\}}tj |||fS)zSplit the given dict into assumptions and non-assumptions. Keys are taken as assumptions if they correspond to an entry in ``_assume_defined``. c|dtvS)Nr)r)is r*z%_filter_assumptions..;s!A$/)r+T)binary)mapdictritemsSymbol _sanitize)r( assumptionsnonassumptionss r*_filter_assumptionsrF5sE #&dD)-#K [!  &&r+c t|tr|r|j|k(r|St|fi|St|tr|St d)aReturn s if s is a Symbol, else if s is a string, return either the matching_symbol if the names are the same or else a new symbol with the same assumptions as the matching symbol (or the assumptions as provided). Examples ======== >>> from sympy import Symbol >>> from sympy.core.symbol import _symbol >>> _symbol('y') y >>> _.is_real is None True >>> _symbol('y', real=True).is_real True >>> x = Symbol('x') >>> _symbol(x, real=True) x >>> _.is_real is None # ignore attribute if s is a Symbol True Below, the variable sym has the name 'foo': >>> sym = Symbol('foo', real=True) Since 'x' is not the same as sym's name, a new symbol is created: >>> _symbol('x', sym).name 'x' It will acquire any assumptions give: >>> _symbol('x', sym, real=False).is_real False Since 'foo' is the same as sym's name, sym is returned >>> _symbol('foo', sym) foo Any assumptions given are ignored: >>> _symbol('foo', sym, real=False).is_real True NB: the symbol here may not be the same as a symbol with the same name defined elsewhere as a result of different assumptions. See Also ======== sympy.core.symbol.Symbol z/symbol must be string for symbol name or Symbol)r!r"rrB ValueError)smatching_symbolrDs r*_symbolrK@sPr!S 33q8" "a';'' Av JKKr+r9c 8 dd}d}t|r|\}}| |s t |fi|St|s|g}tj|Dcgc](}|j t D]}|j *c}}|Dcgc]2}|j tD]}|jj 4c}}z} ||}t fd| Dr|  t fd| Drt |fi|Scc}}wcc}}w)a~ Return a symbol whose name is derivated from *xname* but is unique from any other symbols in *exprs*. *xname* and symbol names in *exprs* are passed to *compare* to be converted to comparable forms. If ``compare(xname)`` is not unique, it is recursively passed to *modify* until unique name is acquired. Parameters ========== xname : str or Symbol Base name for the new symbol. exprs : Expr or iterable of Expr Expressions whose symbols are compared to *xname*. compare : function Unary function which transforms *xname* and symbol names from *exprs* to comparable form. modify : function Unary function which modifies the string. Default is appending the number, or increasing the number if exists. Examples ======== By default, a number is appended to *xname* to generate unique name. If the number already exists, it is recursively increased. >>> from sympy.core.symbol import uniquely_named_symbol, Symbol >>> uniquely_named_symbol('x', Symbol('x')) x0 >>> uniquely_named_symbol('x', (Symbol('x'), Symbol('x0'))) x1 >>> uniquely_named_symbol('x0', (Symbol('x1'), Symbol('x0'))) x2 Name generation can be controlled by passing *modify* parameter. >>> from sympy.abc import x >>> uniquely_named_symbol('x', x, modify=lambda s: 2*s) xx c|s t|St|dz }|dk7r||jsn |dz}|dk7rtt||dzdxs|dz dz}|d|dz|zS)Nr)r"lenisdigitint)rIstartr<ns r*numbered_string_incrz3uniquely_named_symbol..numbered_string_incrsu:  FQJ2gQ4<<> FA2g Aa!efI*+a/ 0!a%y1}r+Nc34K|]}|k(ywr-r9).0rIcomparexs r* z(uniquely_named_symbol..s -!a71:o -s)r) rrKsetunionatomsrBrr funcany) xnameexprsrWmodifyrDrTdefaulter<namesrXs ` @r*uniquely_named_symbolres^ G5wA q'1[11 u  EKK8A8188#CQWW\-BCCC D EE~% -u - - 1I  -u - - 1g - -- 9Cs -D 7D ceZdZUdZdZdZded<dZdZe dZ e dZ e dd Z d Zd Ze d Ze edZdZdZdZdZdZe dZeddZdZddZdZe dZeZdZy )rBu  Symbol class is used to create symbolic variables. Explanation =========== Symbolic variables are placeholders for mathematical symbols that can represent numbers, constants, or any other mathematical entities and can be used in mathematical expressions and to perform symbolic computations. Assumptions: commutative = True positive = True real = True imaginary = True complex = True complete list of more assumptions- :ref:`predicates` You can override the default assumptions in the constructor. Examples ======== >>> from sympy import Symbol >>> x = Symbol("x", positive=True) >>> x.is_positive True >>> x.is_negative False passing in greek letters: >>> from sympy import Symbol >>> alpha = Symbol('alpha') >>> alpha #doctest: +SKIP α Trailing digits are automatically treated like subscripts of what precedes them in the name. General format to add subscript to a symbol : `` = Symbol('_')`` >>> from sympy import Symbol >>> alpha_i = Symbol('alpha_i') >>> alpha_i #doctest: +SKIP αᵢ Parameters ========== AtomicExpr: variable name Boolean: Assumption with a boolean value(True or False) F)r_assumptions_orig _assumptions0r"rTc2|jrtStSr-)is_commutativerrr.s r*kindz Symbol.kind s    r+cy)zAllow derivatives wrt Symbols. Examples ======== >>> from sympy import Symbol >>> x = Symbol('x') >>> x._diff_wrt True Tr9r.s r* _diff_wrtzSymbol._diff_wrtsr+Nc t|jdd}|!|rd|jznd}td|zt |j D])}||}||j |t|||<+y)zMRemove None, convert values to bool, check commutativity *in place*. commutativeTNz%s z&%scommutativity must be True or False.)rgetr4rHlistkeyspopbool)rDr)rjwhosekeyvs r*rCzSymbol._sanitize s $KOOM4$HI  !,/ECLL(RE85@B B ((*+ 'CC Ay$#AwK   'r+c |j}t|t|zD]0}||||k7sttd|d||d|||j ||S)Nz2 non-matching assumptions for z(: existing value is z and new value is ) assumptions0rZrHrupdate)r/rDbaseks r*_mergez Symbol._merge4sw  [!CI- 2A1~a( tAw A-0"122 2 K  r+c T|j||tj||fi|S)zSymbols are identified by name and assumptions:: >>> from sympy import Symbol >>> Symbol("x") == Symbol("x") True >>> Symbol("x", real=True) == Symbol("x", real=False) False )rCrB_Symbol__xnew_cached_r'rrDs r*r&zSymbol.__new__?s* k3'$$S$>+>>r+c 8t|ts tdtt |z|j }|j ddt|}t|}tj|}||_ ||_ ||_ ||_|S)Nr roT)r!r"r#r$r%copy setdefaultrr@r r&r _assumptionsrgrh)r'rrDassumptions_origassumptions_kbrzr)s r*__xnew__zSymbol.__xnew__Ls$$=T$Z@PPQ Q'++- }d3";/N+ ll3) 0(& r+c 0tj||fi|Sr-)rBrrs r*__xnew_cached_zSymbol.__xnew_cached_zssD8K88r+c4|jf|jfSr-)rrgr.s r*__getnewargs_ex__zSymbol.__getnewargs_ex__s d4455r+cN|jD]\}}t|||yr-)rAsetattr)r/statervalues r* __setstate__zSymbol.__setstate__s' ;;= 'KD% D$ & 'r+cv|jftt|jj zSr-)rtuplesortedrzrAr.s r*r3zSymbol._hashable_contents, |eF4+<+<+B+B+D$EFFFr+cz|jr/ddlm}||tjdj ||Sy)Nr)PowF)evaluate)is_Powsympy.core.powerrrOne _eval_subs)r/oldnewrs r*rzSymbol._eval_subss1 :: ,tQUUU3>>sCH H r+c|Sr-r9)r/rDs r* _eval_refinezSymbol._eval_refines r+c6|jjSr-)rhrr.s r*rzzSymbol.assumptions0s!!&&((r+c|jd|jfftjj tjfS)Nr) class_keyrrrsort_keyr/orders r*rzSymbol.sort_keys2~~!dii\!2AEENN4DaeeKKr+c|jdurt|jSt|j|jS)NF)ro)rjDummyrr.s r*as_dummyzSymbol.as_dummys;#'#6#6e#CuTYY Ctyyd.A.AB Cr+c \|jd|k(ryddlm}m}||||fS)Nignorer)imre)rq$sympy.functions.elementary.complexesrr)r/deephintsrrs r* as_real_imagzSymbol.as_real_imags, 99X $ & CtHbh' 'r+c|sy||vSNFr9)r/wrtflagss r* is_constantzSymbol.is_constants3r+c|hSr-r9r.s r* free_symbolszSymbol.free_symbolss v r+c"tjSr-)r UniversalSetr.s r*as_setz Symbol.as_sets ~~r+r-)T) r4r5r6r7 is_comparabler8__annotations__ is_Symbol is_symbolpropertyrkrm staticmethodrCr~r&rr rrrr3rrrzrrrrrbinary_symbolsrr9r+r*rBrBs 2hM>I III    ''&  ?++Z 9 96'GI )) L LC ( "Nr+rBceZdZdZdZej ZejddZ dZ dZ d dZ d Z ed d Zd Zy)raDummy symbols are each unique, even if they have the same name: Examples ======== >>> from sympy import Dummy >>> Dummy("x") == Dummy("x") False If a name is not supplied then a string value of an internal count will be used. This is useful when a temporary variable is needed and the name of the variable used in the expression is not important. >>> Dummy() #doctest: +SKIP _Dummy_10 ri@Bi@T) dummy_indexTNc 0| |Jd|dttjz}|:tjtjz}txjdz c_|j ||t j ||fi|}||_|S)Nz:If you specify a dummy_index, you must also provide a nameDummy_r)r"r_count_base_dummy_indexrCrBrr)r'rrrDr)s r*r&z Dummy.__new__s  "# a%a a# <c%,,//D  11ELL@K LLA L k3'ooc47;7% r+cJ|j|jf|jfSr-)rrrgr.s r*rzDummy.__getnewargs_ex__s"D,,-t/E/EFFr+c|jd|j|jfftjj tjfS)N)rrrrrrrs r*rzDummy.sort_keysE~~  4++,"./0uu~~/?G Gr+cHtj||jfzSr-)rBr3rr.s r*r3zDummy._hashable_contents!''-1A1A0CCCr+)NNr-)r4r5r6r7rrandomRandom_prngrandintrr8is_Dummyr&rr rr3r9r+r*rrs]:F FMMOE eW5 IH$G G GDr+rcZeZdZdZdZdZd dZdZee dZ fdZ d dZ xZ S) Wilda A Wild symbol matches anything, or anything without whatever is explicitly excluded. Parameters ========== name : str Name of the Wild instance. exclude : iterable, optional Instances in ``exclude`` will not be matched. properties : iterable of functions, optional Functions, each taking an expressions as input and returns a ``bool``. All functions in ``properties`` need to return ``True`` in order for the Wild instance to match the expression. Examples ======== >>> from sympy import Wild, WildFunction, cos, pi >>> from sympy.abc import x, y, z >>> a = Wild('a') >>> x.match(a) {a_: x} >>> pi.match(a) {a_: pi} >>> (3*x**2).match(a*x) {a_: 3*x} >>> cos(x).match(a) {a_: cos(x)} >>> b = Wild('b', exclude=[x]) >>> (3*x**2).match(b*x) >>> b.match(a) {a_: b_} >>> A = WildFunction('A') >>> A.match(a) {a_: A_} Tips ==== When using Wild, be sure to use the exclude keyword to make the pattern more precise. Without the exclude pattern, you may get matches that are technically correct, but not what you wanted. For example, using the above without exclude: >>> from sympy import symbols >>> a, b = symbols('a b', cls=Wild) >>> (2 + 3*y).match(a*x + b*y) {a_: 2/x, b_: 3} This is technically correct, because (2/x)*x + 3*y == 2 + 3*y, but you probably wanted it to not match at all. The issue is that you really did not want a and b to include x and y, and the exclude parameter lets you specify exactly this. With the exclude parameter, the pattern will not match. >>> a = Wild('a', exclude=[x, y]) >>> b = Wild('b', exclude=[x, y]) >>> (2 + 3*y).match(a*x + b*y) Exclude also helps remove ambiguity from matches. >>> E = 2*x**3*y*z >>> a, b = symbols('a b', cls=Wild) >>> E.match(a*b) {a_: 2*y*z, b_: x**3} >>> a = Wild('a', exclude=[x, y]) >>> E.match(a*b) {a_: z, b_: 2*x**3*y} >>> a = Wild('a', exclude=[x, y, z]) >>> E.match(a*b) {a_: 2, b_: x**3*y*z} Wild also accepts a ``properties`` parameter: >>> a = Wild('a', properties=[lambda k: k.is_Integer]) >>> E.match(a*b) {a_: 2, b_: x**3*y*z} T)exclude propertiesc t|Dcgc] }t|c}}t|}|j||tj||||fi|Scc}wr-)rrrCrr)r'rrrrDrXs r*r&z Wild.__new__[sRW556:&  k3'}}S$K{KK6sAcH|j|j|jfSr-)rrrr.s r*r0zWild.__getnewargs__as 4<<99r+c Ptj||fi|}||_||_|Sr-)rBrrr)r'rrrrDr)s r*rz Wild.__xnew__ds,ooc47;7 # r+cRt||j|jfzSr-)superr3rr)r/ __class__s r*r3zWild._hashable_contentls#w(*dllDOO-LLLr+ctfd|jDrytfd|jDsy|i}n|j }||<|S)Nc3@K|]}j|ywr-)has)rVrXexprs r*rYzWild.matches..qs1qtxx{1sc3.K|] }|ywr-r9)rVfrs r*rYzWild.matches..ss4q1T74s)r^rallrr)r/r repl_dictrs ` r*matchesz Wild.matchespsS 1DLL1 14DOO44  I!(I $r+)r9r9r)r4r5r6r7is_Wildr8r&r0rr rr3r __classcell__)rs@r*rrsHWpG)IL :   M r+rz"([0-9]*:[0-9]+|[a-zA-Z]?:[a-zA-Z]))r'c g}t|trd}d}g|D]_}||vst||vr|dz }t||vrt|}|dz }|j||}j ||ddfafd}|j }|j d} | r|ddj}|s td|jdD cgc]} | j }} td |Ds td tt|dz ddD]} || j|| | dz|jd | } |D]} | s td d | vr!||| fi|}|j |6tj| }g}tt|dz D]h} | sd || vs|| d k7s|| dz j ds/|| dzjdsG|| dz dd|| dz <|| dzdd|| dz<j|D]3}d |vr|j d r td|jd \}}|dt j"vrM|sdn t%|}t%|}|j t||Dcgc] }t|c}n}|xsd}|j tt j&j)|t j&j)|dzDcgc]}t j&|c}|dr|j |g6d} t|dk(r|d}n$t+|Dcgc]}dj-|}}r.|j/|Dcgc]}|||fi|c}r|j/|Dcgc] }||fi| c}| st|dkr|sy|dSt1|S|D]} |j t3| fd|i|!t5||Scc} wcc}wcc}wcc}wcc}wcc}w)a1 Transform strings into instances of :class:`Symbol` class. :func:`symbols` function returns a sequence of symbols with names taken from ``names`` argument, which can be a comma or whitespace delimited string, or a sequence of strings:: >>> from sympy import symbols, Function >>> x, y, z = symbols('x,y,z') >>> a, b, c = symbols('a b c') The type of output is dependent on the properties of input arguments:: >>> symbols('x') x >>> symbols('x,') (x,) >>> symbols('x,y') (x, y) >>> symbols(('a', 'b', 'c')) (a, b, c) >>> symbols(['a', 'b', 'c']) [a, b, c] >>> symbols({'a', 'b', 'c'}) {a, b, c} If an iterable container is needed for a single symbol, set the ``seq`` argument to ``True`` or terminate the symbol name with a comma:: >>> symbols('x', seq=True) (x,) To reduce typing, range syntax is supported to create indexed symbols. Ranges are indicated by a colon and the type of range is determined by the character to the right of the colon. If the character is a digit then all contiguous digits to the left are taken as the nonnegative starting value (or 0 if there is no digit left of the colon) and all contiguous digits to the right are taken as 1 greater than the ending value:: >>> symbols('x:10') (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) >>> symbols('x5:10') (x5, x6, x7, x8, x9) >>> symbols('x5(:2)') (x50, x51) >>> symbols('x5:10,y:5') (x5, x6, x7, x8, x9, y0, y1, y2, y3, y4) >>> symbols(('x5:10', 'y:5')) ((x5, x6, x7, x8, x9), (y0, y1, y2, y3, y4)) If the character to the right of the colon is a letter, then the single letter to the left (or 'a' if there is none) is taken as the start and all characters in the lexicographic range *through* the letter to the right are used as the range:: >>> symbols('x:z') (x, y, z) >>> symbols('x:c') # null range () >>> symbols('x(:c)') (xa, xb, xc) >>> symbols(':c') (a, b, c) >>> symbols('a:d, x:z') (a, b, c, d, x, y, z) >>> symbols(('a:d', 'x:z')) ((a, b, c, d), (x, y, z)) Multiple ranges are supported; contiguous numerical ranges should be separated by parentheses to disambiguate the ending number of one range from the starting number of the next:: >>> symbols('x:2(1:3)') (x01, x02, x11, x12) >>> symbols(':3:2') # parsing is from left to right (00, 01, 10, 11, 20, 21) Only one pair of parentheses surrounding ranges are removed, so to include parentheses around ranges, double them. And to include spaces, commas, or colons, escape them with a backslash:: >>> symbols('x((a:b))') (x(a), x(b)) >>> symbols(r'x(:1\,:2)') # or r'x((:1)\,(:2))' (x(0,0), x(0,1)) All newly created symbols have assumptions set according to ``args``:: >>> a = symbols('a', integer=True) >>> a.is_integer True >>> x, y, z = symbols('x,y,z', real=True) >>> x.is_real and y.is_real and z.is_real True Despite its name, :func:`symbols` can create symbol-like objects like instances of Function or Wild classes. To achieve this, set ``cls`` keyword argument to the desired type:: >>> symbols('f,g,h', cls=Function) (f, g, h) >>> type(_[0]) r)z\,z\:z\ rNcDrD]\}}|j||}|Sr-)replace)rIclliteralss r*literalzsymbols..literals-$(DAq !QA(Hr+,rNzno symbols givenc3 K|]}|ywr-r9)rVrSs r*rYzsymbols..s$1$s zmissing symbol between commasseqzmissing symbol:()zmissing end rangeaTrpr9r')r!r"chrrappendstripendswithrstriprHsplitrrangerOrt_range startswithstringdigitsrQ ascii_lettersindexrjoinextendrsymbolsr%)rdr'argsresultmarker splitterssplitterlit_charras_seqrSr<rrsymbolr split_listrIrba_ib_irrs @r*rrsuhF%' *,! :H5 &kU*aKF&kU*v;!  h98AB< 89 :   $ #2J%%'E/0 0%*KK$45q55$e$$<= =s5zA~r2. /A#Ahnn.E!QUO /hhuf%- CD !122$WT]3d3 f%%||D1E*,J3u:>* 4aU1X_a!e --c2a!e //4#(Q<#4E!a%L#(Q<#3E!a%L  4  C!8zz#()<==773%%qc*# C&z?a'&qME18*1EFARWWQZFEFMME"Jq3wqz#:T#:"JKMM5"Aa3q>D>"AB[- C^s6{a'!9 V} :D MM'$8C848 9 :tE{6""E6F+L+@G"J"As$Q-Q #Q Q.Q" Q' c .fdddlm}|j} t|fi|}|at |t r||j |j<~|St |tr||j |j<~|S||~|S#~wxYw)a Create symbols and inject them into the global namespace. Explanation =========== This calls :func:`symbols` with the same arguments and puts the results into the *global* namespace. It's recommended not to use :func:`var` in library code, where :func:`symbols` has to be used:: Examples ======== >>> from sympy import var >>> var('x') x >>> x # noqa: F821 x >>> var('a,ab,abc') (a, ab, abc) >>> abc # noqa: F821 abc >>> var('x,y', real=True) (x, y) >>> x.is_real and y.is_real # noqa: F821 True See :func:`symbols` documentation for more details on what kinds of arguments can be passed to :func:`var`. c|D]_}t|tr||j|j<-t|tr||j|j <W||ay)z4Recursively inject symbols to the global namespace. N)r!r f_globalsrrr4)rframer traverses r*rzvar..traversexsT (F&%(/5 ,FM2390'  (r+r) currentframe) inspectrf_backrr!rrrrr4)rdrrrsymsrs @r*varrUsF(% N ! !E u%%  $&-1 *  KD-015 .  K u%  K s7B)B BBct|}d}t|j|}i}|D];}|jt |j dgj |=i}|D]}td|zfi||dj}||d|k7r ||||d<d} tdt||D]9} d|| | zfz} | |vrn| dz } ||| } t| fi| j|| <;|j|S)a Return a Tuple containing the passed expressions with symbols that appear the same when printed replaced with numerically subscripted symbols, and all Dummy symbols replaced with Symbols. Parameters ========== iter: list of symbols or expressions. Examples ======== >>> from sympy.core.symbol import disambiguate >>> from sympy import Dummy, Symbol, Tuple >>> from sympy.abc import y >>> tup = Symbol('_x'), Dummy('x'), Dummy('x') >>> disambiguate(*tup) (x_2, x, x_1) >>> eqs = Tuple(Symbol('x')/y, Dummy('x')/y) >>> disambiguate(*eqs) (x_1/y, x/y) >>> ix = Symbol('x', integer=True) >>> vx = Symbol('x') >>> disambiguate(vx + ix) (x + x_1,) To make your own mapping of symbols to use, pass only the free symbols of the expressions and create a dictionary: >>> free = eqs.free_symbols >>> mapping = dict(zip(free, disambiguate(*free))) >>> eqs.xreplace(mapping) (x_1/y, x/y) cZtt|jjSr-)rrrzrA)rXs r*r=zdisambiguate..s5 4 4 678r+)rs_z%srrz%s_%i) r rrrr"lstriprrBrzrrOxreplace) iternew_iterrwrmappingrIrepsr}mapk0skipr<rkis r* disambiguater&sDPd|H 8C 8((s 3DG =3q6==-r299!<= D 7tqz@WQZ]%?%?@ 1:a=E !"'DA q#gaj/* 7A!QX.w&   ABd6boo6DH 77   T ""r+r-)returnr)9 __future__rrDrrbasicrrcacher containersr rr r functionr rrkrrlogicr singletonrsortingrrsympy.logic.boolalgrsympy.utilities.iterablesrrsympy.utilities.miscrrr_rer itertoolsrtypingrrrFrKr"re_uniquely_named_symbolrBrrcompilerrrr&r9r+r*r8s"3"1+'7+  $8 '@LD(*3tI.T/iZiXADFADH|6|~ 9 :!R#j=~?#r+