
    \h/                     n   S r SSKJr  SSKJr  SSKJr  SSKJr  SSK	J
r
  SSKJrJrJrJrJr  SSKJrJrJrJrJrJrJrJrJr  SS	KJr  SS jr\R<                  S
4S jr\R<                  S
4S jr \R<                  S
4S jr!\R<                  S
4S jr"\R<                  S
4S jr#\R<                  S
4S jr$g
)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                    SSK Jn  Uc1  UR                  (       a  [        R                  O[        R
                  n [        R                  nU R                  [        [        [        [        /[        5      nUR                  [        [        [        [         /["        5      nUR%                  [&        5       HV  nUR(                  R*                  (       a  [,        eUR(                  R.                  (       d  MA  XC" UR0                  X5      -  nMX     U R%                  [2        [4        [6        5       H  nXC" UR8                  S   X5      -  nM     U R%                  [:        [<        5       H9  nXC" UR8                  S   S-
  X5      -  nXC" UR8                  S   S-   X5      -  nM;     U$ ! [,         a    [-        [?        S5      5      ef = f)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          T/var/www/auris/envauris/lib/python3.13/site-packages/sympy/calculus/singularities.pysingularitiesr/      sb   x 0~"NN;

S#s3S9IItT4.5Auu  ))uu   !&&&99  !!#ue4AXaffQi88E 5!!%/AXaffQi!mV<<EXaffQi!mV<<E 0  ;!* .9 #: ; 	;;s   B6F& 6B/F& &Gc                 L   SSK Jn  [        U 5      n U R                  nUc  [	        U5      S:  a  [        S5      eU=(       d"    U(       a  UR                  5       O
[        S5      nU R                  U5      nU" U" U5      U[        R                  5      nUR                  U5      $ )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~t9q=%5 
 >$((*&+H*J!)J"7177K011    c                     [        U S X5      $ )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                     U S:  $ Nr    r1   s    r.   <lambda>is_increasing.<locals>.<lambda>       Q!Vr>   r=   r(   r8   r)   s      r.   is_increasingrI      s    P z+;XNNr>   c                     [        U S X5      $ )a  
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                     U S:  $ rA   rB   rC   s    r.   rD   (is_strictly_increasing.<locals>.<lambda>       QUr>   rG   rH   s      r.   is_strictly_increasingrN          P z?HMMr>   c                     [        U S X5      $ )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                     U S:*  $ rA   rB   rC   s    r.   rD   is_decreasing.<locals>.<lambda>+  rF   r>   rG   rH   s      r.   is_decreasingrS      s    X z+;XNNr>   c                     [        U S X5      $ )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(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                     U S:  $ rA   rB   rC   s    r.   rD   (is_strictly_decreasing.<locals>.<lambda>V  rM   r>   rG   rH   s      r.   is_strictly_decreasingrW   .  rO   r>   c                 >   SSK Jn  [        U 5      n U R                  nUc  [	        U5      S:  a  [        S5      eU=(       d"    U(       a  UR                  5       O
[        S5      nU" U R                  U5      XQ5      nUR                  U5      [        R                  L $ )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_monotonicr[   Y  s    ` 0$J""D~#d)a-!1
 	

 >$((*&+Hjooh7LN  0AJJ>>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=   rI   rN   rS   rW   r[   rB   r>   r.   <module>re      s   " ! " $ & 6 L L> > > +S;v 9: .2b ()wwt (OV 12 (NV ()wwt ,O^ 12 (NV '(ggd =?r>   