7^(h'%ddlmZddlmZGddeZGddeZGddeZGd d eZGd d eZGd deZ GddeZ GddeZ GddeZ GddeZ GddeZy)) Predicate) Dispatcherc(eZdZdZdZeddZy)NegativePredicateac Negative number predicate. Explanation =========== ``Q.negative(x)`` is true iff ``x`` is a real number and :math:`x < 0`, that is, it is in the interval :math:`(-\infty, 0)`. Note in particular that negative infinity is not negative. A few important facts about negative numbers: - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same thing. ``~Q.negative(x)`` simply means that ``x`` is not negative, whereas ``Q.nonnegative(x)`` means that ``x`` is real and not negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to ``Q.zero(x) | Q.positive(x)``. So for example, ``~Q.negative(I)`` is true, whereas ``Q.nonnegative(I)`` is false. - See the documentation of ``Q.real`` for more information about related facts. Examples ======== >>> from sympy import Q, ask, symbols, I >>> x = symbols('x') >>> ask(Q.negative(x), Q.real(x) & ~Q.positive(x) & ~Q.zero(x)) True >>> ask(Q.negative(-1)) True >>> ask(Q.nonnegative(I)) False >>> ask(~Q.negative(I)) True negativeNegativeHandlerzKHandler for Q.negative. Test that an expression is strictly less than zero.docN__name__ __module__ __qualname____doc__namerhandler`/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/sympy/assumptions/predicates/order.pyrrs!$J DGrrc(eZdZdZdZeddZy)NonNegativePredicateah Nonnegative real number predicate. Explanation =========== ``ask(Q.nonnegative(x))`` is true iff ``x`` belongs to the set of positive numbers including zero. - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same thing. ``~Q.negative(x)`` simply means that ``x`` is not negative, whereas ``Q.nonnegative(x)`` means that ``x`` is real and not negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to ``Q.zero(x) | Q.positive(x)``. So for example, ``~Q.negative(I)`` is true, whereas ``Q.nonnegative(I)`` is false. Examples ======== >>> from sympy import Q, ask, I >>> ask(Q.nonnegative(1)) True >>> ask(Q.nonnegative(0)) True >>> ask(Q.nonnegative(-1)) False >>> ask(Q.nonnegative(I)) False >>> ask(Q.nonnegative(-I)) False nonnegativeNonNegativeHandlerzHandler for Q.nonnegative.r Nr rrrrr3s@ D )Grrc(eZdZdZdZeddZy)NonZeroPredicatea Nonzero real number predicate. Explanation =========== ``ask(Q.nonzero(x))`` is true iff ``x`` is real and ``x`` is not zero. Note in particular that ``Q.nonzero(x)`` is false if ``x`` is not real. Use ``~Q.zero(x)`` if you want the negation of being zero without any real assumptions. A few important facts about nonzero numbers: - ``Q.nonzero`` is logically equivalent to ``Q.positive | Q.negative``. - See the documentation of ``Q.real`` for more information about related facts. Examples ======== >>> from sympy import Q, ask, symbols, I, oo >>> x = symbols('x') >>> print(ask(Q.nonzero(x), ~Q.zero(x))) None >>> ask(Q.nonzero(x), Q.positive(x)) True >>> ask(Q.nonzero(x), Q.zero(x)) False >>> ask(Q.nonzero(0)) False >>> ask(Q.nonzero(I)) False >>> ask(~Q.zero(I)) True >>> ask(Q.nonzero(oo)) False nonzeroNonZeroHandlerzKHandler for key 'nonzero'. Test that an expression is not identically zero.r Nr rrrrr[s!&N DGrrc(eZdZdZdZeddZy) ZeroPredicatea Zero number predicate. Explanation =========== ``ask(Q.zero(x))`` is true iff the value of ``x`` is zero. Examples ======== >>> from sympy import ask, Q, oo, symbols >>> x, y = symbols('x, y') >>> ask(Q.zero(0)) True >>> ask(Q.zero(1/oo)) True >>> print(ask(Q.zero(0*oo))) None >>> ask(Q.zero(1)) False >>> ask(Q.zero(x*y), Q.zero(x) | Q.zero(y)) True zero ZeroHandlerzHandler for key 'zero'.r Nr rrrrrs2 D %Grrc(eZdZdZdZeddZy)NonPositivePredicateah Nonpositive real number predicate. Explanation =========== ``ask(Q.nonpositive(x))`` is true iff ``x`` belongs to the set of negative numbers including zero. - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same thing. ``~Q.positive(x)`` simply means that ``x`` is not positive, whereas ``Q.nonpositive(x)`` means that ``x`` is real and not positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to `Q.negative(x) | Q.zero(x)``. So for example, ``~Q.positive(I)`` is true, whereas ``Q.nonpositive(I)`` is false. Examples ======== >>> from sympy import Q, ask, I >>> ask(Q.nonpositive(-1)) True >>> ask(Q.nonpositive(0)) True >>> ask(Q.nonpositive(1)) False >>> ask(Q.nonpositive(I)) False >>> ask(Q.nonpositive(-I)) False nonpositiveNonPositiveHandlerzHandler for key 'nonpositive'.r Nr rrrr"r"s B D ,Grr"c(eZdZdZdZeddZy)PositivePredicateaC Positive real number predicate. Explanation =========== ``Q.positive(x)`` is true iff ``x`` is real and `x > 0`, that is if ``x`` is in the interval `(0, \infty)`. In particular, infinity is not positive. A few important facts about positive numbers: - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same thing. ``~Q.positive(x)`` simply means that ``x`` is not positive, whereas ``Q.nonpositive(x)`` means that ``x`` is real and not positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to `Q.negative(x) | Q.zero(x)``. So for example, ``~Q.positive(I)`` is true, whereas ``Q.nonpositive(I)`` is false. - See the documentation of ``Q.real`` for more information about related facts. Examples ======== >>> from sympy import Q, ask, symbols, I >>> x = symbols('x') >>> ask(Q.positive(x), Q.real(x) & ~Q.negative(x) & ~Q.zero(x)) True >>> ask(Q.positive(1)) True >>> ask(Q.nonpositive(I)) False >>> ask(~Q.positive(I)) True positivePositiveHandlerzRHandler for key 'positive'. Test that an expression is strictly greater than zero.r Nr rrrr&r&s!$J DGrr&c$eZdZdZdZedZy)ExtendedPositivePredicatea Positive extended real number predicate. Explanation =========== ``Q.extended_positive(x)`` is true iff ``x`` is extended real and `x > 0`, that is if ``x`` is in the interval `(0, \infty]`. Examples ======== >>> from sympy import ask, I, oo, Q >>> ask(Q.extended_positive(1)) True >>> ask(Q.extended_positive(oo)) True >>> ask(Q.extended_positive(I)) False extended_positiveExtendedPositiveHandlerNr rrrr*r** D23Grr*c$eZdZdZdZedZy)ExtendedNegativePredicatea Negative extended real number predicate. Explanation =========== ``Q.extended_negative(x)`` is true iff ``x`` is extended real and `x < 0`, that is if ``x`` is in the interval `[-\infty, 0)`. Examples ======== >>> from sympy import ask, I, oo, Q >>> ask(Q.extended_negative(-1)) True >>> ask(Q.extended_negative(-oo)) True >>> ask(Q.extended_negative(-I)) False extended_negativeExtendedNegativeHandlerNr rrrr/r/r-rr/c$eZdZdZdZedZy)ExtendedNonZeroPredicatea Nonzero extended real number predicate. Explanation =========== ``ask(Q.extended_nonzero(x))`` is true iff ``x`` is extended real and ``x`` is not zero. Examples ======== >>> from sympy import ask, I, oo, Q >>> ask(Q.extended_nonzero(-1)) True >>> ask(Q.extended_nonzero(oo)) True >>> ask(Q.extended_nonzero(I)) False extended_nonzeroExtendedNonZeroHandlerNr rrrr3r37s* D12Grr3c$eZdZdZdZedZy)ExtendedNonPositivePredicatea Nonpositive extended real number predicate. Explanation =========== ``ask(Q.extended_nonpositive(x))`` is true iff ``x`` is extended real and ``x`` is not positive. Examples ======== >>> from sympy import ask, I, oo, Q >>> ask(Q.extended_nonpositive(-1)) True >>> ask(Q.extended_nonpositive(oo)) False >>> ask(Q.extended_nonpositive(0)) True >>> ask(Q.extended_nonpositive(I)) False extended_nonpositiveExtendedNonPositiveHandlerNr rrrr7r7Q. "D56Grr7c$eZdZdZdZedZy)ExtendedNonNegativePredicatea Nonnegative extended real number predicate. Explanation =========== ``ask(Q.extended_nonnegative(x))`` is true iff ``x`` is extended real and ``x`` is not negative. Examples ======== >>> from sympy import ask, I, oo, Q >>> ask(Q.extended_nonnegative(-1)) False >>> ask(Q.extended_nonnegative(oo)) True >>> ask(Q.extended_nonnegative(0)) True >>> ask(Q.extended_nonnegative(I)) False extended_nonnegativeExtendedNonNegativeHandlerNr rrrr<r<mr:rr<N)sympy.assumptionsrsympy.multipledispatchrrrrrr"r&r*r/r3r7r<rrrrAs'-+ +\%9%P-y-`IB&9&R+ +\4 444 443y347978797r