� ��g�o����ddlmZmZmZmZddlmZddlmZddl m Z m Z m Z ddl mZmZmZmZddlmZddlmZmZddlmZdd lmZdd lmZdd lmZGd �d e��Zeee��d���Z eee��d���Z eee��d���Z!eee��d���Z!eee��d���Z!eee��d���Z!eZ"dS)�)�Add�Mul�Pow�S)�Basic)�Expr)� _sympifyit�oo�zoo)�is_le�is_lt�is_ge�is_gt)�_sympify)�Min�Max)�And)�dispatch)�Order)� FiniteSetc�"�eZdZdZdZdZd�ZdZd�Ze d���Z e d���Z e d ���Z e d ���Z ed e��d ���Zed e��d ���ZeZd�Zed e��d���Zed e��d���Zed e��d���ZeZed e��d���Zed e��d���Zed e��d���Zed e��d���Zd�Zd�Zd�Zd�ZdS)�AccumulationBoundsaAn accumulation bounds. # Note AccumulationBounds has an alias: AccumBounds AccumulationBounds represent an interval `[a, b]`, which is always closed at the ends. Here `a` and `b` can be any value from extended real numbers. The intended meaning of AccummulationBounds is to give an approximate location of the accumulation points of a real function at a limit point. Let `a` and `b` be reals such that `a \le b`. `\left\langle a, b\right\rangle = \{x \in \mathbb{R} \mid a \le x \le b\}` `\left\langle -\infty, b\right\rangle = \{x \in \mathbb{R} \mid x \le b\} \cup \{-\infty, \infty\}` `\left\langle a, \infty \right\rangle = \{x \in \mathbb{R} \mid a \le x\} \cup \{-\infty, \infty\}` `\left\langle -\infty, \infty \right\rangle = \mathbb{R} \cup \{-\infty, \infty\}` ``oo`` and ``-oo`` are added to the second and third definition respectively, since if either ``-oo`` or ``oo`` is an argument, then the other one should be included (though not as an end point). This is forced, since we have, for example, ``1/AccumBounds(0, 1) = AccumBounds(1, oo)``, and the limit at `0` is not one-sided. As `x` tends to `0-`, then `1/x \rightarrow -\infty`, so `-\infty` should be interpreted as belonging to ``AccumBounds(1, oo)`` though it need not appear explicitly. In many cases it suffices to know that the limit set is bounded. However, in some other cases more exact information could be useful. For example, all accumulation values of `\cos(x) + 1` are non-negative. (``AccumBounds(-1, 1) + 1 = AccumBounds(0, 2)``) A AccumulationBounds object is defined to be real AccumulationBounds, if its end points are finite reals. Let `X`, `Y` be real AccumulationBounds, then their sum, difference, product are defined to be the following sets: `X + Y = \{ x+y \mid x \in X \cap y \in Y\}` `X - Y = \{ x-y \mid x \in X \cap y \in Y\}` `X \times Y = \{ x \times y \mid x \in X \cap y \in Y\}` When an AccumBounds is raised to a negative power, if 0 is contained between the bounds then an infinite range is returned, otherwise if an endpoint is 0 then a semi-infinite range with consistent sign will be returned. AccumBounds in expressions behave a lot like Intervals but the semantics are not necessarily the same. Division (or exponentiation to a negative integer power) could be handled with *intervals* by returning a union of the results obtained after splitting the bounds between negatives and positives, but that is not done with AccumBounds. In addition, bounds are assumed to be independent of each other; if the same bound is used in more than one place in an expression, the result may not be the supremum or infimum of the expression (see below). Finally, when a boundary is ``1``, exponentiation to the power of ``oo`` yields ``oo``, neither ``1`` nor ``nan``. Examples ======== >>> from sympy import AccumBounds, sin, exp, log, pi, E, S, oo >>> from sympy.abc import x >>> AccumBounds(0, 1) + AccumBounds(1, 2) AccumBounds(1, 3) >>> AccumBounds(0, 1) - AccumBounds(0, 2) AccumBounds(-2, 1) >>> AccumBounds(-2, 3)*AccumBounds(-1, 1) AccumBounds(-3, 3) >>> AccumBounds(1, 2)*AccumBounds(3, 5) AccumBounds(3, 10) The exponentiation of AccumulationBounds is defined as follows: If 0 does not belong to `X` or `n > 0` then `X^n = \{ x^n \mid x \in X\}` >>> AccumBounds(1, 4)**(S(1)/2) AccumBounds(1, 2) otherwise, an infinite or semi-infinite result is obtained: >>> 1/AccumBounds(-1, 1) AccumBounds(-oo, oo) >>> 1/AccumBounds(0, 2) AccumBounds(1/2, oo) >>> 1/AccumBounds(-oo, 0) AccumBounds(-oo, 0) A boundary of 1 will always generate all nonnegatives: >>> AccumBounds(1, 2)**oo AccumBounds(0, oo) >>> AccumBounds(0, 1)**oo AccumBounds(0, oo) If the exponent is itself an AccumulationBounds or is not an integer then unevaluated results will be returned unless the base values are positive: >>> AccumBounds(2, 3)**AccumBounds(-1, 2) AccumBounds(1/3, 9) >>> AccumBounds(-2, 3)**AccumBounds(-1, 2) AccumBounds(-2, 3)**AccumBounds(-1, 2) >>> AccumBounds(-2, -1)**(S(1)/2) sqrt(AccumBounds(-2, -1)) Note: `\left\langle a, b\right\rangle^2` is not same as `\left\langle a, b\right\rangle \times \left\langle a, b\right\rangle` >>> AccumBounds(-1, 1)**2 AccumBounds(0, 1) >>> AccumBounds(1, 3) < 4 True >>> AccumBounds(1, 3) < -1 False Some elementary functions can also take AccumulationBounds as input. A function `f` evaluated for some real AccumulationBounds `\left\langle a, b \right\rangle` is defined as `f(\left\langle a, b\right\rangle) = \{ f(x) \mid a \le x \le b \}` >>> sin(AccumBounds(pi/6, pi/3)) AccumBounds(1/2, sqrt(3)/2) >>> exp(AccumBounds(0, 1)) AccumBounds(1, E) >>> log(AccumBounds(1, E)) AccumBounds(0, 1) Some symbol in an expression can be substituted for a AccumulationBounds object. But it does not necessarily evaluate the AccumulationBounds for that expression. The same expression can be evaluated to different values depending upon the form it is used for substitution since each instance of an AccumulationBounds is considered independent. For example: >>> (x**2 + 2*x + 1).subs(x, AccumBounds(-1, 1)) AccumBounds(-1, 4) >>> ((x + 1)**2).subs(x, AccumBounds(-1, 1)) AccumBounds(0, 4) References ========== .. [1] https://en.wikipedia.org/wiki/Interval_arithmetic .. [2] https://fab.cba.mit.edu/classes/S62.12/docs/Hickey_interval.pdf Notes ===== Do not use ``AccumulationBounds`` for floating point interval arithmetic calculations, use ``mpmath.iv`` instead. TFc�0�t|��}t|��}|jr|jstd���||kr|S|jr|jr|jo |jo||k}n ||z j}|rtd���t j|||��S)Nz*Only real AccumulationBounds are supportedz.Lower limit should be smaller than upper limit)r�is_extended_real� ValueError� is_number� is_comparable�is_extended_negativer�__new__)�cls�min�max�bads �q/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sympy/calculus/accumulationbounds.pyrzAccumulationBounds.__new__�s����s�m�m���s�m�m���#� K�3�+?� K��I�J�J� J� �#�:�:��J� �=� 3�S�]� 3��#�G��(9�G�c�C�i�C�C���9�2�C� � B��@�B�B� B��}�S�#�s�+�+�+�g&@c�>�|jjr|jjrdSdSdS)NT)r!�is_realr"��selfs r$� _eval_is_realz AccumulationBounds._eval_is_real�s4�� �8� � ��� 0� ��4� � � � r%c��|jdS)z� Returns the minimum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).min 1 r��argsr(s r$r!zAccumulationBounds.min�����y��|�r%c��|jdS)z� Returns the maximum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).max 3 �r,r(s r$r"zAccumulationBounds.max�r.r%c� �|j|jz S)a7 Returns the difference of maximum possible value attained by AccumulationBounds object and minimum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).delta 2 )r"r!r(s r$�deltazAccumulationBounds.delta�s���x�$�(�"�"r%c�&�|j|jzdz S)a/ Returns the mean of maximum possible value attained by AccumulationBounds object and minimum possible value attained by AccumulationBounds object. Examples ======== >>> from sympy import AccumBounds >>> AccumBounds(1, 3).mid 2 �)r!r"r(s r$�midzAccumulationBounds.mid s����4�8�#�q�(�(r%�otherc�,�|�|��S�N)�__pow__�r)r6s r$� _eval_powerzAccumulationBounds._eval_powers���|�|�E�"�"�"r%c��t|t���r�t|t��r@tt|j|j��t|j|j����S|t jur|jt jus!|t jur.|jt jurtt t��S|j r�|jt jur.|jt jurtt t��S|jt jurtt |j|z��S|jt jurt|j|zt��Stt|j|��t|j|����St||d���StS�NF��evaluate) � isinstancer� AccumBoundsrr!r"r�Infinity�NegativeInfinityr r�NotImplementedr:s r$�__add__zAccumulationBounds.__add__st�� �e�T� "� "� 4��%��-�-� .�"����%�)�,�,����%�)�,�,�.�.�.��� �"�"�t�x�1�3E�'E�'E��Q�/�/�/�D�H�� �4J�4J�"�B�3��+�+�+��'� S��8�q�1�1�1�d�h�!�*�6L�6L�&��s�B�/�/�/��X��!3�3�3�&��s�D�H�u�,<�=�=�=��X���+�+�&�t�x�%�'7��<�<�<�&�s�4�8�U�';�';�S���5�=Q�=Q�R�R�R��t�U�U�3�3�3� 3��r%c�:�t|j |j ��Sr8)rAr"r!r(s r$�__neg__zAccumulationBounds.__neg__7s���D�H�9�t�x�i�0�0�0r%c��t|t���r�t|t��rBtt|j|j ��t|j|j ����S|t jur|jt jus!|t jur.|jt jurtt t��S|j r�|jt jur.|jt jurtt t��S|jt jurtt |j|z ��S|jt jurt|j|z t��Stt|j| ��t|j| ����St|| d���StSr=) r@rrArr!r"rrCrBr rrDr:s r$�__sub__zAccumulationBounds.__sub__:s��� �e�T� "� "� 5��%��-�-� /�"����5�9�*�-�-����5�9�*�-�-�/�/�/���*�*�*�t�x�1�;M�/M�/M��Q�Z�'�'�D�H�� �,B�,B�"�B�3��+�+�+��'� /��8�q�1�1�1�d�h�!�*�6L�6L�&��s�B�/�/�/��X��!3�3�3�&��s�D�H�u�,<�=�=�=��X���+�+�&�t�x�%�'7��<�<�<�&��D�H�u�f�-�-��D�H�u�f�-�-�/�/�/��t�e�V�e�4�4�4� 4��r%c�0�|���|zSr8)rGr:s r$�__rsub__zAccumulationBounds.__rsub__Rs���|�|�~�~��%�%r%c���|jt tfkr|St|t���r7t|t��rr|jt tfkr|St ��}|jD]$}||z}|�|jp|f���%t t|�t|���S|tj urC|j j rt dt��S|j j rt t d��S|tjurC|j j rt t d��S|j j rt dt��S|jr�|j r]|j tj urt dt��S|j tjurt t d��StjS|jr6t t%|j |��t%|j |����S|jr6t t%|j |��t%|j |����St|t(��r|St%||d���St*S)NrFr>)r-r r@rrA�set�updaterrrrBr!�is_zeror"rCr�Zero�is_extended_positiverrrrD)r)r6�v�a�vis r$�__mul__zAccumulationBounds.__mul__VsK�� �9�"��b� � !� !��K� �e�T� "� "�$ 4��%��-�-� 5��:�2�#�r��*�*� �L��E�E����/�/�A��q��B��H�H�R�W�-���.�.�.�.�"�3��7�C��G�4�4�4��� �"�"��8�#�.�&�q�"�-�-�-��8�#�/�&��s�A�.�.�.���*�*�*��8�#�/�&��s�A�.�.�.��8�#�.�&�q�"�-�-�-��%� .��=�"��x�1�:�-�-�*�1�b�1�1�1��x�1�#5�5�5�*�B�3��2�2�2��6�M��-�.�&��D�H�e�,�,��D�H�e�,�,�.�.�.��/�.�&��D�H�e�,�,��D�H�e�,�,�.�.�.��%��'�'� �� ��t�U�U�3�3�3� 3��r%c��t|t���r�t|t���r3|jjs |jjr#|td|jz d|jz ��zS|jjr�|jjr�|jjr�|jjrv|jj r!|jj rtdt��S|jj r"|jj rtt d��Stt t��S|jj r�|jj rU|jj r"t|j|jz t��S|jj rtt t��S|jj r/|jj r#tt |j|jz ��S|jj r�|jj rV|jj r#tt |j|jz ��S|jj rtt t��S|jj r.|jj r"t|j|jz t��S�n*|j �r"|tjtjfvr�|tt t��krtt t��S|jtjur,tt#d|��t%d|����S|jtjur.tt#d| ��t%d| ����S|j r t|j|z |j|z ��S|j r t|j|z |j|z ��Sd|z tjurt)|d|z d���St)|d|z ��St*S)Nr0rFr>)r@rrAr!� is_positiver"� is_negative�is_extended_nonpositive�is_extended_nonnegativerOr rrQrrrBrCrr�ComplexInfinityrrDr:s r$� __truediv__zAccumulationBounds.__truediv__�su�� �e�T� "� "�6 ,��%��-�-�1 K��9�(�H�E�I�,A�H��+�a�� �k�1�U�Y�;�"G�"G�G�G��H�4�0���9Y�0��I�5�0�:?�)�:[�0��x�'�2�E�I�,=�2�*�1�b�1�1�1��x�'�3�E�I�,=�3�*�B�3��2�2�2�&��s�B�/�/�/��8�0� F��y�5�8� �9�,�I�#.�t�x�%�)�/C�R�#H�#H�H� �9�9�8�$/��s�B�#7�#7�7��y�(�F�U�Y�-K�F�*�B�3���5�9�0D�E�E�E��8�0� E��y�5�8� �9�,�J�#.��s�D�H�u�y�4H�#I�#I�I� �9�9�8�$/��s�B�#7�#7�7��y�(�E�U�Y�-K�E�*�4�8�e�i�+?��D�D�D���'� K��Q�Z��);�<�<�<��{�B�3��3�3�3�3�*�B�3��3�3�3��x�1�:�-�-�*�3�q�%�=�=�#�a��-�-�H�H�H��x�1�#5�5�5�*�3�q�5�&�>�>�3�q�5�&�>�>�J�J�J��-�K�&�t�x�%�'7���E�9I�J�J�J��/�K�&�t�x�%�'7���E�9I�J�J�J��E� �a�/�/�/��4��U��U�;�;�;�;��4��U��+�+�+��r%c�`�t|t���r�|j�ru|jr tjS|jj�r |jj r�|jjre|j r+tt|d|jz ��t��S|jr,tt t|d|jz ����S|jjre|j r,tt t|d|jz ����S|jr+tt|d|jz ��t��Stt t��Stt||jz ||jz ��t!||jz ||jz ����St|d|z d���St"S)Nr0Fr>)r@rrrOrrPr!rYr"rZrQrArr rrrrDr:s r$� __rtruediv__zAccumulationBounds.__rtruediv__�s��� �e�T� "� "� "��%� P��=�"��6�M��H�4�P���9Y�P��x�'�N� �5�M�#.�s�5�!�d�h�,�/G�/G��#L�#L�L� �5�N�#.��s�C��q�4�8�|�4L�4L�#M�#M�M��x�'�M� �5�N�#.��s�C��q�4�8�|�4L�4L�#M�#M�M� �5�M�#.�s�5�!�d�h�,�/G�/G��#L�#L�L�&��s�B�/�/�/�&�s�5�4�8�+;�U�T�X�=M�'N�'N�'*�5�4�8�+;�U�T�X�=M�'N�'N�P�P�P��u�a�$�h��7�7�7� 7�!� !r%c� ���t|t���r�|tjur�jjrC�jdkr tjS�jdkr tjStdt��S�jj r5�jdkr tjS�jdkrtStj S�jdkr,�jdkr tjStdt��Stt t��S|tj ur d�z tzS�j�jz jr9�jjr-|jr&���j|z�j|z��S|jr tjS|js|j�r߉jjrLtt+�j|z�j|z��t-�j|z�j|z����S�jj rLtt+�j|z�j|z��t-�j|z�j|z����S|dzdkr�|j r[�jjrt�j|zt��S�jjrt�j|zt��Sd�z | zSttjt-�j|z�j|z����S|dzdkr�|j r\�jjrt�j|zt��S�jjrtt �j|z��Sd�z | zSt�j|z�j|z��S|js|jrw�jjs|jrd�jjrX|���\}�|tjurt�fd��jD���S�tjur �|zd�z zSt|t��r��jjs�jjr�|jjry�fd�|jD��}t7d�|D����sMd�|D��} ��t |��t |����S#t8$rYnwxYwt;�|d � ��St<S) Nr0r�����r4c� ��g|] }|d�z z�� S)r0�)�.0�i�dens �r$� <listcomp>z.AccumulationBounds.__pow__.<locals>.<listcomp>"s!���(G�(G�(G���Q�s�U��(G�(G�(Gr%c���g|]}�|z��Srbrb)rcrdr)s �r$rfz.AccumulationBounds.__pow__.<locals>.<listcomp>+s���5�5�5�Q��q��5�5�5r%c3�$K�|] }|jV�� dSr8)�is_Pow)rcrds r$� <genexpr>z-AccumulationBounds.__pow__.<locals>.<genexpr>,s$����3�3�A�q�x�3�3�3�3�3�3r%c�,�g|]}|jp|fD]}|���Srbr,)rcrd�js r$rfz.AccumulationBounds.__pow__.<locals>.<listcomp>-s-��B�B�B�1�1�6�>�a�T�B�B�a�Q�B�B�B�Br%Fr>)r@rrrBr!rZr"rPrAr rr �NaNrC�is_nonnegative�funcrO�One� is_Integer� is_integerrQrrr� is_rational�as_numer_denomr-�any� TypeErrorrrD)r)r6�num�prSres` @r$r9zAccumulationBounds.__pow__�s����� �e�T� "� "�Y 4��� �"�"��8�3�0��x�!�|�|� �v� ��x�!�|�|� �z�)�&�q�"�-�-�-��X�2� 0��x�"�}�}� �v� ��x�"�}�}�"� ��5�L��x�"�}�}��8�a�<�<�#$�6�M�*�1�b�1�1�1�&��s�B�/�/�/���*�*�*��$���|�#���4�8�#�3� K��8�*�K��+�K�#�y�y���5��$�(�E�/�J�J�J��}� ��u� ��� I�5�#3� I��8�0�?�&��D�H�e�O�T�X�u�_�=�=��D�H�e�O�T�X�u�_�=�=�?�?�?��X�2�?�&��D�H�e�O�T�X�u�_�=�=��D�H�e�O�T�X�u�_�=�=�?�?�?��1�9��>�>��1�2��8�+�D�#.�t�x����#C�#C�C��8�+�D�#.�t�x����#C�#C�C� !�$��5�&�1�1�&����D�H�e�O�T�X�u�_� E� E�G�G�G��Q�Y�!�^�^��1�2��8�+�D�#.�t�x����#C�#C�C��8�+�E�#.��s�D�H�e�O�#D�#D�D� !�$��5�&�1�1�&�t�x�����%��H�H�H��� 0�5�#4� 0��H�4� 0��1� 0��H�4� 0�!�/�/�1�1���S��!�%�<�<�&�(G�(G�(G�(G�T�Y�(G�(G�(G�H�H����%�%� �#�I��3��/�/��%��-�-� !��H�1� !���8� !�� �9� !�6�5�5�5�%�*�5�5�5�A��3�3��3�3�3�3�3�!�B�B��B�B�B��!�#'�9�9�S��V�V�S��V�V�#<�#<�<��(�!�!�!� �D�!�����t�U�U�3�3�3� 3��s�)/R� R&�%R&c����jr��jr�|j|jz jr��t jur t jS�jrD�fd�|jD��\}}t||��|kr||}}|�||��S�j r:|jj r|�dd��S|jjr t j St�|d���S)Nc���g|]}�|z��Srbrb)rcrdr6s �r$rfz/AccumulationBounds.__rpow__.<locals>.<listcomp>>s���4�4�4�Q��q��4�4�4r%rr0Fr>) r'rZr"r!rQrrpr-rorOrPr)r)r6rS�bs ` r$�__rpow__zAccumulationBounds.__rpow__7s���� �=� "�U�:� "���4�8�#�%9� "����~�~��u� ��)� '�4�4�4�4�$�)�4�4�4���1��q�!�9�9��>�>��a�q�A��y�y��A���&��}� "��8�#�+��9�9�Q��?�?�*��8�0�"��6�M��5�$��/�/�/�/r%c���|jjr|���S|jjr?t t jtt|j��|j����S|Sr8) r"rrGr!rArrPr�absr(s r$�__abs__zAccumulationBounds.__abs__JsU�� �8� (� ��<�<�>�>� !� �X� *� ��q�v�s�3�t�x�=�=�$�(�'C�'C�D�D� D��Kr%c��t|��}|tjtjfvr*|jtjus|jtjurdSdSt |j|k|j|k��}|dvrtd���|S)a� Returns ``True`` if other is contained in self, where other belongs to extended real numbers, ``False`` if not contained, otherwise TypeError is raised. Examples ======== >>> from sympy import AccumBounds, oo >>> 1 in AccumBounds(-1, 3) True -oo and oo go together as limits (in AccumulationBounds). >>> -oo in AccumBounds(1, oo) True >>> oo in AccumBounds(-oo, 0) True TF)TFzinput failed to evaluate)rrrBrCr!r"rrv)r)r6�rvs r$� __contains__zAccumulationBounds.__contains__Ss���,����� �Q�Z��!3�4� 4� 4��x�1�-�-�-���Q�Z�1G�1G��t��5� ���U�"�D�H��$5� 6� 6�� �]� "� "��6�7�7� 7�� r%c�d�t|ttf��std���t|t��r)tj}|D]}||vr|t|��z}�|S|j|jks|j|jkr tjS|j|jkr<|j|jkrt|j|j��S|j|jkr|S|j|jkr<|j|jkrt|j|j��S|j|jkr|SdSdS)a Returns the intersection of 'self' and 'other'. Here other can be an instance of :py:class:`~.FiniteSet` or AccumulationBounds. Parameters ========== other : AccumulationBounds Another AccumulationBounds object with which the intersection has to be computed. Returns ======= AccumulationBounds Intersection of ``self`` and ``other``. Examples ======== >>> from sympy import AccumBounds, FiniteSet >>> AccumBounds(1, 3).intersection(AccumBounds(2, 4)) AccumBounds(2, 3) >>> AccumBounds(1, 3).intersection(AccumBounds(4, 6)) EmptySet >>> AccumBounds(1, 4).intersection(FiniteSet(1, 2, 5)) {1, 2} �4Input must be AccumulationBounds or FiniteSet objectN)r@rArrvr�EmptySetr"r!)r)r6�fin_setrds r$� intersectionzAccumulationBounds.intersectionus?��@�%�+�y�!9�:�:� H��F�H�H� H� �e�Y� '� '� ��j�G�� 5� 5����9�9�%� �!� � �4�G���N� �8�e�i� � �4�8�e�i�#7�#7��:� � �8�u�y� � ��x�5�9�$�$�"�5�9�d�h�7�7�7��x�%�)�#�#�� � �9��� � ��y�4�8�#�#�"�4�8�U�Y�7�7�7��y�4�8�#�#�� � !� �$�#r%c��t|t��std���|j|jkr=|j|jkr-t|jt |j|j����S|j|jkr=|j|jkr/t|jt |j|j����SdSdS)Nr�)r@rArvr!r"rr:s r$�unionzAccumulationBounds.union�s����%��-�-� H��F�H�H� H� �8�u�y� � �T�X���%:�%:��t�x��T�X�u�y�)A�)A�B�B� B� �9��� � �U�Y�$�(�%:�%:��u�y�#�d�h�� �*B�*B�C�C� C� !� �%:�%:r%N) �__name__� __module__� __qualname__�__doc__rrr� _op_priorityr*�propertyr!r"r2r5r rDr;rE�__radd__rGrIrKrU�__rmul__r\r^r9r|rr�r�r�rbr%r$rrs�������g�g�R���I�,�,�,�0�L����� � ��X� �� � ��X� ��#�#��X�#� �)�)��X�)� �Z���(�(�#�#�)�(�#��Z���(�(���)�(��*�H�1�1�1��Z���(�(���)�(��.�Z���(�(�&�&�)�(�&��Z���(�(�(�(�)�(�(�T�H��Z���(�(�9�9�)�(�9�v�Z���(�(�"�"�)�(�"�0�Z���(�(�\�\�)�(�\�|�Z���(�(�0�0�)�(�0�$��� � � �D8�8�8�t D� D� D� D� Dr%rc�v�t|j|j��rdSt|j|j��rdSdS�NTF)r r"r!r��lhs�rhss r$� _eval_is_ler���B�� �S�W�c�g�����t� �S�W�c�g�����u��r%c���|js"tdt|���d|�����|jr.t |j|��rdSt |j|��rdSdSdS)af Returns ``True `` if range of values attained by ``lhs`` AccumulationBounds object is greater than the range of values attained by ``rhs``, where ``rhs`` may be any value of type AccumulationBounds object or extended real number value, ``False`` if ``rhs`` satisfies the same property, else an unevaluated :py:class:`~.Relational`. Examples ======== >>> from sympy import AccumBounds, oo >>> AccumBounds(1, 3) > AccumBounds(4, oo) False >>> AccumBounds(1, 4) > AccumBounds(3, 4) AccumBounds(1, 4) > AccumBounds(3, 4) >>> AccumBounds(1, oo) > -1 True �Invalid comparison of � TFN�rrv�typerr r"rr!r�s r$r�r��s���, � ���)��c�����C�C�!�"�"� "� � �� ���#� � � ��4� ���#� � � ��5� �� � r%c�v�t|j|j��rdSt|j|j��rdSdSr��rr!r"r r�s r$� _eval_is_ger��r�r%c���|js"tdt|���d|�����|jr.t |j|��rdSt |j|��rdSdSdS)ab Returns ``True`` if range of values attained by ``lhs`` AccumulationBounds object is less that the range of values attained by ``rhs``, where other may be any value of type AccumulationBounds object or extended real number value, ``False`` if ``rhs`` satisfies the same property, else an unevaluated :py:class:`~.Relational`. Examples ======== >>> from sympy import AccumBounds, oo >>> AccumBounds(1, 3) >= AccumBounds(4, oo) False >>> AccumBounds(1, 4) >= AccumBounds(3, 4) AccumBounds(1, 4) >= AccumBounds(3, 4) >>> AccumBounds(1, oo) >= 1 True r�r�TFN)rrvr�rrr!r r"r�s r$r�r��s���* � ���i� �#�Y�Y�Y�Y��� ��� � � �� ���#� � � ��4� ���#� � � ��5� �� � r%c���|js"tdt|���d|�����|jr.t |j|��rdSt |j|��rdSdSdS)Nr�r�TFr�r�s r$r�r�s��� � ���i� �#�Y�Y�Y�Y��� ��� � � �� ���#� � � ��4� ���#� � � ��5� �� � r%c�v�t|j|j��rdSt|j|j��rdSdSr�r�r�s r$r�r�r�r%N)#� sympy.corerrrr�sympy.core.basicr�sympy.core.exprr�sympy.core.numbersr r r �sympy.core.relationalr r rr�sympy.core.sympifyr�(sympy.functions.elementary.miscellaneousrr�sympy.logic.boolalgr�sympy.multipledispatchr�sympy.series.orderr�sympy.sets.setsrrr�r�rArbr%r$�<module>r�sA��'�'�'�'�'�'�'�'�'�'�'�'�"�"�"�"�"�"� � � � � � �2�2�2�2�2�2�2�2�2�2�<�<�<�<�<�<�<�<�<�<�<�<�'�'�'�'�'�'�=�=�=�=�=�=�=�=�#�#�#�#�#�#�+�+�+�+�+�+�$�$�$�$�$�$�%�%�%�%�%�%�m D�m D�m D�m D�m D��m D�m D�m D�` �� �0�1�1���2�1�� �� �e�$�$���%�$��@ �� �0�1�1���2�1�� �� �d�#�#���$�#��> ��$�"�#�#� � �$�#� � �� �0�1�1���2�1��!� � � r%
Memory