ó ~9­\c@ sÃdZddlmZmZddlZddlmZddlmZddl Z e j ddkZ e rwe fZ efZefZeZe jZeZeZd„ZeZejd ƒZejd ƒZejd ƒZddlZdd lm Z dd l!m"Z"e"Z#e$edƒZ%e&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/ddl0m1Z1n6ddl2Z2ddl3Z3e e3j4fZ eefZeefZeZe j5ZeZeZd„Zdefd„ƒYZejdƒZejdƒZejdƒZddl6Ze Z dd l"m"Z"dd l#m"Z#ddd„Z%e8Z&ddlm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-dd„Z/ej9d„Z1d„Z:ddHd„ƒYZ;ee<e;fd„Z=dd„Z>ydd l0m?Z?Wn!e@k r!dd!l0mAZ?nXydd"lBmCZCWne@k rRejCZCnXeDd#„ZEdd$„ZFd%„ZGdeDeHd&„ZIdd'„ZJeJd(d)ƒjKƒZLdZMeLd*kr4eLd+krõed,d-d.d/d0d1dIƒZNeNrûdZMqûnd2ZLeMs4ed2d-d3d/d0d1dJƒZNeNr1d4ZMq1q4neLd)krXeMrOd2ZLqXd*ZLneLd2krŽeM rŽdd5lOmPZPePd6ƒd*ZLneZQeLd2kr¿eQe eNjRdƒƒf7ZQndd7lmSZSdd8lmTZTdd9lUmVZVeSd:d;d<d=d>gƒZWd?eXfd@„ƒYZYeƒfeZeee[e dƒfƒe\e]e e^dA„Z_dBeHdC„Z`e j d dKkrŽddElm`Z`nyddFl0maZaWne@k r¾dG„ZanXdS(Ls® Reimplementations of constructs introduced in later versions of Python than we support. Also some functions that are needed SymPy-wide and are located here for easy import. iÿÿÿÿ(tprint_functiontdivisionN(t defaultdict(t import_moduleiicC s|S(N((tx((s7lib/python2.7/site-packages/sympy/core/compatibility.pytu_decodeNst__code__t __globals__t__name__(treduce(tStringIOtexec(tMappingtCallabletMutableMappingt MutableSettIterabletHashable(tunwrap(t accumulatecC s |jdƒS(Nsutf-8(tdecode(R((s7lib/python2.7/site-packages/sympy/core/compatibility.pyRtstIteratorcB seZd„ZRS(cC st|ƒj|ƒS(N(ttypet__next__(tself((s7lib/python2.7/site-packages/sympy/core/compatibility.pytnextxs(Rt __module__R(((s7lib/python2.7/site-packages/sympy/core/compatibility.pyRwst func_codet func_globalst func_namecB sc|dkrBejdƒ}|j}|dkr<|j}n~n|dkrW|}nddUdS(sExecute code in a namespace.isexec _code_ in _globs_, _locs_N(tNonetsyst _getframet f_globalstf_locals(t_code_t_globs_t_locs_tframe((s7lib/python2.7/site-packages/sympy/core/compatibility.pytexec_…s      c s™ˆdkrd„}n‡fd†}|}t|ƒh}xV||ƒr”|j}t|ƒ}||kr„tdj|ƒƒ‚n|j|ƒq?W|S(s–Get the object wrapped by *func*. Follows the chain of :attr:`__wrapped__` attributes returning the last object in the chain. *stop* is an optional callback accepting an object in the wrapper chain as its sole argument that allows the unwrapping to be terminated early if the callback returns a true value. If the callback never returns a true value, the last object in the chain is returned as usual. For example, :func:`signature` uses this to stop unwrapping if any object in the chain has a ``__signature__`` attribute defined. :exc:`ValueError` is raised if a cycle is encountered. cS s t|dƒS(Nt __wrapped__(thasattr(tf((s7lib/python2.7/site-packages/sympy/core/compatibility.pyt _is_wrapper¦sc st|dƒoˆ|ƒ S(NR((R)(R*(tstop(s7lib/python2.7/site-packages/sympy/core/compatibility.pyR+©ss!wrapper loop when unwrapping {!r}N(RtidR(t ValueErrortformattadd(tfuncR,R+R*tmemotid_func((R,s7lib/python2.7/site-packages/sympy/core/compatibility.pyR•s     cc s<|d}|Vx&|dD]}|||ƒ}|VqWdS(Nii((titerableR1tstateti((s7lib/python2.7/site-packages/sympy/core/compatibility.pyRµs  c s5dˆf‡‡fd†ƒY}tj|ddiƒS(s Create a base class with a metaclass. For example, if you have the metaclass >>> class Meta(type): ... pass Use this as the metaclass by doing >>> from sympy.core.compatibility import with_metaclass >>> class MyClass(with_metaclass(Meta, object)): ... pass This is equivalent to the Python 2:: class MyClass(object): __metaclass__ = Meta or Python 3:: class MyClass(object, metaclass=Meta): pass That is, the first argument is the metaclass, and the remaining arguments are the base classes. Note that if the base class is just ``object``, you may omit it. >>> MyClass.__mro__ (, <... 'object'>) >>> type(MyClass) t metaclassc seZ‡‡fd†ZRS(c sˆ|ˆ|ƒS(N((tclstnamet this_basestd(tbasestmeta(s7lib/python2.7/site-packages/sympy/core/compatibility.pyt__new__ås(RRR>((R<R=(s7lib/python2.7/site-packages/sympy/core/compatibility.pyR7ästNewBase((RR>(R=R<R7((R<R=s7lib/python2.7/site-packages/sympy/core/compatibility.pytwith_metaclass½s't NotIterablecB seZdZRS(sÌ 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 (RRt__doc__(((s7lib/python2.7/site-packages/sympy/core/compatibility.pyRAïscC sQt|dƒr|jSyt|ƒWntk r8tSX|rMt||ƒ StS(sZ 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. You can also set the _iterable attribute to True or False on your class, which will override the checks here, including the exclude test. As a rule of thumb, some SymPy functions use this to check if they should recursively map over an object. If an object is technically iterable in the Python sense but does not desire this behavior (e.g., because its iteration is not finite, or because iteration might induce an unwanted computation), it should disable it by setting the _iterable attribute to False. See also: is_sequence Examples ======== >>> from sympy.utilities.iterables import iterable >>> from sympy import Tuple >>> things = [[1], (1,), set([1]), Tuple(1), (j for j in [1, 2]), {1:2}, '1', 1] >>> for i in things: ... print('%s %s' % (iterable(i), type(i))) True <... 'list'> True <... 'tuple'> True <... 'set'> True True <... 'generator'> False <... 'dict'> False <... 'str'> False <... 'int'> >>> iterable({}, exclude=None) True >>> iterable({}, exclude=str) True >>> iterable("no", exclude=str) False t _iterable(R)RCtitert TypeErrortFalset isinstancetTrue(R6texclude((s7lib/python2.7/site-packages/sympy/core/compatibility.pyR4÷s/ cC s4t|dƒrt|ƒp3t|ƒo3t||ƒS(sÞ 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. Note: although generators can generate a sequence, they often need special handling to make sure their elements are captured before the generator is exhausted, so these are not included by default in the definition of a sequence. See also: iterable Examples ======== >>> from sympy.utilities.iterables import is_sequence >>> from types import GeneratorType >>> is_sequence([]) True >>> is_sequence(set()) False >>> is_sequence('abc') False >>> is_sequence('abc', include=str) True >>> generator = (c for c in 'abc') >>> is_sequence(generator) False >>> is_sequence(generator, include=(str, GeneratorType)) True t __getitem__(R)R4tboolRG(R6tinclude((s7lib/python2.7/site-packages/sympy/core/compatibility.pyt is_sequence1s"  (t zip_longest(t izip_longest(t maketranscC sŠddlm}yO|r9t|t|fƒ r9t‚nt|ƒ}||krZt‚n|SWn$tk r…td|fƒ‚nXdS(sn Convert the argument to a builtin integer. The return value is guaranteed to be equal to the input. ValueError is raised if the input has a non-integral value. When ``strict`` is False, non-integer input that compares equal to the integer value will not raise an error. Examples ======== >>> from sympy.core.compatibility import as_int >>> from sympy import sqrt, S The function is primarily concerned with sanitizing input for functions that need to work with builtin integers, so anything that is unambiguously an integer should be returned as an int: >>> as_int(S(3)) 3 Floats, being of limited precision, are not assumed to be exact and will raise an error unless the ``strict`` flag is False. This precision issue becomes apparent for large floating point numbers: >>> big = 1e23 >>> type(big) is float True >>> big == int(big) True >>> as_int(big) Traceback (most recent call last): ... ValueError: ... is not an integer >>> as_int(big, strict=False) 99999999999999991611392 Input that might be a complex representation of an integer value is also rejected by default: >>> one = sqrt(3 + 2*sqrt(2)) - sqrt(2) >>> int(one) == 1 True >>> as_int(one) Traceback (most recent call last): ... ValueError: ... is not an integer iÿÿÿÿ(tIntegers%s is not an integerN(tsympy.core.numbersRQRGt SYMPY_INTSREtintR.(tntstrictRQtresult((s7lib/python2.7/site-packages/sympy/core/compatibility.pytas_intes2     c C s½ddlm}ddlm}ddlm}m}ddlm}t||ƒre|j d|ƒS||dt ƒr't|t ƒr›|j ƒ}t }n0t|tƒr¹|}t }nt|ƒ}t}g|D]} t| d|ƒ^qÒ}|rt|ƒ}ndt|ƒt|ƒf} }nkt|t ƒsvy||ƒ}Wn|k rYqvXt||ƒrvt|ƒSnd dt|ƒff} }| d |jjf||jj ƒ|jfS( s¥Return a key that can be used for sorting. The key has the structure: (class_key, (len(args), args), exponent.sort_key(), coefficient) This key is supplied by the sort_key routine of Basic objects when ``item`` is a Basic object or an object (other than a string) that sympifies to a Basic object. Otherwise, this function produces the key. The ``order`` argument is passed along to the sort_key routine and is used to determine how the terms *within* an expression are ordered. (See examples below) ``order`` options are: 'lex', 'grlex', 'grevlex', and reversed values of the same (e.g. 'rev-lex'). The default order value is None (which translates to 'lex'). Examples ======== >>> from sympy import S, I, default_sort_key, sin, cos, sqrt >>> from sympy.core.function import UndefinedFunction >>> from sympy.abc import x The following are equivalent ways of getting the key for an object: >>> x.sort_key() == default_sort_key(x) True Here are some examples of the key that is produced: >>> default_sort_key(UndefinedFunction('f')) ((0, 0, 'UndefinedFunction'), (1, ('f',)), ((1, 0, 'Number'), (0, ()), (), 1), 1) >>> default_sort_key('1') ((0, 0, 'str'), (1, ('1',)), ((1, 0, 'Number'), (0, ()), (), 1), 1) >>> default_sort_key(S.One) ((1, 0, 'Number'), (0, ()), (), 1) >>> default_sort_key(2) ((1, 0, 'Number'), (0, ()), (), 2) While sort_key is a method only defined for SymPy objects, default_sort_key will accept anything as an argument so it is more robust as a sorting key. For the following, using key= lambda i: i.sort_key() would fail because 2 doesn't have a sort_key method; that's why default_sort_key is used. Note, that it also handles sympification of non-string items likes ints: >>> a = [2, I, -I] >>> sorted(a, key=default_sort_key) [2, -I, I] The returned key can be used anywhere that a key can be specified for a function, e.g. sort, min, max, etc...: >>> a.sort(key=default_sort_key); a[0] 2 >>> min(a, key=default_sort_key) 2 Note ---- The key returned is useful for getting items into a canonical order that will be the same across platforms. It is not directly useful for sorting lists of expressions: >>> a, b = x, 1/x Since ``a`` has only 1 term, its value of sort_key is unaffected by ``order``: >>> a.sort_key() == a.sort_key('rev-lex') True If ``a`` and ``b`` are combined then the key will differ because there are terms that can be ordered: >>> eq = a + b >>> eq.sort_key() == eq.sort_key('rev-lex') False >>> eq.as_ordered_terms() [x, 1/x] >>> eq.as_ordered_terms('rev-lex') [1/x, x] But since the keys for each of these terms are independent of ``order``'s value, they don't sort differently when they appear separately in a list: >>> sorted(eq.args, key=default_sort_key) [1/x, x] >>> sorted(eq.args, key=lambda i: default_sort_key(i, order='rev-lex')) [1/x, x] The order of terms obtained when using these keys is the order that would be obtained if those terms were *factors* in a product. Although it is useful for quickly putting expressions in canonical order, it does not sort expressions based on their complexity defined by the number of operations, power of variables and others: >>> sorted([sin(x)*cos(x), sin(x)], key=default_sort_key) [sin(x)*cos(x), sin(x)] >>> sorted([x, x**2, sqrt(x), x**3], key=default_sort_key) [sqrt(x), x, x**2, x**3] See Also ======== ordered, sympy.core.expr.as_ordered_factors, sympy.core.expr.as_ordered_terms i(tS(tBasic(tsympifyt SympifyError(R4torderRIi i(t singletonRYtbasicRZR[R\t compatibilityR4RGtsort_keyt string_typestdicttitemsRHtsettlistRFtdefault_sort_keytsortedtlenttupletstrt __class__RtOne( titemR]RYRZR[R\R4targst unorderedtargt cls_index((s7lib/python2.7/site-packages/sympy/core/compatibility.pyRg£s:s    %"  cC s…ddlm}t||ƒr,|j|ƒSt|ƒrPdtd„|DƒƒSt|tƒr}dtd„|jƒDƒƒSdSdS(s  A helper for ordered() which returns the node count of ``e`` which for Basic objects is the number of Basic nodes in the expression tree but for other objects is 1 (unless the object is an iterable or dict for which the sum of nodes is returned). i(RZcs s|]}t|ƒVqdS(N(t_nodes(t.0tei((s7lib/python2.7/site-packages/sympy/core/compatibility.pys Qscs s+|]!\}}t|ƒt|ƒVqdS(N(Rs(Rttktv((s7lib/python2.7/site-packages/sympy/core/compatibility.pys SsN(R_RZRGtcountR4tsumRcRd(teRZ((s7lib/python2.7/site-packages/sympy/core/compatibility.pyRsEs  c c s¬ttƒ}|ryt|ttfƒs3|g}nt|ƒ}|jdƒ}xN|D]}|||ƒj|ƒqUWn&|sŽtdƒ‚n|d j|ƒxt |j ƒƒD]ò}t ||ƒdkr}|rôt |||||ƒ||>> from sympy.utilities.iterables import ordered >>> from sympy import count_ops >>> from sympy.abc import x, y The count_ops is not sufficient to break ties in this list and the first two items appear in their original order (i.e. the sorting is stable): >>> list(ordered([y + 2, x + 2, x**2 + y + 3], ... count_ops, default=False, warn=False)) ... [y + 2, x + 2, x**2 + y + 3] The default_sort_key allows the tie to be broken: >>> list(ordered([y + 2, x + 2, x**2 + y + 3])) ... [x + 2, y + 2, x**2 + y + 3] Here, sequences are sorted by length, then sum: >>> seq, keys = [[[1, 2, 1], [0, 3, 1], [1, 1, 3], [2], [1]], [ ... lambda x: len(x), ... lambda x: sum(x)]] ... >>> list(ordered(seq, keys, default=False, warn=False)) [[1], [2], [1, 2, 1], [0, 3, 1], [1, 1, 3]] If ``warn`` is True, an error will be raised if there were not enough keys to break ties: >>> list(ordered(seq, keys, default=False, warn=True)) Traceback (most recent call last): ... ValueError: not enough keys to break ties Notes ===== The decorated sort is one of the fastest ways to sort a sequence for which special item comparison is desired: the sequence is decorated, sorted on the basis of the decoration (e.g. making all letters lower case) and then undecorated. If one wants to break ties for items that have the same decorated value, a second key can be used. But if the second key is expensive to compute then it is inefficient to decorate all items with both keys: only those items having identical first key values need to be decorated. This function applies keys successively only when needed to break ties. By yielding an iterator, use of the tie-breaker is delayed as long as possible. This function is best used in cases when use of the first key is expected to be a good hashing function; if there are no unique hashes from application of a key then that key should not have been used. The exception, however, is that even if there are many collisions, if the first group is small and one does not need to process all items in the list then time will not be wasted sorting what one was not interested in. For example, if one were looking for the minimum in a list and there were several criteria used to define the sort order, then this function would be good at returning that quickly if the first group of candidates is small relative to the number of items being processed. is+if default=False then keys must be provideditdefaulttwarniÿÿÿÿ(tuniqs!not enough keys to break ties: %sN(RRfRGRjtpoptappendR.RtextendRhtkeysRitorderedRsRgRFtsympy.utilities.iterablesR}( tseqRR{R|R;R*taRvR}tuRw((s7lib/python2.7/site-packages/sympy/core/compatibility.pyR‚Xs6P      cC sddlm}|||ƒS(Niÿÿÿÿ(tgetenv(tosR‡(tkeyR{R‡((s7lib/python2.7/site-packages/sympy/core/compatibility.pyt_getenvÑstSYMPY_GROUND_TYPEStautotpythontgmpy1tgmpy2tmin_module_versions2.0.0tmodule_version_attrtversiontmodule_version_attr_call_argstgmpys1.13i(R|sAgmpy library is not installed, switching to 'python' ground types(t namedtuple(tupdate_wrapper(tRLockt CacheInfothitstmissestmaxsizetcurrsizet _HashedSeqcB s#eZdZed„Zd„ZRS(t hashvaluecC s||(||ƒ|_dS(N(Rž(Rttupthash((s7lib/python2.7/site-packages/sympy/core/compatibility.pyt__init__ scC s|jS(N(Rž(R((s7lib/python2.7/site-packages/sympy/core/compatibility.pyt__hash__s(RRt __slots__R R¡R¢(((s7lib/python2.7/site-packages/sympy/core/compatibility.pyRs c  sÒ|} |rF||jƒƒ} | |7} x| D]} | | 7} q/Wn|r˜| |‡fd†|Dƒƒ7} |rÈ| |‡fd†| Dƒƒ7} qÈn0|| ƒdkrȈ| dƒ|krÈ| dSt| ƒS(sGMake a cache key from optionally typed positional and keyword argumentsc3 s|]}ˆ|ƒVqdS(N((RtRw(R(s7lib/python2.7/site-packages/sympy/core/compatibility.pys sc3 s!|]\}}ˆ|ƒVqdS(N((RtRvRw(R(s7lib/python2.7/site-packages/sympy/core/compatibility.pys sii(RdR( Rotkwdsttypedtkwd_markt fasttypesRhRjRRiR‰t sorted_itemsRn((Rs7lib/python2.7/site-packages/sympy/core/compatibility.pyt _make_keys   &(idc s‡‡fd†}|S(sœLeast-recently-used cache decorator. If *maxsize* is set to None, the LRU features are disabled and the cache can grow without bound. If *typed* is True, arguments of different types will be cached separately. For example, f(3.0) and f(3) will be treated as distinct calls with distinct results. Arguments to the cached function must be hashable. View the cache statistics named tuple (hits, misses, maxsize, currsize) with f.cache_info(). Clear the cache and statistics with f.cache_clear(). Access the underlying function with f.__wrapped__. See: https://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used c sgtƒ‰ddg‰ d \‰‰t‰ ˆj‰t‰tƒ‰ g‰ ˆ ˆ ddgˆ (ˆ g‰ d \‰‰‰‰ˆdkr—‡‡ ‡fd†}nrˆdkr͇‡‡‡‡ ‡ ‡ ‡‡f d†}n<‡‡‡‡‡‡‡‡‡‡ ‡ ‡‡ ‡ ‡‡fd†}‡‡‡‡ ‡‡ fd†}‡‡ ‡ ‡ fd †}ˆ|_||_||_t |ˆƒS( Niiiic s#ˆ||Ž}ˆˆcd7<|S(Ni((RoR¤RW(tMISSEStstatst user_function(s7lib/python2.7/site-packages/sympy/core/compatibility.pytwrapperMsc snˆ||ˆƒ}ˆ|ˆƒ}|ˆk rAˆˆcd7<|Sˆ||Ž}|ˆ|<ˆˆcd7<|S(Ni((RoR¤R‰RW( tHITSRªtcachet cache_gettmake_keytrootR«R¥R¬(s7lib/python2.7/site-packages/sympy/core/compatibility.pyR­Us  c  säy(|sˆr!ˆ ||ˆƒn|}Wn+tk rUˆ ˆcd7<ˆ||ŽSXˆ ˆ|ƒ}|dk rèˆ \}|\}}}}||ˆ<||ˆ<|ˆ}||ˆ<|ˆ<||ˆ<||ˆ<ˆ ˆcd7<|SWdQXˆ||Ž}ˆ Ûˆ \}|ˆkrn®ˆˆƒˆ kr”|} || ˆ<|| ˆ<| ˆ}ˆ d<|ˆ} |ˆ} d|ˆ<|ˆ<ˆ| =| ˆ|³t(tfilter(RÉtitr((RÉs7lib/python2.7/site-packages/sympy/core/compatibility.pyRȲs((((ii(bRBt __future__RRtoperatort collectionsRtsympy.externalRRt version_infotPY3Rt class_typesRTt integer_typesRkRbtlongtint_infotunicodetchrtunichrRtobjectRt attrgettertget_function_codetget_function_globalstget_function_nametbuiltinst functoolsR tioR t cStringIOtgetattrR'trangetcollections.abcR R RRRRtinspectRt itertoolsRtcodecsttypest ClassTypet long_infot __builtin__RtxrangeR0R@RARcR4RMRNt ImportErrorROtstringRPRHRXRgRsRFR‚RŠtlowert GROUND_TYPEStHAS_GMPYR”twarningsR|RStmpzR•R–t threadingR—RÁRfRRet frozensetRhRjRiR©RÇRÈ(((s7lib/python2.7/site-packages/sympy/core/compatibility.pytsØ 6       .        .  2: '    > ¢ y           ‡