Simplify comparison (#89)

* Simplify comparison

* Update ci

* Remove ordering

Author: blegat

.github/workflows/ci.yml

@@ -27,26 +27,25 @@ jobs:
             os: ubuntu-latest
             arch: x64
     steps:
-      - uses: actions/checkout@v3
-      - uses: julia-actions/setup-julia@v1
+      - uses: actions/checkout@v4
+      - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
-      - uses: actions/cache@v1
-        env:
-          cache-name: cache-artifacts
-        with:
-          path: ~/.julia/artifacts
-          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
-          restore-keys: |
-            ${{ runner.os }}-test-${{ env.cache-name }}-
-            ${{ runner.os }}-test-
-            ${{ runner.os }}-
+      - uses: julia-actions/cache@v2
+      - name: MP
+        shell: julia --project=@. {0}
+        run: |
+          using Pkg
+          Pkg.add([
+              PackageSpec(name="MultivariatePolynomials", rev="master"),
+          ])
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
         with:
           depwarn: error
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v3
+      - uses: codecov/codecov-action@v4
         with:
           file: lcov.info
+          token: ${{ secrets.CODECOV_TOKEN }}

src/operators.jl

@@ -1,51 +1,12 @@
 # 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
-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}}
-    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 +29,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

@@ -113,3 +113,5 @@ function MP.monomials(vars::Tuple{Vararg{Variable}}, degrees::AbstractArray, fil
             for p in monomial_powers(Val{length(vars)}(), d) if filter(Monomial{vars}(p))]
     end
 end
+
+MP.promote_variables(a::MonomialLike, b::MonomialLike) = promote(a, b)