Add support for monomial ordering

Author: blegat

src/operators.jl

@@ -1,51 +1,20 @@
 # Graded Lexicographic order
-# First compare total degree, then lexicographic order
-function Base.isless(m1::Monomial{V}, m2::Monomial{V}) where {V}
-    d1 = degree(m1)
-    d2 = degree(m2)
-    if d1 < d2
-        return true
-    elseif d1 > d2
-        return false
-    else
-        return exponents(m1) < exponents(m2)
-    end
+function MP.compare(m1::Monomial{V}, m2::Monomial{V}, ::Type{O}) where {V,O<:MP.AbstractMonomialOrder}
+    return MP.compare(MP.exponents(m1), MP.exponents(m2), O)
 end
 
-function _compare(a::Tuple, b::Tuple, ::Type{MP.LexOrder})
-    if a == b
-        return 0
-    elseif a < b
-        return -1
-    else
-        return 1
-    end
-end
-function _compare(a::Tuple, b::Tuple, ::Type{MP.InverseLexOrder})
-    return _compare(reverse(a), reverse(b), MP.LexOrder)
-end
-
-function MP.compare(m1::Monomial{V}, m2::Monomial{V}, ::Type{O}) where {V,O<:Union{MP.LexOrder,MP.InverseLexOrder}}
-    return _compare(MP.exponents(m1), MP.exponents(m2), O)
-end
-
-function MP.compare(m1::Monomial, m2::Monomial, ::Type{O}) where {O<:Union{MP.LexOrder,MP.InverseLexOrder}}
+function MP.compare(m1::Monomial, m2::Monomial, ::Type{O}) where {O<:MP.AbstractMonomialOrder}
     return MP.compare(promote(m1, m2)..., O)
 end
 
-function MP.compare(m1::Monomial, m2::Monomial)
-    return MP.compare(m1, m2, MP.Graded{MP.LexOrder})
-end
-
-
 (==)(::Variable{N}, ::Variable{N}) where {N} = true
 (==)(::Variable, ::Variable) = false
 (==)(m1::Monomial{V}, m2::Monomial{V}) where {V} = exponents(m1) == exponents(m2)
 
 # Multiplication is handled as a special case so that we can write these
 # definitions without resorting to promotion:
 
-(*)(v1::V, v2::V) where {V <: Variable} = Monomial{(V(),), 1}((2,))
+(*)(::V, ::V) where {V <: Variable} = Monomial{(V(),), 1}((2,))
 (*)(v1::Variable, v2::Variable) = (*)(promote(v1, v2)...)
 
 function MP.divides(m1::Monomial{V, N}, m2::Monomial{V, N}) where {V, N}
@@ -68,7 +37,7 @@ end
 # We could remove these methods since it is the default.
 MA.mutability(::Type{<:Monomial}) = MA.IsNotMutable()
 
-^(v::V, x::Integer) where {V <: Variable} = Monomial{(V(),), 1}((x,))
+^(::V, x::Integer) where {V <: Variable} = Monomial{(V(),), 1}((x,))
 
 # dot(v1::AbstractVector{<:TermLike}, v2::AbstractVector) = dot(v1, v2)
 # dot(v1::AbstractVector, v2::AbstractVector{<:TermLike}) = dot(v1, v2)

src/types.jl

@@ -1,10 +1,15 @@
-struct Variable{Name} <: AbstractVariable
+"""
+    Variable{Name,M} <: AbstractVariable
+
+Variable of name `Name` and monomial order `M`.
+"""
+struct Variable{Name,M} <: AbstractVariable
 end
 
-MP.name(::Type{Variable{N}}) where {N} = N
+MP.name(::Type{<:Variable{N}}) where {N} = N
 MP.name(v::Variable) = name(typeof(v))
 MP.name_base_indices(v::Variable) = name_base_indices(typeof(v))
-function MP.name_base_indices(v::Type{Variable{N}}) where N
+function MP.name_base_indices(::Type{<:Variable{N}}) where N
     name = string(N)
     splits = split(string(N), r"[\[,\]]\s*", keepempty=false)
     if length(splits) == 1
@@ -23,15 +28,15 @@ checksorted(x::Tuple{Any}, cmp) = true
 checksorted(x::Tuple{}, cmp) = true
 checksorted(x::Tuple, cmp) = cmp(x[1], x[2]) && checksorted(Base.tail(x), cmp)
 
-struct Monomial{V, N} <: AbstractMonomial
+struct Monomial{V, M, N} <: AbstractMonomial
     exponents::NTuple{N, Int}
 
-    function Monomial{V, N}(exponents::NTuple{N, Int}=ntuple(_ -> 0, Val{N}())) where {V, N}
+    function Monomial{V, M, N}(exponents::NTuple{N, Int}=ntuple(_ -> 0, Val{N}())) where {V, M, N}
         @assert checksorted(V, >)
-        new{V, N}(exponents)
+        new{V, M, N}(exponents)
     end
-    Monomial{V}(exponents::NTuple{N, Integer}=()) where {V, N} = Monomial{V, N}(exponents)
-    Monomial{V}(exponents::AbstractVector{<:Integer}) where {V} = Monomial{V}(NTuple{length(V), Int}(exponents))
+    Monomial{V, M}(exponents::NTuple{N, Integer}=()) where {V, N} = Monomial{V, M, N}(exponents)
+    Monomial{V, M}(exponents::AbstractVector{<:Integer}) where {V} = Monomial{V, M}(NTuple{length(V), Int}(exponents))
 end
 
 Monomial(v::Variable) = monomial_type(v)((1,))
@@ -46,8 +51,8 @@ MP.monomial_type(v::Variable) = Monomial{(v,), 1}
 
 MP.exponents(m::Monomial) = m.exponents
 MP.exponent(m::Monomial, i::Integer) = m.exponents[i]
-_exponent(v::V, p1::Tuple{V, Integer}, p2...) where {V <: Variable} = p1[2]
-_exponent(v::Variable, p1::Tuple{Variable, Integer}, p2...) = _exponent(v, p2...)
+_exponent(::V, p1::Tuple{V, Integer}, p2...) where {V <: Variable} = p1[2]
+_exponent(v::Variable, ::Tuple{Variable, Integer}, p2...) = _exponent(v, p2...)
 _exponent(v::Variable) = 0
 MP.degree(m::Monomial, v::Variable) = _exponent(v, powers(m)...)