g%ddlmZmZddlmZmZmZmZddlZ ddl Z ddl Z e j dZ dZdZGdd Zeeeffd Zd ZdS) )SymbolBasic) combinations permutationsproductrNz"([0-9]*:[0-9]+|[a-zA-Z]?:[a-zA-Z])c g}t|trd}gdttD]}d}||vrpt ||vr|dz }t ||vt |}|dz }|||}||ddffd|}| d}|r|dd }|stdd | dD}td |Dstd tt|dz ddD]$}|| |||dz<%d td |}|D]} | stdd| vr(| fi} || @t | } tt| dz D]}|rd| |vrz| |dkrn| |dz  drP| |dzdr2| |dz dd| |dz <| |dzdd| |dz<t#| D]\}} d| vr| d drtd| d\} }|dt$jvr@| sdnt)| } t)|}dt| |D| |<n^| pd} dtt$j| t$j|dzD| |<| |sn | g| |<d}t| dkr | d}ndt/| D}r%|fd|D||fd|D|st|dkr |sdS|dSt3|S|D]"} |t5| fi#t7||S)a 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 symengine import symbols >>> 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(set(['a', 'b', 'c'])) set([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('x(:1\,:2)') # or 'x((:1)\,(:2))' (x(0,0), x(0,1)) r)z\,z\:z\ rNcHrD]\}}|||}|SN)replace)sclliteralss I/granary/edev/quantum/lib/python3.11/site-packages/symengine/utilities.pyliteralzsymbols..literalds6 ($((DAq !QAAH,zno symbols givenc6g|]}|S)strip.0ns r zsymbols..rs 555q555rc3K|]}|VdSr rrs r zsymbols..ss"$$1$$$$$$rzmissing symbol between commasclsseqzmissing symbol:()zmissing end rangec,g|]}t|Sr)strrrs rrzsymbols..s#@#@#@qCFF#@#@#@rac2g|]}tj|Sr)string ascii_lettersr&s rrzsymbols..s2$@$@$@F$8$;$@$@$@rTc8g|]}d|S))join)rr s rrzsymbols..s"@@@ARWWQZZ@@@rc4g|]}|fiSrr)rr argsrrs rrzsymbols..s3"J"J"Jq33wwqzz#:#:T#:#:"J"J"Jrc"g|] }|fi Srr)rr r/rs rrzsymbols..s'"A"A"Aa33q>>D>>"A"A"Arr) isinstancer%rangelenpopchrr appendrendswithrstrip ValueErrorsplitallr_range startswith enumerater)digitsintr*indexcartesextendtuplesymbolstype)namesr/resultmarkerilitlit_charas_seqr namesymbolr:r r'brrrs ` @@@rrErE sTF%]#(((s8}}%% 5 5A,,q//Ce||&kkU**aKF&kkU**v;;!  c8443qrr7 3444       $$  (#2#J%%''E 1/00 065EKK$4$4555$$e$$$$$ ><== =s5zzA~r2.. / /A#Ahnn..E!QU(OOhhuf%%hhuf%%, C, CD 3 !1222$WWT]]33d33 f%%%LL&&E3u::>** 4 44aU1X__a!e --c22.=a!e //44.=$)Q<#4E!a%L#(Q<#3E!a%L!%(( C C1!88u~~c**>()<===773<t |t r||j|<n ||~n#~wxYw|S)a Create symbols and inject them into the global namespace. INPUT: - s -- a string, either a single variable name, or - a space separated list of variable names, or - a list of variable names. 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 symengine import var >>> var('x') x >>> x x >>> var('a,ab,abc') (a, ab, abc) >>> abc abc See :func:`symbols` documentation for more details on what kinds of arguments can be passed to :func:`var`. c|D]@}t|tr||j|<4||AdS)z4Recursively inject symbols to the global namespace. N)r1r f_globals__str__)rEframerOtraverses rrVzvar..traverses^ ( (F&%(( (4: 0 011''''  ( (rr) currentframe)inspectrWf_backrEr1rrSrT)rGr/rWrUsymsrVs @rvarr[s@(((((%$$$$$ LNN !E u%%%%  $&& &26 //u%%% EE Ks A A,,A/ceZdZdZdS) NotIterablez Use this as mixin when creating a class which is not supposed to return true when iterable() is called on its instances. I.e. avoid infinite loop when calling e.g. list() on the instance N)__name__ __module__ __qualname____doc__rrrr]r]s  Drr]cp t|n#t$rYdSwxYw|rt|| SdS)a Return a boolean indicating whether ``i`` is SymPy iterable. True also indicates that the iterator is finite, i.e. you e.g. call list(...) on the instance. When SymPy is working with iterables, it is almost always assuming that the iterable is not a string or a mapping, so those are excluded by default. If you want a pure Python definition, make exclude=None. To exclude multiple items, pass them as a tuple. FT)iter TypeErrorr1)rJexcludes riterablerfsV Q uu*a)))) 4s   c@t|dot|S)a Return a boolean indicating whether ``i`` is a sequence in the SymPy sense. If anything that fails the test below should be included as being a sequence for your application, set 'include' to that object's type; multiple types should be passed as a tuple of types. __getitem__)hasattrrf)rJs r is_sequencerjs 1m $ $ 4!4r)lib.symengine_wrapperrr itertoolsrrrrBre_rer)syscompiler<rEr[r]r%dictrfrjrrrrrs00000000LLLLLLLLLLLL  9 : :i#i#i#X:::z        dK0(55555r