ó ”¼™\c@ s£ddlmZmZddlmZddlmZmZmZm Z ddl m Z ddl m Z ddl mZddlmZmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlZddlZ ddl!Z!dd„Z#de$dd„Z%deefd„ƒYZ&de&fd„ƒYZ'de&fd„ƒYZ(e j)dƒZ*d„Z+d„Z,d„Z-dS(i’’’’(tprint_functiontdivision(t StdFactKB(t string_typestranget is_sequencetorderedi(tBasic(tsympify(tS(tExprt AtomicExpr(tcacheit(t FunctionClass(t fuzzy_bool(tBoolean(tcartes(tTupleNcK sXt|tƒr5|r(|j|kr(|St||St|tƒrH|Stdƒ‚dS(sżReturn 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, Dummy >>> 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 s/symbol must be string for symbol name or SymbolN(t isinstanceRtnametSymbolt ValueError(tstmatching_symbolt assumptions((s0lib/python2.7/site-packages/sympy/core/symbol.pyt_symbols9 c sŻd}t|ƒr!|\}}nt|ƒ‰|sCtˆ||St|ƒs[|g}ntƒjg|D]}|j^qkŒ}|dkr›d„}nx/t‡‡fd†|DƒƒrĢ|ˆƒ‰qžWtˆ||S(søReturn a symbol which, when printed, will have a name unique from any other already in the expressions given. The name is made unique by prepending underscores (default) but this can be customized with the keyword 'modify'. Parameters ========== xname : a string or a Symbol (when symbol xname <- str(xname)) compare : a single arg function that takes a symbol and returns a string to be compared with xname (the default is the str function which indicates how the name will look when it is printed, e.g. this includes underscores that appear on Dummy symbols) modify : a single arg function that changes its string argument in some way (the default is to preppend underscores) Examples ======== >>> from sympy.core.symbol import _uniquely_named_symbol as usym, Dummy >>> from sympy.abc import x >>> usym('x', x) _x cS sd|S(Nt_((R((s0lib/python2.7/site-packages/sympy/core/symbol.pyt}tc3 s!|]}ˆˆ|ƒkVqdS(N((t.0R(tcomparetx(s0lib/python2.7/site-packages/sympy/core/symbol.pys ~sN(tNoneRtstrRtsettuniont free_symbolstany(txnametexprsRtmodifyRtdefaulttetsyms((RRs0lib/python2.7/site-packages/sympy/core/symbol.pyt_uniquely_named_symbolYs    (  "RcB seZdZeZdgZeZeZe d„ƒZ e dd„ƒZ d„Zd„Ze eƒZe eeƒƒZd„Zd„Zd„Zd „Ze d „ƒZedd „ƒZd „Zed „Zd„Zd„Ze d„ƒZeZd„ZRS(sC Assumptions: commutative = True You can override the default assumptions in the constructor: >>> from sympy import symbols >>> A,B = symbols('A,B', commutative = False) >>> bool(A*B != B*A) True >>> bool(A*B*2 == 2*A*B) == True # multiplication by scalars is commutative True RcC stS(sĮAllow derivatives wrt Symbols. Examples ======== >>> from sympy import Symbol >>> x = Symbol('x') >>> x._diff_wrt True (tTrue(tself((s0lib/python2.7/site-packages/sympy/core/symbol.pyt _diff_wrtšs c C sbt|jdtƒƒ}|dkrP|r7d|jnd}td|ƒ‚nx t|jƒƒD]÷}ddlm }ddl m }|d„ƒ}|j id d 6d d 6d d6ƒ||r!|dd|dd||ddddƒj ƒ|||||<|j|ƒ||}n||}|dkrJ|j|ƒqcnt|ƒ||>> from sympy import Symbol >>> Symbol("x") == Symbol("x") True >>> Symbol("x", real=True) == Symbol("x", real=False) False (RMRt_Symbol__xnew_cached_(tclsRR((s0lib/python2.7/site-packages/sympy/core/symbol.pyt__new__Źs cK s“t|tƒs.tdtt|ƒƒƒ‚ntj|ƒ}||_|jƒ}t |j dt ƒƒ}||ds (tdictRUR^(R.((s0lib/python2.7/site-packages/sympy/core/symbol.pyR]s cC s1|jƒdt|ƒfftjjƒtjfS(Ni(t class_keyR!R Rdtsort_key(R.torder((s0lib/python2.7/site-packages/sympy/core/symbol.pyRlscC s t|jƒS(N(tDummyR(R.((s0lib/python2.7/site-packages/sympy/core/symbol.pytas_dummy scK sIddlm}m}|jdƒ|kr/dS||ƒ||ƒfSdS(Ni’’’’(timtretignore(tsympyRpRqR=R (R.tdeepthintsRpRq((s0lib/python2.7/site-packages/sympy/core/symbol.pyt as_real_imagscC sddlj}|j|jƒS(Ni’’’’(tsage.alltalltvarR(R.tsage((s0lib/python2.7/site-packages/sympy/core/symbol.pyt_sage_scO s|s tS||kS(N(Re(R.twrttflags((s0lib/python2.7/site-packages/sympy/core/symbol.pyt is_constantscC s|hS(N((R.((s0lib/python2.7/site-packages/sympy/core/symbol.pyR$scC stjS(N(R t UniversalSet(R.((s0lib/python2.7/site-packages/sympy/core/symbol.pytas_set%sN( R>t __module__t__doc__Ret is_comparablet __slots__R-t is_Symbolt is_symboltpropertyR/t staticmethodR RMRPRXt__xnew__R RNRYRZR_RfR]RlRoRvR{R~R$tbinary_symbolsR€(((s0lib/python2.7/site-packages/sympy/core/symbol.pyRƒs8 !          RncB sxeZdZdZejƒZejd dd ƒZdgZ e Z d d d„Z d„Zed d„ƒZd „ZRS( s—Dummy symbols are each unique, even if they have the same name: >>> 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 ii ii t dummy_indexcK s©|dk r'|dk s'tdƒ‚n|dkrIdttjƒ}n|dkrwtjtj}tjd7_n|j||ƒtj|||}||_ |S(Ns:If you specify a dummy_index, you must also provide a nametDummy_i( R tAssertionErrorR!Rnt_countt_base_dummy_indexRMRR‰R‹(RORR‹RRG((s0lib/python2.7/site-packages/sympy/core/symbol.pyRPLs    cC si|jd6|jd6S(NRUR‹(RUR‹(R.((s0lib/python2.7/site-packages/sympy/core/symbol.pyRZ^scC s7|jƒdt|ƒ|jfftjjƒtjfS(Ni(RkR!R‹R RdRl(R.Rm((s0lib/python2.7/site-packages/sympy/core/symbol.pyRlas cC stj|ƒ|jfS(N(RR_R‹(R.((s0lib/python2.7/site-packages/sympy/core/symbol.pyR_fsi@Bi@BN(R>RR‚RŽtrandomtRandomt_prngtrandintRR„R-tis_DummyR RPRZR RlR_(((s0lib/python2.7/site-packages/sympy/core/symbol.pyRn)s    tWildcB seeZdZeZddgZdd d„Zd„Zee d„ƒƒZ d„Z ie d„Z RS( s 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 didn't 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} texcludet propertiescK sZtg|D]}t|ƒ^q ƒ}t|ƒ}|j||ƒtj|||||S(N(R[RRMR•R‰(RORR–R—RR((s0lib/python2.7/site-packages/sympy/core/symbol.pyRPÅs% cC s|j|j|jfS(N(RR–R—(R.((s0lib/python2.7/site-packages/sympy/core/symbol.pyRYĖscK s+tj|||}||_||_|S(N(RR‰R–R—(RORR–R—RRG((s0lib/python2.7/site-packages/sympy/core/symbol.pyR‰Īs  cC s#tt|ƒjƒ|j|jfS(N(tsuperR•R_R–R—(R.((s0lib/python2.7/site-packages/sympy/core/symbol.pyR_Ösc s`t‡fd†|jDƒƒr#dSt‡fd†|jDƒƒrFdS|jƒ}ˆ||<|S(Nc3 s|]}ˆj|ƒVqdS(N(thas(RR(texpr(s0lib/python2.7/site-packages/sympy/core/symbol.pys Ūsc3 s|]}|ˆƒ VqdS(N((Rtf(Rš(s0lib/python2.7/site-packages/sympy/core/symbol.pys Żs(R%R–R R—RT(R.Ršt repl_dictRg((Ršs0lib/python2.7/site-packages/sympy/core/symbol.pytmatchesŚs  (((R>RR‚R-tis_WildR„RPRYRˆR R‰R_ReR(((s0lib/python2.7/site-packages/sympy/core/symbol.pyR•jsV   s"([0-9]*:[0-9]+|[a-zA-Z]?:[a-zA-Z])c s>g}t|tƒrd}dddg‰xšttˆƒƒD]†}ˆjdƒ}||kr=x t|ƒ|kr€|d7}qaWt|ƒ}|d7}|j||ƒ}ˆj||dfƒq=q=W‡fd†}|jƒ}|j dƒ}|r |d j ƒ}n|st d ƒ‚ng|j dƒD]} | jƒ^q/}t d „|Dƒƒslt d ƒ‚nx?tt|ƒdddƒD]!}||j ƒ|||d+q‰W|jd tƒ} |jd |ƒ} xł|D]ń} | sōt dƒ‚nd| kr(| || ƒ|} |j| ƒqŁntj | ƒ}x©tt|ƒdƒD]‘}|rNd||krN||dkrN||dj dƒrN||djdƒrN||dd ||d<||dd||d>> 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]) is\,s\:s\ ic s6ˆr2x)ˆD]\}}|j||ƒ}q Wn|S(N(treplace(Rtctl(tliterals(s0lib/python2.7/site-packages/sympy/core/symbol.pytliteralhst,i’’’’sno symbols givencs s|] }|VqdS(N((Rtn((s0lib/python2.7/site-packages/sympy/core/symbol.pys wssmissing symbol between commasROtseqsmissing symbolt:t(t)smissing end rangetaRN((RRRtlenREtchrRŸtappendtstriptendswithtrstripRtsplitRxRt_ranget startswitht enumeratetstringtdigitstintR!t ascii_letterstindexR-RtjointextendR[tsymbolsRS(tnamestargstresulttmarkertitlittlit_charR£tas_seqR„ROR¦RtsymbolR±RRŖtbR ((R¢s0lib/python2.7/site-packages/sympy/core/symbol.pyR¼ęst    (#   &!  / 4  (2-  c s©‡fd†‰ddlm}|ƒj}zst||}|dk rt|tƒrk||j|j>> from sympy import var >>> var('x') x >>> x x >>> var('a,ab,abc') (a, ab, abc) >>> abc abc >>> var('x,y', real=True) (x, y) >>> x.is_real and y.is_real True See :func:`symbol` documentation for more details on what kinds of arguments can be passed to :func:`var`. c sfx_|D]W}t|tƒr/||j|j(R¼tframeRÅ(ttraverse(s0lib/python2.7/site-packages/sympy/core/symbol.pyRÉŪs  i’’’’(t currentframeN( tinspectRŹtf_backR¼R RRRĒRR R>(R½R¾RŹRČR+((RÉs0lib/python2.7/site-packages/sympy/core/symbol.pyRy»s    c G sUt|Œ}d„}t|jd|ƒ}i}x6|D].}|jt|ƒjdƒgƒj|ƒq7Wi}xÖ|D]Ī}td|||dj}||kr»||||d>> 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) cS stt|jjƒƒƒS(N(R[R\R]R^(R((s0lib/python2.7/site-packages/sympy/core/symbol.pyR RR@Rs%siis%s_%i( RRR$t setdefaultR!tlstripR­RR]RR«R-txreplace( titertnew_iterRJR+tmappingRtrepstktk0tskipRĮRtki((s0lib/python2.7/site-packages/sympy/core/symbol.pyt disambiguate÷s*(   ,     ((.t __future__RRtsympy.core.assumptionsRtsympy.core.compatibilityRRRRtbasicRRt singletonR RšR R tcacheR tfunctionR tsympy.core.logicRtsympy.logic.boolalgRtsympy.utilities.iterablesRtsympy.core.containersRRµRqt_reRR RR!R,RRnR•tcompileR²R¼RyRŲ(((s0lib/python2.7/site-packages/sympy/core/symbol.pyts0"    C*¦Az Õ <