ó ~9­\c@sÅdZddlmZddlmZddlmZddlmZm Z d„Z ej d d„Z ej d d„Zej d d „Zej d d „Zej d d „Zej d d „Zd S(sf Singularities ============= This module implements algorithms for finding singularities for a function and identifying types of functions. The differential calculus methods in this module include methods to identify the following function types in the given ``Interval``: - Increasing - Strictly Increasing - Decreasing - Strictly Decreasing - Monotonic iÿÿÿÿ(tsympify(tsolveset(tsimplify(tStSymbolcCsW|j|ƒstdƒ‚n5|jr0tjntj}ttd|ƒ||ƒSdS(sª Find singularities of a given function. Parameters ========== expression : Expr The target function in which singularities need to be found. symbol : Symbol The symbol over the values of which the singularity in expression in being searched for. Returns ======= Set A set of values for ``symbol`` for which ``expression`` has a singularity. An ``EmptySet`` is returned if ``expression`` has no singularities for any given value of ``Symbol``. Raises ====== NotImplementedError The algorithm to find singularities for irrational functions has not been implemented yet. Notes ===== This function does not find non-isolated singularities nor does it find branch points of the expression. Currently supported functions are: - univariate rational (real or complex) functions References ========== .. [1] https://en.wikipedia.org/wiki/Mathematical_singularity Examples ======== >>> from sympy.calculus.singularities import singularities >>> from sympy import Symbol >>> x = Symbol('x', real=True) >>> y = Symbol('y', real=False) >>> singularities(x**2 + x + 1, x) EmptySet() >>> singularities(1/(x + 1), x) {-1} >>> singularities(1/(y**2 + 1), y) {-I, I} >>> singularities(1/(y**3 + 1), y) {-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2} sTAlgorithms finding singularities for non-rational functions are not yet implemented.iN(tis_rational_functiontNotImplementedErrortis_realRtRealst ComplexesRR(t expressiontsymboltdomain((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyt singularitiess ; cCs t|ƒ}|j}|dkrEt|ƒdkrEtdƒ‚qEn|pf|r]|jƒn tdƒ}|j|ƒ}t||ƒ|t j ƒ}|j |ƒS(sà Helper function for functions checking function monotonicity. Parameters ========== expression : Expr The target function which is being checked predicate : function The property being tested for. The function takes in an integer and returns a boolean. The integer input is the derivative and the boolean result should be true if the property is being held, and false otherwise. interval : Set, optional The range of values in which we are testing, defaults to all reals. symbol : Symbol, optional The symbol present in expression which gets varied over the given range. It returns a boolean indicating whether the interval in which the function's derivative satisfies given predicate is a superset of the given interval. Returns ======= Boolean True if ``predicate`` is true for all the derivatives when ``symbol`` is varied in ``range``, False otherwise. isKThe function has not yet been implemented for all multivariate expressions.txN( Rt free_symbolstNonetlenRtpopRtdiffRRRt is_subset(R t predicatetintervalR tfreetvariablet derivativetpredicate_interval((s;lib/python2.7/site-packages/sympy/calculus/singularities.pytmonotonicity_helperbs   $cCst|d„||ƒS(s Return whether the function is increasing in the given interval. Parameters ========== expression : Expr The target function which is being checked. interval : Set, optional The range of values in which we are testing (defaults to set of all real numbers). symbol : Symbol, optional The symbol present in expression which gets varied over the given range. Returns ======= Boolean True if ``expression`` is increasing (either strictly increasing or constant) in the given ``interval``, False otherwise. Examples ======== >>> from sympy import is_increasing >>> from sympy.abc import x, y >>> from sympy import S, Interval, oo >>> is_increasing(x**3 - 3*x**2 + 4*x, S.Reals) True >>> is_increasing(-x**2, Interval(-oo, 0)) True >>> is_increasing(-x**2, Interval(0, oo)) False >>> is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3)) False >>> is_increasing(x**2 + y, Interval(1, 2), x) True cSs |dkS(Ni((R((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyt¹t(R(R RR ((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyt is_increasing‘s(cCst|d„||ƒS(st Return whether the function is strictly increasing in the given interval. Parameters ========== expression : Expr The target function which is being checked. interval : Set, optional The range of values in which we are testing (defaults to set of all real numbers). symbol : Symbol, optional The symbol present in expression which gets varied over the given range. Returns ======= Boolean True if ``expression`` is strictly increasing in the given ``interval``, False otherwise. Examples ======== >>> from sympy import is_strictly_increasing >>> from sympy.abc import x, y >>> from sympy import Interval, oo >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2)) True >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo)) True >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3)) False >>> is_strictly_increasing(-x**2, Interval(0, oo)) False >>> is_strictly_increasing(-x**2 + y, Interval(-oo, 0), x) False cSs |dkS(Ni((R((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyRäR(R(R RR ((s;lib/python2.7/site-packages/sympy/calculus/singularities.pytis_strictly_increasing¼s(cCst|d„||ƒS(s7 Return whether the function is decreasing in the given interval. Parameters ========== expression : Expr The target function which is being checked. interval : Set, optional The range of values in which we are testing (defaults to set of all real numbers). symbol : Symbol, optional The symbol present in expression which gets varied over the given range. Returns ======= Boolean True if ``expression`` is decreasing (either strictly decreasing or constant) in the given ``interval``, False otherwise. Examples ======== >>> from sympy import is_decreasing >>> from sympy.abc import x, y >>> from sympy import S, Interval, oo >>> is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3)) True >>> is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo)) True >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2)) False >>> is_decreasing(-x**2, Interval(-oo, 0)) False >>> is_decreasing(-x**2 + y, Interval(-oo, 0), x) False cSs |dkS(Ni((R((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyRR(R(R RR ((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyt is_decreasingçs(cCst|d„||ƒS(s Return whether the function is strictly decreasing in the given interval. Parameters ========== expression : Expr The target function which is being checked. interval : Set, optional The range of values in which we are testing (defaults to set of all real numbers). symbol : Symbol, optional The symbol present in expression which gets varied over the given range. Returns ======= Boolean True if ``expression`` is strictly decreasing in the given ``interval``, False otherwise. Examples ======== >>> from sympy import is_strictly_decreasing >>> from sympy.abc import x, y >>> from sympy import S, Interval, oo >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo)) True >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2)) False >>> is_strictly_decreasing(-x**2, Interval(-oo, 0)) False >>> is_strictly_decreasing(-x**2 + y, Interval(-oo, 0), x) False cSs |dkS(Ni((R((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyR8R(R(R RR ((s;lib/python2.7/site-packages/sympy/calculus/singularities.pytis_strictly_decreasings&cCs—t|ƒ}|j}|dkrBt|ƒdkrBtdƒ‚n|pc|rZ|jƒn tdƒ}t|j|ƒ||ƒ}|j |ƒt j kS(sk Return whether the function is monotonic in the given interval. Parameters ========== expression : Expr The target function which is being checked. interval : Set, optional The range of values in which we are testing (defaults to set of all real numbers). symbol : Symbol, optional The symbol present in expression which gets varied over the given range. Returns ======= Boolean True if ``expression`` is monotonic in the given ``interval``, False otherwise. Raises ====== NotImplementedError Monotonicity check has not been implemented for the queried function. Examples ======== >>> from sympy import is_monotonic >>> from sympy.abc import x, y >>> from sympy import S, Interval, oo >>> is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3)) True >>> is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo)) True >>> is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals) True >>> is_monotonic(-x**2, S.Reals) False >>> is_monotonic(x**2 + y + 1, Interval(1, 2), x) True isKis_monotonic has not yet been implemented for all multivariate expressions.RN( RRRRRRRRRt intersectionRtEmptySet(R RR RRtturning_points((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyt is_monotonic;s.   $N(t__doc__tsympy.core.sympifyRtsympy.solvers.solvesetRtsympy.simplifyRtsympyRRR RRRRRR R!R%(((s;lib/python2.7/site-packages/sympy/calculus/singularities.pyts J/+++)