Simplify comparison

Author: blegat

src/comparison.jl

@@ -249,12 +249,19 @@ struct Graded{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
     same_degree_ordering::O
 end
 
-_deg(exponents) = sum(exponents)
-_deg(mono::AbstractMonomial) = degree(mono)
+function compare(a::_TupleOrVector, b::_TupleOrVector, ::Type{Graded{O}}) where {O}
+    deg_a = sum(a)
+    deg_b = sum(b)
+    if deg_a == deg_b
+        return compare(a, b, O)
+    else
+        return deg_a - deg_b
+    end
+end
 
-function compare(a, b, ::Type{Graded{O}}) where {O}
-    deg_a = _deg(a)
-    deg_b = _deg(b)
+function compare(a::AbstractMonomial, b::AbstractMonomial, ::Type{Graded{O}}) where {O}
+    deg_a = degree(a)
+    deg_b = degree(b)
     if deg_a == deg_b
         return compare(a, b, O)
     else
@@ -293,6 +300,43 @@ Returns the [`AbstractMonomialOrdering`](@ref) used for the monomials of `p`.
 """
 function ordering end
 
+ordering(::Type{P}) where {P} = ordering(monomial_type(P))
+ordering(p::AbstractPolynomialLike) = ordering(typeof(p))
+
+# We reverse the order of comparisons here so that the result
+# of x < y is equal to the result of Monomial(x) < Monomial(y)
+function compare(v1::AbstractVariable, v2::AbstractVariable, ::Type{<:AbstractMonomialOrdering})
+    return -cmp(name(v1), name(v2))
+end
+
+function compare(m1::AbstractMonomial, m2::AbstractMonomial, ::Type{O}) where {O<:AbstractMonomialOrdering}
+    s1, s2 = promote_variables(m1, m2)
+    return compare(exponents(s1), exponents(s2), O)
+end
+
+# Implement this to make coefficients be compared with terms.
+function _cmp_coefficient(a::Real, b::Real)
+    return cmp(a, b)
+end
+function _cmp_coefficient(a::Number, b::Number)
+    return cmp(abs(a), abs(b))
+end
+# By default, coefficients are not comparable so `a` is not strictly
+# less than `b`, they are considered sort of equal.
+_cmp_coefficient(a, b) = 0
+
+function compare(t1::AbstractTerm, t2::AbstractTerm, ::Type{O}) where {O<:AbstractMonomialOrdering}
+    Δ = compare(monomial(t1), monomial(t2), O)
+    if iszero(Δ)
+        return _cmp_coefficient(coefficient(t1), coefficient(t2))
+    end
+    return Δ
+end
+
+Base.cmp(t1::AbstractTermLike, t2::AbstractTermLike) = compare(t1, t2, ordering(t1))
+
+Base.isless(t1::AbstractTermLike, t2::AbstractTermLike) = cmp(t1, t2) < 0
+
 _last_lex_index(n, ::Type{LexOrder}) = n
 _prev_lex_index(i, ::Type{LexOrder}) = i - 1
 _not_first_indices(n, ::Type{LexOrder}) = n:-1:2

src/default_polynomial.jl

@@ -93,7 +93,7 @@ Base.one(p::Polynomial) = one(typeof(p))
 Base.zero(::Type{Polynomial{C,T,A}}) where {C,T,A} = Polynomial{C,T,A}(A())
 Base.zero(t::Polynomial) = zero(typeof(t))
 
-compare_monomials(a, b) = compare(monomial(a), monomial(b))
+compare_monomials(a, b) = cmp(monomial(a), monomial(b))
 
 function join_terms(
     terms1::AbstractArray{<:Term},

src/operators.jl

@@ -1,33 +1,3 @@
-# We reverse the order of comparisons here so that the result
-# of x < y is equal to the result of Monomial(x) < Monomial(y)
-Base.@pure function Base.isless(v1::AbstractVariable, v2::AbstractVariable)
-    return name(v1) > name(v2)
-end
-function Base.isless(m1::AbstractTermLike, m2::AbstractTermLike)
-    return isless(promote(m1, m2)...)
-end
-
-# Implement this to make coefficients be compared with terms.
-function isless_coefficient(a::Real, b::Real)
-    return a < b
-end
-function isless_coefficient(a::Number, b::Number)
-    return abs(a) < abs(b)
-end
-# By default, coefficients are not comparable so `a` is not strictly
-# less than `b`, they are considered sort of equal.
-isless_coefficient(a, b) = false
-
-function Base.isless(t1::AbstractTerm, t2::AbstractTerm)
-    if monomial(t1) < monomial(t2)
-        return true
-    elseif monomial(t1) == monomial(t2)
-        return isless_coefficient(coefficient(t1), coefficient(t2))
-    else
-        return false
-    end
-end
-
 # promoting multiplication is not a good idea
 # For example a polynomial of Float64 * a polynomial of JuMP affine expression
 # is a polynomial of JuMP affine expression but if we promote it would be a

src/promote.jl

@@ -1,3 +1,10 @@
+"""
+    promote_variables(p::AbstractPolynomialLike, q::AbstractPolynomialLike)
+
+Return two polynomials over the same variables.
+"""
+function promote_variables end
+
 # MonomialLike
 Base.promote_rule(::Type{M}, ::Type{M}) where {M<:AbstractMonomialLike} = M
 function Base.promote_rule(