o
    à8Vai,  ã                   @   s¦   d Z ddlmZmZ ddlmZ ddlmZ ddlm	Z	 ddd„Z
ejdfd	d
„Zejdfdd„Zejdfdd„Zejdfdd„Zejdfdd„Zejdfdd„ZdS )af  
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

é    )ÚSÚSymbol)Úsympify)Úsolveset)Ú
filldedentNc                 C   sâ   ddl m} ddlm}m}m}m}m} ddlm	}	 |du r'|j
r$tjntj}z<tj}
|  ||||g|¡ |	¡D ]}|jjr@t‚|jjrM|
t|j||ƒ7 }
q8|  |¡D ]}|
t|jd ||ƒ7 }
qS|
W S  typ   ttdƒƒ‚w )aÑ  
    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
        Methods for determining the singularities of this function have
        not been developed.

    Notes
    =====

    This function does not find non-isolated singularities
    nor does it find branch points of the expression.

    Currently supported functions are:
        - univariate continuous (real or complex) functions

    References
    ==========

    .. [1] https://en.wikipedia.org/wiki/Mathematical_singularity

    Examples
    ========

    >>> from sympy.calculus.singularities import singularities
    >>> from sympy import Symbol, log
    >>> 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}
    >>> singularities(log(x), x)
    {0}

    r   )Úlog)ÚsecÚcscÚcotÚtanÚcos)ÚPowNzl
            Methods for determining the singularities
            of this function have not been developed.)Z&sympy.functions.elementary.exponentialr   Z(sympy.functions.elementary.trigonometricr   r	   r
   r   r   Zsympy.core.powerr   Zis_realr   ÚRealsZ	ComplexesÚEmptySetZrewriteZatomsZexpZis_infiniteÚNotImplementedErrorZis_negativer   ÚbaseÚargsr   )Ú
expressionÚsymbolÚdomainr   r   r	   r
   r   r   r   ZsingsÚi© r   ú>/usr/lib/python3/dist-packages/sympy/calculus/singularities.pyÚsingularities   s&   =€ÿr   c                 C   sh   t | ƒ} | j}|du rt|ƒdkrtdƒ‚|p |r| ¡ ntdƒ}|  |¡}t||ƒ|tj	ƒ}| 
|¡S )aà  
    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.

    Né   zKThe function has not yet been implemented for all multivariate expressions.Úx)r   Úfree_symbolsÚlenr   Úpopr   Údiffr   r   r   Z	is_subset)r   Z	predicateÚintervalr   ÚfreeÚvariableZ
derivativeZpredicate_intervalr   r   r   Úmonotonicity_helperp   s   ÿ

r#   c                 C   ó   t | dd„ ||ƒS )a  
    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

    c                 S   s   | dkS ©Nr   r   ©r   r   r   r   Ú<lambda>Ç   ó    zis_increasing.<locals>.<lambda>©r#   ©r   r    r   r   r   r   Úis_increasingŸ   ó   (r+   c                 C   r$   )at  
    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

    c                 S   s   | dkS r%   r   r&   r   r   r   r'   ò   r(   z(is_strictly_increasing.<locals>.<lambda>r)   r*   r   r   r   Úis_strictly_increasingÊ   r,   r-   c                 C   r$   )a7  
    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

    c                 S   s   | dkS r%   r   r&   r   r   r   r'     r(   zis_decreasing.<locals>.<lambda>r)   r*   r   r   r   Úis_decreasingõ   r,   r.   c                 C   r$   )a  
    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

    c                 S   s   | dk S r%   r   r&   r   r   r   r'   F  r(   z(is_strictly_decreasing.<locals>.<lambda>r)   r*   r   r   r   Úis_strictly_decreasing   s   &r/   c                 C   sd   t | ƒ} | j}|du rt|ƒdkrtdƒ‚|p |r| ¡ ntdƒ}t|  |¡||ƒ}| |¡t	j
u S )ak  
    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

    Nr   zKis_monotonic has not yet been implemented for all multivariate expressions.r   )r   r   r   r   r   r   r   r   Úintersectionr   r   )r   r    r   r!   r"   Zturning_pointsr   r   r   Úis_monotonicI  s   .ÿr1   )N)Ú__doc__Zsympyr   r   Zsympy.core.sympifyr   Zsympy.solvers.solvesetr   Zsympy.utilities.miscr   r   r   r#   r+   r-   r.   r/   r1   r   r   r   r   Ú<module>   s    
X/+++)