~9\c@sddlmZmZmZmZmZmZmZmZm Z m Z m Z ddl m Z ddlmZmZmZddlmZddlmZmZddlmZmZddlmZddlmZmZmZm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-ddl.m/Z/ddl0m1Z1dZ2dZ3dZ4e5dZ6dZ7dZ8dZ9defdYZ:e:Z;dS(i( tOrdertStlogtlimittlcm_listtpitAbstimtretSymboltDummy(tBasic(tAddtMultPow(tAnd(t AtomicExprtExpr(t _sympifyittoo(t_sympify(tIntervalt Intersectiont FiniteSettUniont ComplementtEmptySet(t ConditionSet(tMintMax(t filldedent(tdenom(ttogether(titerable(tsolve_univariate_inequalityc CsAddlm}ddlm}m}|jtjr|}xn|jt D]]}|||\}} |rN| dkrN||j dk|j } t | |}qNqNWxH|jt D]7}||jddk|j } t | |}qW|}ny|jtrJ|d||||tt|||} nx|jt D]c}|||\}} |rZ| dkrZ|d||||tt|||} PqZqZWt |d||||tt|||} Wn<tk r8ddl} tdd| jdfnX|| S( s" Returns the intervals in the given domain for which the function is continuous. This method is limited by the ability to determine the various singularities and discontinuities of the given function. Parameters ========== f : Expr The concerned function. symbol : Symbol The variable for which the intervals are to be determined. domain : Interval The domain over which the continuity of the symbol has to be checked. Examples ======== >>> from sympy import Symbol, S, tan, log, pi, sqrt >>> from sympy.sets import Interval >>> from sympy.calculus.util import continuous_domain >>> x = Symbol('x') >>> continuous_domain(1/x, x, S.Reals) Union(Interval.open(-oo, 0), Interval.open(0, oo)) >>> continuous_domain(tan(x), x, Interval(0, pi)) Union(Interval.Ropen(0, pi/2), Interval.Lopen(pi/2, pi)) >>> continuous_domain(sqrt(x - 2), x, Interval(-5, 5)) Interval(2, 5) >>> continuous_domain(log(2*x - 1), x, S.Reals) Interval.open(1/2, oo) Returns ======= Interval Union of all intervals where the function is continuous. Raises ====== NotImplementedError If the method to determine continuity of such a function has not yet been developed. i(R"(tsolvesett_has_rational_poweriiiNsXMethods for determining the continuous domains of this function have not been developed.(tsympy.solvers.inequalitiesR"tsympy.solvers.solvesetR#R$t is_subsetRtRealstatomsRtbasetas_setRRtargsthasRRR tNotImplementedErrortsystNonetexc_info( tftsymboltdomainR"R#R$tconstrained_intervaltatomt predicatetdenomint constrainttsingsR/((s2lib/python2.7/site-packages/sympy/calculus/util.pytcontinuous_domainsF.  "#   c Cs{ddlm}t|tr&tjSt||}|tjkrTt|jS|dk rt|t r|j |j j rt d|}qqt|trxH|jD]:}t|t r|j |j j rt d|}qqWqnt|||}tj}t|t tfr0|f}n-t|trK|j}nttdx|D]} t| trx| D]1} | |kr|t|j|| 7}qqWqdt| t ratj} tj} tj} | j| j df| j| j dff}xe|D]]\}}}|rT| tt||||7} | | 7} q| t|j||7} qW||j||| }t|stdj|n| |7} x*| D]"}| t|j||7} qWtt}}| tjk r?| j | j kr!t}n| j | j kr?t}q?n|t | j | j ||7}qdttdqdW|S( s Finds the range of a function in a given domain. This method is limited by the ability to determine the singularities and determine limits. Parameters ========== f : Expr The concerned function. symbol : Symbol The variable for which the range of function is to be determined. domain : Interval The domain under which the range of the function has to be found. Examples ======== >>> from sympy import Symbol, S, exp, log, pi, sqrt, sin, tan >>> from sympy.sets import Interval >>> from sympy.calculus.util import function_range >>> x = Symbol('x') >>> function_range(sin(x), x, Interval(0, 2*pi)) Interval(-1, 1) >>> function_range(tan(x), x, Interval(-pi/2, pi/2)) Interval(-oo, oo) >>> function_range(1/x, x, S.Reals) Union(Interval.open(-oo, 0), Interval.open(0, oo)) >>> function_range(exp(x), x, S.Reals) Interval.open(0, oo) >>> function_range(log(x), x, S.Reals) Interval(-oo, oo) >>> function_range(sqrt(x), x , Interval(-5, 9)) Interval(0, 3) Returns ======= Interval Union of all ranges for all intervals under domain where function is continuous. Raises ====== NotImplementedError If any of the intervals, in the given domain, for which function is continuous are not finite or real, OR if the critical points of the function on the domain can't be found. i(R#isL Unable to find range for the given domain. t+t-s%Unable to find critical points for {}N(R&R#t isinstanceRRt periodicitytZeroRtexpandR0Rtinftsupt is_infiniteRR,R;R.Rtsubst left_opent right_openRtdiffR!tformattFalsetTrue(R2R3R4R#tperiodtsub_domt intervalst range_intt interval_itertintervalt singletontvalstcritical_pointstcritical_valuestboundstis_opent limit_pointt directiontsolutiontcritical_pointRFRG((s2lib/python2.7/site-packages/sympy/calculus/util.pytfunction_rangensn1        &            "c st|dkr!tdn|jr1tSt|trj|jd}tt|jd||St|tr|}t j }n|jd}|jd}t|tstdt ||fnt|dkr|dnt d|ffd}t|t rItg|D]}|||^q-St|trt j}xH|jD]=}tg|D]}|||^q{} t|| }qkW|SdS(sy Finds the domain of the functions in `finite_set` in which the `finite_set` is not-empty Parameters ========== finset_intersection : The unevaluated intersection of FiniteSet containing real-valued functions with Union of Sets syms : Tuple of symbols Symbol for which domain is to be found Raises ====== NotImplementedError The algorithms to find the non-emptiness of the given FiniteSet are not yet implemented. ValueError The input is not valid. RuntimeError It is a bug, please report it to the github issue tracker (https://github.com/sympy/sympy/issues). Examples ======== >>> from sympy import FiniteSet, Interval, not_empty_in, oo >>> from sympy.abc import x >>> not_empty_in(FiniteSet(x/2).intersect(Interval(0, 1)), x) Interval(0, 2) >>> not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x) Union(Interval(-sqrt(2), -1), Interval(1, 2)) >>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x) Union(Interval.Lopen(-2, -1), Interval(2, oo)) is*One or more symbols must be given in syms.is%A FiniteSet must be given, not %s: %ss&more than one variables %s not handledc s,ddlm}|j}|j}||jddtj}|jr|tjkrhtj}q|||kdtj}n|||kdtj}|j r|tj krtj}q |||kdtj}n|||kdtj}t ||}t ||} | S(s9 Finds the domain of an expression in any given interval i(R#iR4( R&R#tstarttendtas_numer_denomRR(RGtInfinityRFtNegativeInfinityRR( texprtintrvlR#t_startt_endt_singularitiest_domain1t_domain2texpr_with_singt expr_domain(tsymb(s2lib/python2.7/site-packages/sympy/calculus/util.pyt elm_domain5s$     !  !N(tlent ValueErrort is_EmptySetRR>RR,t not_empty_inRRR(ttypeR.R( tfinset_intersectiontsymst elm_in_setst finite_sett_setsRltelementt_domainRct_domain_element((Rks2lib/python2.7/site-packages/sympy/calculus/util.pyRps<)       & "c'sddlm}ddlm}ddlm}ddlm}ddlm }ddl m }m } m } m} m} ddlm} dd lm}dd lm}m}td d t}|j|}|fd }|}d}t||r|j|j}n| |}|jkr7tj St||rpy|j!}Wqpt"k rlqpXnt||r6|j#d}t|| | | fr| |j#d}nt$|}|dk r6t|| r6||}y|||dSWq3t"k r/}|r0t"|q0q3Xq6nt||rt%|dkrt$t&|}t$t%|}|dk r|dk rt'||g}qqn|j(r=|j#\}}|j)}|j)}|r | r t$|}qb|r(| r(t$|}qbt*|j#}n%|j+r|j,dt-\}}t||s|tj.k rt$|}qbt*|j#}n|j/r|j,\}}|tj k rt$|St*|j#}nmt||r|j#\} }!| kr(|!}qbt| |rIt$| }qb| j0rb|| dkrb|!jkrb||!| j}qbn|dkrbddlm1}"||}#t2|#}$|$dkrbx~t3t4|#D]g\}%}|$d|%}&|"|#|&}||kr||krt$|}|dk rXPqXqqWqbn|dk r|r|||S|SdS(sb Tests the given function for periodicity in the given symbol. Parameters ========== f : Expr. The concerned function. symbol : Symbol The variable for which the period is to be determined. check : Boolean, optional The flag to verify whether the value being returned is a period or not. Returns ======= period The period of the function is returned. `None` is returned when the function is aperiodic or has a complex period. The value of `0` is returned as the period of a constant function. Raises ====== NotImplementedError The value of the period computed cannot be verified. Notes ===== Currently, we do not support functions with a complex period. The period of functions having complex periodic values such as `exp`, `sinh` is evaluated to `None`. The value returned might not be the "fundamental" period of the given function i.e. it may not be the smallest periodic value of the function. The verification of the period through the `check` flag is not reliable due to internal simplification of the given expression. Hence, it is set to `False` by default. Examples ======== >>> from sympy import Symbol, sin, cos, tan, exp >>> from sympy.calculus.util import periodicity >>> x = Symbol('x') >>> f = sin(x) + sin(2*x) + sin(3*x) >>> periodicity(f, x) 2*pi >>> periodicity(sin(x)*cos(x), x) pi >>> periodicity(exp(tan(2*x) - 1), x) pi/2 >>> periodicity(sin(4*x)**cos(2*x), x) pi >>> periodicity(exp(x), x) i(RH(tMod(t Relational(texp(R(tTrigonometricFunctiontsintcostcsctsec(tsimplify(t decompogen(tdegreeRtxtrealcsR|j|}|j|r)|Sttd|||fdS(s,Return the checked period or raise an error.s The period of the given function cannot be verified. When `%s` was replaced with `%s + %s` in `%s`, the result was `%s` which was not recognized as being the same as the original function. So either the period was wrong or the two forms were not recognized as being equal. Set check=False to obtain the value.N(REtequalsR.R(torig_fRLtnew_f(R3(s2lib/python2.7/site-packages/sympy/calculus/util.pyt_checks iitas_Addi(tcompogenN(5tsympy.core.functionRHtsympy.core.modRztsympy.core.relationalR{t&sympy.functions.elementary.exponentialR|t$sympy.functions.elementary.complexesRt(sympy.functions.elementary.trigonometricR}R~RRRtsympy.simplify.simplifyRtsympy.solvers.decompogenRtsympy.polys.polytoolsRRR RKRER0R>tlhstrhst free_symbolsRR@RLR.R,R?RRtlcimtis_PowR-t _periodicitytis_Multas_independentRJtOnetis_Addt is_polynomialRRmt enumeratetreversed('R2R3tcheckRHRzR{R|RR}R~RRRRRRRttempRRRLtargterrt period_realt period_imagR*texpot base_has_symt expo_has_symtcoefftgtktatnRtg_st num_of_gstindext start_index((R3s2lib/python2.7/site-packages/sympy/calculus/util.pyR?_s;(            $      cCsyg}xL|D]D}t||}|dkr2dS|tjk r |j|q q Wt|dkrqt|S|dS(s< Helper for `periodicity` to find the period of a list of simpler functions. It uses the `lcim` method to find the least common period of all the functions. Parameters ========== args : Tuple of Symbol All the symbols present in a function. symbol : Symbol The symbol over which the function is to be evaluated. Returns ======= period The least common period of the function for all the symbols of the function. None if for at least one of the symbols the function is aperiodic iiN(R?R0RR@tappendRmR(R,R3tperiodsR2RL((s2lib/python2.7/site-packages/sympy/calculus/util.pyR%s   csd}td|Drttd|}ttd|}|ddtfd|Dr}g|D]\}}|^q}t||}qn%td|Drt|}n|S( sReturns the least common integral multiple of a list of numbers. The numbers can be rational or irrational or a mixture of both. `None` is returned for incommensurable numbers. Parameters ========== numbers : list Numbers (rational and/or irrational) for which lcim is to be found. Returns ======= number lcim if it exists, otherwise `None` for incommensurable numbers. Examples ======== >>> from sympy import S, pi >>> from sympy.calculus.util import lcim >>> lcim([S(1)/2, S(3)/4, S(5)/6]) 15/2 >>> lcim([2*pi, 3*pi, pi, pi/2]) 6*pi >>> lcim([S(1), 2*pi]) css|]}|jVqdS(N(t is_irrational(t.0tnum((s2lib/python2.7/site-packages/sympy/calculus/util.pys kscSs |jS(N(tfactor(R((s2lib/python2.7/site-packages/sympy/calculus/util.pytltcSs |jS(N(t as_coeff_Mul(R((s2lib/python2.7/site-packages/sympy/calculus/util.pyRnRiic3s!|]\}}|kVqdS(N((RRR(tterm(s2lib/python2.7/site-packages/sympy/calculus/util.pys qscss|]}|jVqdS(N(t is_rational(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pys vsN(R0talltlisttmapR(tnumberstresulttfactorized_numst factors_numt common_termRRtcoeffs((Rs2lib/python2.7/site-packages/sympy/calculus/util.pyRMs  cOst|dkr!tdnt|}|jdtj}|d}|j|ddk}t||t|r}tSt S(sDetermines the convexity of the function passed in the argument. Parameters ========== f : Expr The concerned function. syms : Tuple of symbols The variables with respect to which the convexity is to be determined. domain : Interval, optional The domain over which the convexity of the function has to be checked. If unspecified, S.Reals will be the default domain. Returns ======= Boolean The method returns `True` if the function is convex otherwise it returns `False`. Raises ====== NotImplementedError The check for the convexity of multivariate functions is not implemented yet. Notes ===== To determine concavity of a function pass `-f` as the concerned function. To determine logarithmic convexity of a function pass log(f) as concerned function. To determine logartihmic concavity of a function pass -log(f) as concerned function. Currently, convexity check of multivariate functions is not handled. Examples ======== >>> from sympy import symbols, exp, oo, Interval >>> from sympy.calculus.util import is_convex >>> x = symbols('x') >>> is_convex(exp(x), x) True >>> is_convex(x**3, x, domain = Interval(-1, oo)) False References ========== .. [1] https://en.wikipedia.org/wiki/Convex_function .. [2] http://www.ifp.illinois.edu/~angelia/L3_convfunc.pdf .. [3] https://en.wikipedia.org/wiki/Logarithmically_convex_function .. [4] https://en.wikipedia.org/wiki/Logarithmically_concave_function .. [5] https://en.wikipedia.org/wiki/Concave_function isMThe check for the convexity of multivariate functions is not implemented yet.R4ii( RmR.RtgetRR(RHR"RJRK(R2RstkwargsR4tvart condition((s2lib/python2.7/site-packages/sympy/calculus/util.pyt is_convex~s<   tAccumulationBoundscBseZdZeZdZdZedZedZ edZ edZ e de dZe de d ZeZd Ze de d Ze de d Ze de d ZeZe de dZeZe de dZeZe de dZdZdZdZdZdZdZ dZ!dZ"RS(s # Note AccumulationBounds has an alias: AccumBounds AccumulationBounds represent an interval `[a, b]`, which is always closed at the ends. Here `a` and `b` can be any value from extended real numbers. The intended meaning of AccummulationBounds is to give an approximate location of the accumulation points of a real function at a limit point. Let `a` and `b` be reals such that a <= b. `\left\langle a, b\right\rangle = \{x \in \mathbb{R} \mid a \le x \le b\}` `\left\langle -\infty, b\right\rangle = \{x \in \mathbb{R} \mid x \le b\} \cup \{-\infty, \infty\}` `\left\langle a, \infty \right\rangle = \{x \in \mathbb{R} \mid a \le x\} \cup \{-\infty, \infty\}` `\left\langle -\infty, \infty \right\rangle = \mathbb{R} \cup \{-\infty, \infty\}` `oo` and `-oo` are added to the second and third definition respectively, since if either `-oo` or `oo` is an argument, then the other one should be included (though not as an end point). This is forced, since we have, for example, `1/AccumBounds(0, 1) = AccumBounds(1, oo)`, and the limit at `0` is not one-sided. As x tends to `0-`, then `1/x -> -oo`, so `-oo` should be interpreted as belonging to `AccumBounds(1, oo)` though it need not appear explicitly. In many cases it suffices to know that the limit set is bounded. However, in some other cases more exact information could be useful. For example, all accumulation values of cos(x) + 1 are non-negative. (AccumBounds(-1, 1) + 1 = AccumBounds(0, 2)) A AccumulationBounds object is defined to be real AccumulationBounds, if its end points are finite reals. Let `X`, `Y` be real AccumulationBounds, then their sum, difference, product are defined to be the following sets: `X + Y = \{ x+y \mid x \in X \cap y \in Y\}` `X - Y = \{ x-y \mid x \in X \cap y \in Y\}` `X * Y = \{ x*y \mid x \in X \cap y \in Y\}` There is, however, no consensus on Interval division. `X / Y = \{ z \mid \exists x \in X, y \in Y \mid y \neq 0, z = x/y\}` Note: According to this definition the quotient of two AccumulationBounds may not be a AccumulationBounds object but rather a union of AccumulationBounds. Note ==== The main focus in the interval arithmetic is on the simplest way to calculate upper and lower endpoints for the range of values of a function in one or more variables. These barriers are not necessarily the supremum or infimum, since the precise calculation of those values can be difficult or impossible. Examples ======== >>> from sympy import AccumBounds, sin, exp, log, pi, E, S, oo >>> from sympy.abc import x >>> AccumBounds(0, 1) + AccumBounds(1, 2) AccumBounds(1, 3) >>> AccumBounds(0, 1) - AccumBounds(0, 2) AccumBounds(-2, 1) >>> AccumBounds(-2, 3)*AccumBounds(-1, 1) AccumBounds(-3, 3) >>> AccumBounds(1, 2)*AccumBounds(3, 5) AccumBounds(3, 10) The exponentiation of AccumulationBounds is defined as follows: If 0 does not belong to `X` or `n > 0` then `X^n = \{ x^n \mid x \in X\}` otherwise `X^n = \{ x^n \mid x \neq 0, x \in X\} \cup \{-\infty, \infty\}` Here for fractional `n`, the part of `X` resulting in a complex AccumulationBounds object is neglected. >>> AccumBounds(-1, 4)**(S(1)/2) AccumBounds(0, 2) >>> AccumBounds(1, 2)**2 AccumBounds(1, 4) >>> AccumBounds(-1, oo)**(-1) AccumBounds(-oo, oo) Note: `^2` is not same as `*` >>> AccumBounds(-1, 1)**2 AccumBounds(0, 1) >>> AccumBounds(1, 3) < 4 True >>> AccumBounds(1, 3) < -1 False Some elementary functions can also take AccumulationBounds as input. A function `f` evaluated for some real AccumulationBounds `` is defined as `f(\left\langle a, b\right\rangle) = \{ f(x) \mid a \le x \le b \}` >>> sin(AccumBounds(pi/6, pi/3)) AccumBounds(1/2, sqrt(3)/2) >>> exp(AccumBounds(0, 1)) AccumBounds(1, E) >>> log(AccumBounds(1, E)) AccumBounds(0, 1) Some symbol in an expression can be substituted for a AccumulationBounds object. But it doesn't necessarily evaluate the AccumulationBounds for that expression. Same expression can be evaluated to different values depending upon the form it is used for substitution. For example: >>> (x**2 + 2*x + 1).subs(x, AccumBounds(-1, 1)) AccumBounds(-1, 4) >>> ((x + 1)**2).subs(x, AccumBounds(-1, 1)) AccumBounds(0, 4) References ========== .. [1] https://en.wikipedia.org/wiki/Interval_arithmetic .. [2] http://fab.cba.mit.edu/classes/S62.12/docs/Hickey_interval.pdf Notes ===== Do not use ``AccumulationBounds`` for floating point interval arithmetic calculations, use ``mpmath.iv`` instead. cCst|}t|}tjtjg}|jp<||k sV|jpR||k retdn|jr|jr||krtdqn||kr|Stj|||S(Ns*Only real AccumulationBounds are supporteds.Lower limit should be smaller than upper limit( RRR`Ratis_realRnt is_comparableR t__new__(tclstmintmaxtinftys((s2lib/python2.7/site-packages/sympy/calculus/util.pyRbs    g&@cCs |jdS(s Returns the minimum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).min 1 i(R,(tself((s2lib/python2.7/site-packages/sympy/calculus/util.pyR{scCs |jdS(s Returns the maximum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).max 3 i(R,(R((s2lib/python2.7/site-packages/sympy/calculus/util.pyRscCs|j|jS(s7 Returns the difference of maximum possible value attained by AccumulationBounds object and minimum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).delta 2 (RR(R((s2lib/python2.7/site-packages/sympy/calculus/util.pytdeltascCs|j|jdS(s/ Returns the mean of maximum possible value attained by AccumulationBounds object and minimum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).mid 2 i(RR(R((s2lib/python2.7/site-packages/sympy/calculus/util.pytmidstothercCs |j|S(N(t__pow__(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyt _eval_powerscCst|trt|trItt|j|jt|j|jS|tjkrj|jtjks|tjkr|jtjkrtt t S|j rtt|j|t|j|St||dt St S(Ntevaluate( R>Rt AccumBoundsR RRRR`RaRRRJtNotImplemented(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyt__add__s!! %cCst|j |j S(N(RRR(R((s2lib/python2.7/site-packages/sympy/calculus/util.pyt__neg__scCst|trt|trKtt|j|j t|j|j S|tjkrl|jtjks|tjkr|jtjkrtt t S|j rtt|j| t|j| St|| dt St S(NR( R>RRR RRRRaR`RRRJR(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyt__sub__s!! cCs|j|S(N(R(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyt__rsub__sc CsPt|trLt|trttt|j|jt|j|jt|j|jt|j|jtt|j|jt|j|jt|j|jt|j|jS|tj kr|jj rtdt S|jj rtt dSn|tj krK|jj r/tt dS|jj rKtdt Sn|j r&|j r|tt t krtt t S|jtj krtdt S|jtj krtt dStjS|jrtt|j|t|j|S|jr&tt|j|t|j|Snt|tr9|St||dtStS(NiR(R>RRRR RRRRR`tis_zeroRRaRR@t is_positivet is_negativeRRJR(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyt__mul__sR          cCst|trt|trtj|krL|td|jd|jStj|krtj|kr|jjr|jjrtdtS|jjr|jjrtt dStt tS|jj rN|jj r|jjrt|j|jtS|jj rtt tSn|jjrN|jj rNtt |j|jSn|jj r|jj r|jjrtt |j|jS|jj rtt tSn|jjr|jj rt|j|jtSqn|j r|tj ks|tj kr|tt tkr'tt tS|jtj krXttd|td|S|jtj krttd| td| Sn|j rt|j||j|S|j rt|j||j|Snt|d|dtStS(NiiR(R>RRRR@RRRRRRRR`RaRRR RJR(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyt__div__sP          $  cCsft|tr^|jrG|jr(tjStj|kr |jtjkr|jrott |d|j t S|j rtt t |d|j Sn|j tjkr|jrtt t |d|jS|j rtt |d|jt Sntt t Stt ||j||j t||j||j Snt |d|dtStSdS(NiR(R>RRRRR@RRRR RRRRRRJR(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyt__rdiv__Rs(    !   !cCsddlm}t|tr|tjkr|jjrs|jdkrPtj S|jdkrftjSt dt S|jj r|jdkrtj S|jdkrt t t St t t S|jdkr|jdkrtj St dt St t t Sn|tjkrd|t S|jr|jr|jr@tjS|jr|jjrt t|j||j|t|j||j|S|jj rt t|j||j|t|j||j|S|ddkrd|j r=|jjrt |j|t S|jjr0t |j|t St dt St tj t|j||j|S|j r|jjrt |j|t S|jjrt t |j|St t t St |j||j|Sn|j\}}|tdkrm|ddkrHtj |krH|jj rEt d||j|SqHnt ||j|||j|S||}|d|St||dtStS(Ni(t real_rootiiiR(t(sympy.functions.elementary.miscellaneousRR>RRR`Rtis_nonnegativeRR@RRRRRaRt is_numberRRt is_IntegerRRRR_RRJR(RRRRtdentnum_pow((s2lib/python2.7/site-packages/sympy/calculus/util.pyRms|             $      cCsO|jjr|jS|jjrGttjtt|j|jS|SdS(N( RRRRRRR@Rtabs(R((s2lib/python2.7/site-packages/sympy/calculus/util.pyt__abs__s    %cCst|}t|trJ|j|jkr1tS|j|jkrtSnx|jpn|tj kpn|tj kst dt ||fn2|j r|j|krtS|j|krtSntt|j|S(s Returns True if range of values attained by `self` AccumulationBounds object is less than the range of values attained by `other`, where other may be any value of type AccumulationBounds object or extended real number value, False if `other` satisfies the same property, else an unevaluated Relational Examples ======== >>> from sympy import AccumBounds, oo >>> AccumBounds(1, 3) < AccumBounds(4, oo) True >>> AccumBounds(1, 4) < AccumBounds(3, 4) AccumBounds(1, 4) < AccumBounds(3, 4) >>> AccumBounds(1, oo) < -1 False sInvalid comparison of %s %s(RR>RRRRKRJRRR`Rat TypeErrorRqRtsuperRt__lt__(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyRs"  cCst|}t|trJ|j|jkr1tS|j|jkrtSnx|jpn|tj kpn|tj kst dt ||fn2|j r|j|krtS|j|krtSntt|j|S(s Returns True if range of values attained by `self` AccumulationBounds object is less than or equal to the range of values attained by `other`, where other may be any value of type AccumulationBounds object or extended real number value, False if `other` satisfies the same property, else an unevaluated Relational. Examples ======== >>> from sympy import AccumBounds, oo >>> AccumBounds(1, 3) <= AccumBounds(4, oo) True >>> AccumBounds(1, 4) <= AccumBounds(3, 4) AccumBounds(1, 4) <= AccumBounds(3, 4) >>> AccumBounds(1, 3) <= 0 False sInvalid comparison of %s %s(RR>RRRRKRJRRR`RaRRqRRRt__le__(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyRs"  cCst|}t|trJ|j|jkr1tS|j|jkrtSnx|jpn|tj kpn|tj kst dt ||fn2|j r|j|krtS|j|krtSntt|j|S(s Returns True if range of values attained by `self` AccumulationBounds object is greater than the range of values attained by `other`, where other may be any value of type AccumulationBounds object or extended real number value, False if `other` satisfies the same property, else an unevaluated Relational. Examples ======== >>> from sympy import AccumBounds, oo >>> AccumBounds(1, 3) > AccumBounds(4, oo) False >>> AccumBounds(1, 4) > AccumBounds(3, 4) AccumBounds(1, 4) > AccumBounds(3, 4) >>> AccumBounds(1, oo) > -1 True sInvalid comparison of %s %s(RR>RRRRKRJRRR`RaRRqRRRt__gt__(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyR s"  cCst|}t|trJ|j|jkr1tS|j|jkrtSnx|jpn|tj kpn|tj kst dt ||fn2|j r|j|krtS|j|krtSntt|j|S(s Returns True if range of values attained by `self` AccumulationBounds object is less that the range of values attained by `other`, where other may be any value of type AccumulationBounds object or extended real number value, False if `other` satisfies the same property, else an unevaluated Relational. Examples ======== >>> from sympy import AccumBounds, oo >>> AccumBounds(1, 3) >= AccumBounds(4, oo) False >>> AccumBounds(1, 4) >= AccumBounds(3, 4) AccumBounds(1, 4) >= AccumBounds(3, 4) >>> AccumBounds(1, oo) >= 1 True sInvalid comparison of %s %s(RR>RRRRKRJRRR`RaRRqRRRt__ge__(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pyR0s"  cCst|}|tjks*|tjkrV|jtjksN|jtjkrRtStSt|j|k|j|k}|ttfkrt dn|S(s Returns True if other is contained in self, where other belongs to extended real numbers, False if not contained, otherwise TypeError is raised. Examples ======== >>> from sympy import AccumBounds, oo >>> 1 in AccumBounds(-1, 3) True -oo and oo go together as limits (in AccumulationBounds). >>> -oo in AccumBounds(1, oo) True >>> oo in AccumBounds(-oo, 0) True sinput failed to evaluate( RRR`RaRRRKRJRR(RRtrv((s2lib/python2.7/site-packages/sympy/calculus/util.pyt __contains__Vs $!cCs?t|ttfs$tdnt|trptj}x-|D]%}||krC|t|}qCqCW|S|j|jks|j|jkrtjS|j|jkr|j|jkrt|j|jS|j|jkr|Sn|j|jkr;|j|jkr"t|j|jS|j|jkr;|SndS(s Returns the intersection of 'self' and 'other'. Here other can be an instance of FiniteSet or AccumulationBounds. Examples ======== >>> from sympy import AccumBounds, FiniteSet >>> AccumBounds(1, 3).intersection(AccumBounds(2, 4)) AccumBounds(2, 3) >>> AccumBounds(1, 3).intersection(AccumBounds(4, 6)) EmptySet() >>> AccumBounds(1, 4).intersection(FiniteSet(1, 2, 5)) {1, 2} s4Input must be AccumulationBounds or FiniteSet objectN(R>RRRRRRR(RRtfin_setti((s2lib/python2.7/site-packages/sympy/calculus/util.pyt intersectionxs*    $cCst|tstdn|j|jkra|j|jkrat|jt|j|jS|j|jkr|j|jkrt|jt|j|jSdS(Ns4Input must be AccumulationBounds or FiniteSet object(R>RRRRR(RR((s2lib/python2.7/site-packages/sympy/calculus/util.pytunions $$(#t__name__t __module__t__doc__RKRRt _op_prioritytpropertyRRRRRRRRt__radd__RRRRt__rmul__Rt __truediv__Rt __rtruediv__RRRRRRRRR(((s2lib/python2.7/site-packages/sympy/calculus/util.pyRs:  ,8I  & & & & " -N(<tsympyRRRRRRRRRR R tsympy.core.basicR t sympy.coreR R Rtsympy.logic.boolalgRtsympy.core.exprRRtsympy.core.numbersRRtsympy.core.sympifyRtsympy.sets.setsRRRRRRtsympy.sets.conditionsetRRRRtsympy.utilitiesRtsympy.simplify.radsimpRtsympy.polys.rationaltoolsR tsympy.core.compatibilityR!R%R"R;R\RpRJR?RRRRR(((s2lib/python2.7/site-packages/sympy/calculus/util.pyts2L. \ o ( 1 H