�
��g�/ � �& � d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m
Z
ddl m Z m
Z
mZmZmZ ddlmZmZmZmZmZmZmZmZmZ dd lm Z dd �Z ej d
fd �Z ej d
fd
�Z ej d
fd�Z!ej d
fd�Z"ej d
fd�Z#ej d
fd�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
� )�Pow)�S)�Symbol)�sympify)�log)�sec�csc�cot�tan�cos) �sech�csch�coth�tanh�cosh�asech�acsch�atanh�acoth)�
filldedentNc �v � ddl m} |� |j r t j n t j } t j }| � t t t t gt � � }|� t t t t gt" � � }|� t& � � D ]6}|j j rt, �|j j r| ||j ||� � z
}�7| � t2 t4 t6 � � D ] }| ||j d ||� � z
}� | � t: t< � � D ]>}| ||j d dz
||� � z
}| ||j d dz ||� � z
}�?|S # t, $ r t- t? d� � � � �w xY 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 ��solvesetN� 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 �l/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sympy/calculus/singularities.py�
singularitiesr/ s� � �x 0�/�/�/�/�/�
�~� "�N�;����� ��;��
�� � � ��S�#�s� 3�S� 9� 9��
�I�I�t�T�4��.�� 5� 5������ � � :� :�A��u� �
*�)�)��u� �
:����!�&�&�&�9�9�9����!�!�#�u�e�4�4� 9� 9�A� �X�X�a�f�Q�i���8�8� 8�E�E��!�!�%��/�/� =� =�A� �X�X�a�f�Q�i�!�m�V�V�<�<� <�E� �X�X�a�f�Q�i�!�m�V�V�<�<� <�E�E�� �� � ;� ;� ;�!�*� .9� #:� #:� ;� ;� ;�;���s �E'F �'F8c �d � ddl m} t | � � } | j }|�"t |� � dk rt d� � �|p$|r|� � � nt d� � }| � |� � } | ||� � |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.
r r Nr 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�9�q�=�=�%�5�� �
�
�>��=�$�(�(�*�*�*�&��+�+�H�� � ��*�*�J�!��)�)�J�"7�"7��1�7�K�K�� � � � 0� 1� 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 � � | dk 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� 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 � � | dk 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� 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 � � | dk 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� 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 � � | dk 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 �R � ddl m} t | � � } | j }|�"t |� � dk rt d� � �|p$|r|� � � nt d� � } || � |� � ||� � }|� |� � 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 Nr 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� �X�j�o�o�h� 7� 7��8�L�L�N� � � � � 0� 0�A�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� 6� 6� 6� 6� 6� L� L� L� L� L� L� L� L� L� L� L� L� L� L�>� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� >� +� +� +� +� +� +�S;� S;� S;� S;�v 9:��� .2� .2� .2� .2�b ()�w�t� (O� (O� (O� (O�V 12��� (N� (N� (N� (N�V ()�w�t� ,O� ,O� ,O� ,O�^ 12��� (N� (N� (N� (N�V '(�g�d� =?� =?� =?� =?� =?� =?r>