Ë
    7^(h˜/  ã                   ó`  — d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	m
Z
 ddlmZmZmZmZmZ ddlmZmZmZmZmZmZmZmZmZ dd	lmZ dd„Zej<                  d
fd„Zej<                  d
fd„Z ej<                  d
fd„Z!ej<                  d
fd„Z"ej<                  d
fd„Z#ej<                  d
fd„Z$y
)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

é    )ÚPow)ÚS)ÚSymbol)Úsympify)Úlog)ÚsecÚcscÚcotÚtanÚcos)	ÚsechÚcschÚcothÚtanhÚcoshÚasechÚacschÚatanhÚacoth)Ú
filldedentNc                 óp  — ddl m} |€,|j                  rt        j                  nt        j
                  }	 t        j                  }| j                  t        t        t        t        gt        «      }|j                  t        t        t        t         gt"        «      }|j%                  t&        «      D ]L  }|j(                  j*                  rt,        ‚|j(                  j.                  sŒ6| ||j0                  ||«      z  }ŒN | j%                  t2        t4        t6        «      D ]  }| ||j8                  d   ||«      z  }Œ | j%                  t:        t<        «      D ]<  }| ||j8                  d   dz
  ||«      z  }| ||j8                  d   dz   ||«      z  }Œ> |S # t,        $ r t-        t?        d«      «      ‚w xY 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 import singularities, 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   ©Úsolveseté   zl
            Methods for determining the singularities
            of this function have not been developed.) Úsympy.solvers.solvesetr   Úis_realr   ÚRealsÚ	ComplexesÚEmptySetÚrewriter   r	   r
   r   r   r   r   r   r   r   Úatomsr   ÚexpÚis_infiniteÚNotImplementedErrorÚis_negativeÚbaser   r   r   Úargsr   r   r   )Ú
expressionÚsymbolÚdomainr   ÚsingsÚeÚis          úZ/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/calculus/singularities.pyÚsingularitiesr/      sv  € õx 0à€~Ø"ŸNšN”—’´·±ˆð;Ü—
‘
ˆØ×Ñ¤¤S¬#¬sÐ3´SÓ9ˆØ�I‰I”tœT¤4¬Ð.´Ó5ˆØ—‘œ“ò 	:ˆAØ�u‰u× Ò Ü)Ð)Ø�u‰u× Ó à™ !§&¡&¨&°&Ó9Ñ9‘ð	:ð ×!Ñ!¤#¤u¬eÓ4ò 	9ˆAØ‘X˜aŸf™f Q™i¨°Ó8Ñ8‰Eð	9à×!Ñ!¤%¬Ó/ò 	=ˆAØ‘X˜aŸf™f Q™i¨!™m¨V°VÓ<Ñ<ˆEØ‘X˜aŸf™f Q™i¨!™m¨V°VÓ<Ñ<‰Eð	=ð ˆøÜò ;Ü!¤*ð .9ó #:ó ;ð 	;ð;ús   ¶B.F Ã%B1F ÆF5c                 ó4  — ddl m} t        | «      } | j                  }|€t	        |«      dkD  rt        d«      ‚|xs |r|j                  «       n
t        d«      }| j                  |«      } | ||«      |t        j                  «      }|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.

    r   r   r   zKThe function has not yet been implemented for all multivariate expressions.Úx)r   r   r   Úfree_symbolsÚlenr$   Úpopr   Údiffr   r   Ú	is_subset)	r(   Ú	predicateÚintervalr)   r   ÚfreeÚvariableÚ
derivativeÚpredicate_intervals	            r.   Úmonotonicity_helperr=   x   s�   € õ> 0ä˜Ó$€JØ×"Ñ"€Dà€~Üˆt‹9�qŠ=Ü%ð5óð ð
 Ò>©˜$Ÿ(™(œ*´&¸³+€HØ—‘ Ó*€JÙ!¡)¨JÓ"7¸Ä1Ç7Á7ÓKÐØ×ÑÐ0Ó1Ð1ó    c                 ó    — t        | 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                 ó   — | dk\  S ©Nr   © ©r1   s    r.   ú<lambda>zis_increasing.<locals>.<lambda>Ñ   ó
   € °Q¸!±V€ r>   ©r=   ©r(   r8   r)   s      r.   Úis_increasingrH   ©   s   € ôP ˜zÑ+;¸XÀvÓNÐNr>   c                 ó    — t        | d„ ||«      S )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                 ó   — | dkD  S rA   rB   rC   s    r.   rD   z(is_strictly_increasing.<locals>.<lambda>ü   ó
   € °Q¸±U€ r>   rF   rG   s      r.   Úis_strictly_increasingrL   Ô   ó   € ôP ˜z©?¸HÀfÓMÐMr>   c                 ó    — t        | d„ ||«      S )aÊ  
    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(S(3)/2, 3))
    True
    >>> 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(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
    False
    >>> is_decreasing(-x**2, Interval(-oo, 0))
    False
    >>> is_decreasing(-x**2 + y, Interval(-oo, 0), x)
    False

    c                 ó   — | dk  S rA   rB   rC   s    r.   rD   zis_decreasing.<locals>.<lambda>+  rE   r>   rF   rG   s      r.   Úis_decreasingrP   ÿ   s   € ôX ˜zÑ+;¸XÀvÓNÐNr>   c                 ó    — t        | d„ ||«      S )aZ  
    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(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
    False
    >>> is_strictly_decreasing(-x**2, Interval(-oo, 0))
    False
    >>> is_strictly_decreasing(-x**2 + y, Interval(-oo, 0), x)
    False

    c                 ó   — | dk  S rA   rB   rC   s    r.   rD   z(is_strictly_decreasing.<locals>.<lambda>V  rK   r>   rF   rG   s      r.   Úis_strictly_decreasingrS   .  rM   r>   c                 ó(  — ddl m} t        | «      } | j                  }|€t	        |«      dkD  rt        d«      ‚|xs |r|j                  «       n
t        d«      } || j                  |«      ||«      }|j                  |«      t        j                  u S )a³  
    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(S(3)/2, 3))
    True
    >>> 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

    r   r   r   zKis_monotonic has not yet been implemented for all multivariate expressions.r1   )r   r   r   r2   r3   r$   r4   r   r5   Úintersectionr   r   )r(   r8   r)   r   r9   r:   Úturning_pointss          r.   Úis_monotonicrW   Y  s‰   € õ` 0ä˜Ó$€Jà×"Ñ"€DØ€~œ#˜d›) aš-Ü!ð1ó
ð 	
ð
 Ò>©˜$Ÿ(™(œ*´&¸³+€HÙ˜jŸo™o¨hÓ7¸À8ÓL€NØ× Ñ  Ó0´A·J±JÐ>Ð>r>   )N)%Ú__doc__Úsympy.core.powerr   Úsympy.core.singletonr   Úsympy.core.symbolr   Úsympy.core.sympifyr   Ú&sympy.functions.elementary.exponentialr   Ú(sympy.functions.elementary.trigonometricr   r	   r
   r   r   Ú%sympy.functions.elementary.hyperbolicr   r   r   r   r   r   r   r   r   Úsympy.utilities.miscr   r/   r   r=   rH   rL   rP   rS   rW   rB   r>   r.   ú<module>ra      s£   ðñõ" !Ý "Ý $Ý &Ý 6ß LÕ L÷>÷ >õ >å +óS;ðv 9:¿¹Èó .2ðb ()§w¡w°tó (OðV 12·±Àó (NðV ()§w¡w°tó ,Oð^ 12·±Àó (NðV '(§g¡g°dô =?r>   