o 8Va@sddlmZmZmZmZmZmZmZmZm Z ddl m Z m Z m Z ddlmZddlmZddlmZmZddlmZddlmZmZmZddlmZmZmZmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&dd l'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddZ6ddZ7ddZ8d2ddZ9ddZ:ddZ;ejej>> 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. rr%) singularities)sympy.solvers.inequalitiesr&Zsympy.calculus.singularitiesr)Z is_subsetrRealsZatomsr expas_numer_denomZis_evenZ is_nonzerobaseZas_setrrargs) fsymboldomainr&r)Zconstrained_intervalZatomdenZ constraintr55/usr/lib/python3/dist-packages/sympy/calculus/util.pycontinuous_domains4 /    r7c Cshddlm}t|trtjSt||}|tjkrt|S|durPt|t r4|j |j j r3t d|}nt|t rP|jD]}t|t rO|j |j j rOt d|}q>> 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. rsolvesetNzL Unable to find range for the given domain. +-z%Unable to find critical points for {}z)Infinite number of critical points for {})FFT)sympy.solvers.solvesetr9 isinstancer#r periodicityZeror expandrinfsupZ is_infiniter!r0r7NotImplementedErrorr'subs left_open right_openrdiffrformatr$)r1r2r3r9periodZsub_domZ intervalsZ range_intZ interval_iterintervalZ singletonZvalsZcritical_pointsZcritical_valuesZboundsZis_openZ limit_pointZ directionZsolutionZcritical_pointrErFr5r5r6function_rangeYs 3                      rKcs4t|dkr td|tjurtjSt|tr*|jd}tt|jdg|R|St|tr5|}tj n |jd}|jdt|tsNtdt ||ft|dkrY|dnt d|ffddtt rwtfdd |DSttrtj}jD]tfd d |D}t||}q|Sd S) ay 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(1, 2), Interval(-sqrt(2), -1)) >>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x) Union(Interval.Lopen(-2, -1), Interval(2, oo)) rz*One or more symbols must be given in syms.r*z%A FiniteSet must be given, not %s: %sz&more than one variables %s not handledc sddlm}|j}|j}||dtjd}|jr/|tjur$tj}n|||ktjd}n |||ktjd}|j rP|tj urEtj}n|||ktjd}n |||ktjd}t ||}t ||} | S)z9 Finds the domain of an expression in any given interval rr8r*r3) r<r9startendr.rr,rFInfinityrENegativeInfinityrr") exprintrvlr9Z_startZ_endZ_singularitiesZ_domain1Z_domain2Zexpr_with_singZ expr_domain)symbr5r6 elm_domain&s&     z not_empty_in..elm_domaincsg|]}|qSr5r5.0element)_setsrTr5r6 Esz not_empty_in..csg|]}|qSr5r5rU)rTrRr5r6rYJsN) len ValueErrorrr#r=r!r0 not_empty_inr r,typerCr)Zfinset_intersectionsymsZ elm_in_setsZ finite_setZ_domainZ_domain_elementr5)rXrTrRrSr6r\sF )               r\Fc% sDddlm}ddlm}ddlm}ddlm}ddlm }m }m } m } m } ddlm} ddlm} dd lm}td d d }||}|fd d}|}d}t||r[|j|j}| |}|jvrgtjSt||r}z|}Wn ty|Ynwt||r|jd}t|| | | fr||jd}t|}|durt||r||}z|||dWSty}z |rt|WYd}~nd}~wwt||s|j r|j!tj"krt#tj"t$|j}t%|dkrtt&|}tt%|}|dur|durt'||g}|j r@|j!tj"kr@|j\}}|(}|(}|r-|s-t|}n|r9|s9t|}nt)|j}n|j*rf|j+dd\}}t||sY|tj,ur_t|}nt)|j}n|j-r|+\}}|tjur|t|St)|j}nt||r|j\}}|kr|}n{t||rt|}no|.r||dkr|jvr|||/}nQt|t0rnJ|durddlm1} | |}!t2|!}"|"dkrt3t4|!D]*\}#}|"d|#}$| |!|$d}||kr||krt|}|durnq|dur |r|||S|SdS)ab 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) r)Mod) Relational)r-)Abs)TrigonometricFunctionsincoscscsec)simplify) decompogen)degreexT)realcs8||}||r|Sttd|||f)z,Return the checked period or raise an error.a 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.)rDZequalsrCr')orig_frInew_fr2r5r6_checks   zperiodicity.._checkNF)Zas_Addr*)compogen)5Zsympy.core.modr_sympy.core.relationalr`Z&sympy.functions.elementary.exponentialr-Z$sympy.functions.elementary.complexesraZ(sympy.functions.elementary.trigonometricrbrcrdrerfZsympy.simplify.simplifyrgZsympy.solvers.decompogenrhZsympy.polys.polytoolsrir rDr=lhsrhsZ free_symbolsrr?rIrCr0r>is_Powr/ZExp1r rrrlcimZhas _periodicityZis_MulZas_independentOneZis_AddZ is_polynomialrGr rqrZ enumeratereversed)%r1r2checkr_r`r-rarbrcrdrerfrgrhriZtemprorlrIargerrZ period_realZ period_imagr/ZexpoZ base_has_symZ expo_has_symcoeffgkanrqZg_sZ num_of_gsindex start_indexr5rnr6r>Ps ;                                             r>cCs^g}|D]}t||}|durdS|tjur||qt|dkr't|S|r-|dSdS)a< 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 Nr*r)r>rr?appendrZrv)r0r2Zperiodsr1rIr5r5r6rws    rwcsd}tdd|Dr?ttdd|}ttdd|}|ddtfd d|Dr=}d d |D}t||}|Std d|DrNt|}|S |S) aReturns 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]) Ncs|]}|jVqdSN)Z is_irrationalrVnumr5r5r6 `zlcim..cS|Sr)factorrr5r5r6azlcim..cSrr)Z as_coeff_Mulrr5r5r6rcrrr*c3s|] \}}|kVqdSrr5rVr~rZtermr5r6rfscSsg|]\}}|qSr5r5rr5r5r6rYhzlcim..csrr) is_rationalrr5r5r6rkr)alllistmapr)ZnumbersresultZfactorized_numsZ factors_numZ common_termZcoeffsr5rr6rvBs&  rvrLcGsJt|dkr tdt|}|d}||ddk}t||d|r#dSdS)aDetermines 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 r*zMThe check for the convexity of multivariate functions is not implemented yet.rrpFT)rZrCrrGr&)r1r3r^varZ conditionr5r5r6 is_convexss <rcCsBddlm}m}t|trtjSt|||}||||||}|S)ax Returns the stationary points of a function (where derivative of the function is 0) in the given domain. Parameters ========== f : Expr The concerned function. symbol : Symbol The variable for which the stationary points are to be determined. domain : Interval The domain over which the stationary points have to be checked. If unspecified, S.Reals will be the default domain. Returns ======= Set A set of stationary points for the function. If there are no stationary point, an EmptySet is returned. Examples ======== >>> from sympy import Symbol, S, sin, pi, pprint, stationary_points >>> from sympy.sets import Interval >>> x = Symbol('x') >>> stationary_points(1/x, x, S.Reals) EmptySet >>> pprint(stationary_points(sin(x), x), use_unicode=False) pi 3*pi {2*n*pi + -- | n in Integers} U {2*n*pi + ---- | n in Integers} 2 2 >>> stationary_points(sin(x),x, Interval(0, 4*pi)) {pi/2, 3*pi/2, 5*pi/2, 7*pi/2} r)r9rG)sympyr9rGr=r#rr7)r1r2r3r9rGsetr5r5r6stationary_pointss *  rcCBddlm}t||rt|trtdt|||jStd|)a Returns the maximum value of a function in the given domain. Parameters ========== f : Expr The concerned function. symbol : Symbol The variable for maximum value needs to be determined. domain : Interval The domain over which the maximum have to be checked. If unspecified, then Global maximum is returned. Returns ======= number Maximum value of the function in given domain. Examples ======== >>> from sympy import Symbol, S, sin, cos, pi, maximum >>> from sympy.sets import Interval >>> x = Symbol('x') >>> f = -x**2 + 2*x + 5 >>> maximum(f, x, S.Reals) 6 >>> maximum(sin(x), x, Interval(-pi, pi/4)) sqrt(2)/2 >>> maximum(sin(x)*cos(x), x) 1/2 rSymbolz+Maximum value not defined for empty domain.%s is not a valid symbol.)rrr=r#r[rKrBr1r2r3rr5r5r6maximum '   rcCr)a  Returns the minimum value of a function in the given domain. Parameters ========== f : Expr The concerned function. symbol : Symbol The variable for minimum value needs to be determined. domain : Interval The domain over which the minimum have to be checked. If unspecified, then Global minimum is returned. Returns ======= number Minimum value of the function in the given domain. Examples ======== >>> from sympy import Symbol, S, sin, cos, minimum >>> from sympy.sets import Interval >>> x = Symbol('x') >>> f = x**2 + 2*x + 5 >>> minimum(f, x, S.Reals) 4 >>> minimum(sin(x), x, Interval(2, 3)) sin(3) >>> minimum(sin(x)*cos(x), x) -1/2 rrz+Minimum value not defined for empty domain.r)rrr=r#r[rKrArr5r5r6minimum"rrc@s*eZdZdZdZddZdZddZedd Z ed d Z ed d Z eddZ e deddZe deddZeZddZe deddZe deddZe deddZeZe deddZe dedd Ze ded!d"Ze ded#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-S).AccumulationBoundsa\ # 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\}` When an AccumBounds is raised to a negative power, if 0 is contained between the bounds then an infinite range is returned, otherwise if an endpoint is 0 then a semi-infinite range with consistent sign will be returned. AccumBounds in expressions behave a lot like Intervals but the semantics are not necessarily the same. Division (or exponentiation to a negative integer power) could be handled with *intervals* by returning a union of the results obtained after splitting the bounds between negatives and positives, but that is not done with AccumBounds. In addition, bounds are assumed to be independent of each other; if the same bound is used in more than one place in an expression, the result may not be the supremum or infimum of the expression (see below). Finally, when a boundary is ``1``, exponentiation to the power of ``oo`` yields ``oo``, neither ``1`` nor ``nan``. 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\}` >>> AccumBounds(1, 4)**(S(1)/2) AccumBounds(1, 2) otherwise, an infinite or semi-infinite result is obtained: >>> 1/AccumBounds(-1, 1) AccumBounds(-oo, oo) >>> 1/AccumBounds(0, 2) AccumBounds(1/2, oo) >>> 1/AccumBounds(-oo, 0) AccumBounds(-oo, 0) A boundary of 1 will always generate all nonnegatives: >>> AccumBounds(1, 2)**oo AccumBounds(0, oo) >>> AccumBounds(0, 1)**oo AccumBounds(0, oo) If the exponent is itself an AccumulationBounds or is not an integer then unevaluated results will be returned unless the base values are positive: >>> AccumBounds(2, 3)**AccumBounds(-1, 2) AccumBounds(1/3, 9) >>> AccumBounds(-2, 3)**AccumBounds(-1, 2) AccumBounds(-2, 3)**AccumBounds(-1, 2) >>> AccumBounds(-2, -1)**(S(1)/2) sqrt(AccumBounds(-2, -1)) 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. The same expression can be evaluated to different values depending upon the form it is used for substitution since each instance of an AccumulationBounds is considered independent. 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. TcCsvt|}t|}|jr|jstd||kr|S|jr)|jr)|jo'|jo'||k}n||j}|r4tdt|||S)Nz*Only real AccumulationBounds are supportedz.Lower limit should be smaller than upper limit)ris_extended_realr[ is_number is_comparableis_extended_negativer__new__)clsminmaxZbadr5r5r6rs   zAccumulationBounds.__new__g&@cCs|jjr |jjr dSdSdS)NT)ris_realrselfr5r5r6 _eval_is_realsz AccumulationBounds._eval_is_realcC |jdS)z Returns the minimum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).min 1 rr0rr5r5r6r zAccumulationBounds.mincCr)z Returns the maximum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).max 3 r*rrr5r5r6r-rzAccumulationBounds.maxcCs |j|jS)a7 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 )rrrr5r5r6delta=s zAccumulationBounds.deltacCs|j|jdS)a/ 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 rp)rrrr5r5r6midNszAccumulationBounds.midothercCs ||Sr)__pow__rrr5r5r6 _eval_power_s zAccumulationBounds._eval_powercCst|tr{t|trtt|j|jt|j|jS|tjur$|jtjus/|tjur5|jtjur5tt t S|j rt|jtjurJ|jtjurJtt t S|jtjurYtt |j|S|jtjurgt|j|t Stt|j|t|j|St||ddSt SNFZevaluate) r=r AccumBoundsr rrrrOrPrrNotImplementedrr5r5r6__add__cs,         zAccumulationBounds.__add__cCst|j |j Sr)rrrrr5r5r6__neg__{szAccumulationBounds.__neg__cCst|trt|trtt|j|j t|j|j S|tjur&|jtjus1|tjur7|jtjur7tt t S|j rx|jtjurL|jtjurLtt t S|jtjur[tt |j|S|jtjurit|j|t Stt|j| t|j| St|| ddSt Sr) r=rrr rrrrPrOrrrrr5r5r6__sub__~s2         zAccumulationBounds.__sub__cCs ||Sr)rrr5r5r6__rsub__s zAccumulationBounds.__rsub__cCs|jt tfkr |St|trt|trB|jt tfkr|St}|jD]}||}|jp/|fD]}||q0q$tt|t|S|t j urZ|j j rPtdtS|j j rZtt dS|t jurr|j j ritt dS|j j rrtdtS|jr|j r|j t j urtdtS|j t jurtt dSt jS|jrtt|j |t|j |S|jrtt|j |t|j |St|tr|St||ddStS)NrFr)r0rr=rrraddrrrrOris_zerorrPrr?is_extended_positiver rrr)rrvivir5r5r6__mul__sX                   zAccumulationBounds.__mul__cCsXt|tr*t|tr|jjs|jjr |td|jd|jS|jjrQ|jjrQ|jjrQ|jjrQ|jj r=|jj r=tdt S|jj rK|jj rKtt dStt t S|jj r|jj rp|jj rft|j|jt S|jj rptt t S|jj r|jj rtt |j|jS|jj r|jj r|jj rtt |j|jS|jj rtt t S|jj r|jj rt|j|jt Sn^|j r|tjus|tjur|tt t krtt t S|jtjurttd|td|S|jtjurttd| td| S|j rt|j||j|S|j rt|j||j|Sd|tjur#t|d|ddSt|d|StS)Nr*rFr)r=rrrZ is_positiverZ is_negativeis_extended_nonpositiveis_extended_nonnegativerrrrrrrOrPrrZComplexInfinityr rrr5r5r6 __truediv__s^          zAccumulationBounds.__truediv__cCst|tr~|jru|jrtjS|jjr^|jj r^|jjr7|j r(t t |d|jt S|jr7t t t |d|jS|jjrX|j rJt t t |d|jS|jrXt t |d|jt St t t St t||j||jt||j||jSt |d|ddStS)Nr*Fr)r=rrrrr?rrrrrrr rrrrrrr5r5r6 __rtruediv__s*  zAccumulationBounds.__rtruediv__csbt|tr|tjurRjjr$jdkrtjSjdkrtjStdt Sjj r:jdkr0tjSjdkr7t Stj SjdkrLjdkrGtjStdt Stt t S|tj ur]dt Sjjjrwjjrw|jrwj|j|S|jr}tjS|js|jr&jjrttj|j|tj|j|Sjj rttj|j|tj|j|S|ddkr|j rjjrtj|t Sjjrtj|t Stdt Sttjtj|j|S|ddkr&|j rjjrtj|t Sjjrtt j|Stt t Stj|j|S|js.|jrbjjs<|jrbjjrb|\}|tjurTtfddjDStjurb|dSt|trjjswjjr|jjrfdd|jD}tdd |Dsd d|D}z t|t|WStyYnwt|d d StS) Nr*rrpcsg|]}|dqS)r*r5rVr)r4r5r6rYgsz.AccumulationBounds.__pow__..cg|]}|qSr5r5rrr5r6rYprcsrr)rurr5r5r6rqrz-AccumulationBounds.__pow__..cSs"g|] }|jp |fD]}|q qSr5r)rVrjr5r5r6rYrs"Fr)r=rrrOrrrr?rrrrZNaNrPZis_nonnegativefuncrrxZ is_Integer is_integerrrrrrr.r0any TypeErrorr r)rrrprr5)r4rr6rs                       zAccumulationBounds.__pow__csjrJjrJ|j|jjrJtjurtjSjr6fdd|jD\}}t|||kr0||}}|||Sj rJ|jj rC|ddS|jjrJtj St |ddS)Ncrr5r5rrr5r6rYrz/AccumulationBounds.__rpow__..rr*Fr) rrrrrrrxr0rrr?r )rrrbr5rr6__rpow__|s      zAccumulationBounds.__rpow__cCs6|jjr|S|jjrttjtt|j|jS|Sr) rrrrrrr?rabsrr5r5r6__abs__s zAccumulationBounds.__abs__cCsft|}|tjus|tjur|jtjus|jtjurdSdSt|j|k|j|k}|dvr1td|S)a 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 TF)TFzinput failed to evaluate)rrrOrPrrrr)rrZrvr5r5r6 __contains__szAccumulationBounds.__contains__cCst|ttfs tdt|tr$tj}|D] }||vr!|t|}q|S|j|jks0|j|jkr3tjS|j|jkrN|j|jkrFt|j|jS|j|jkrN|S|j|jkri|j|jkrat|j|jS|j|jkrk|SdSdS)a Returns the intersection of 'self' and 'other'. Here other can be an instance of FiniteSet or AccumulationBounds. Parameters ========== other: AccumulationBounds Another AccumulationBounds object with which the intersection has to be computed. Returns ======= AccumulationBounds Intersection of 'self' and 'other'. 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} 4Input must be AccumulationBounds or FiniteSet objectN)r=rr rrr#rr)rrZfin_setrr5r5r6 intersections2         zAccumulationBounds.intersectioncCsvt|ts td|j|jkr |j|jkr t|jt|j|jS|j|jkr7|j|jkr9t|jt|j|jSdSdS)Nr)r=rrrrrrr5r5r6unions zAccumulationBounds.unionN)__name__ __module__ __qualname____doc__rrZ _op_priorityrpropertyrrrrrrrr__radd__rrrr__rmul__rrrrrrrrr5r5r5r6rTsP)         + ;  ^  " :rcC(t|j|jr dSt|j|jrdSdSNTF)rrrrrsrtr5r5r6 _eval_is_le rcCH|js tdt||f|jr t|j|rdSt|j|r"dSdSdS)aL 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 Invalid comparison of %s %sTFNrrr]rrrrrrr5r5r6r s   cCrrrrrrrr5r5r6 _eval_is_ge+rrcCr)aF Returns True if range of values attained by `lhs` AccumulationBounds object is less that the range of values attained by `rhs`, where other may be any value of type AccumulationBounds object or extended real number value, False if `rhs` 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 rTFN)rrr]rrrrrrr5r5r6r2s   cCsH|js tdt||f|jr t|j|rdSt|j|r"dSdSdS)NrTFrrr5r5r6rRs   cCrrrrr5r5r6r_rN)F)Errrrrrrrr r Z sympy.corer r r Zsympy.core.basicrZsympy.core.compatibilityrZsympy.core.exprrrZsympy.core.functionrZsympy.core.numbersrrrrrrrrrZsympy.core.sympifyrZ(sympy.functions.elementary.miscellaneousrrZsympy.logic.boolalgrZsympy.sets.setsrrr r!r"r#Zsympy.sets.fancysetsr$r+r&Zsympy.utilitiesr'Zsympy.multipledispatchr(r7rKr\r>rwrvr,rrrrrrrrr5r5r5r6s^,          F oJ)1H5224