Updates

Author: blegat

.github/workflows/ci.yml

@@ -28,7 +28,7 @@ jobs:
             arch: x64
     steps:
       - uses: actions/checkout@v4
-      - uses: julia-actions/setup-julia@v1
+      - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}

src/comparison.jl

@@ -258,7 +258,7 @@ function compare(a::_TupleOrVector, b::_TupleOrVector, ::Type{Graded{O}}) where
         return deg_a - deg_b
     end
 end
-
+# TODO Backward compat, remove
 function compare(a::AbstractMonomial, b::AbstractMonomial, ::Type{Graded{O}}) where {O}
     deg_a = degree(a)
     deg_b = degree(b)
@@ -291,7 +291,9 @@ struct Reverse{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
     reverse_ordering::O
 end
 
-compare(a, b, ::Type{Reverse{O}}) where {O} = compare(b, a, O)
+compare(a::_TupleOrVector, b::_TupleOrVector, ::Type{Reverse{O}}) where {O} = compare(b, a, O)
+# TODO Backward compat, remove
+compare(a::AbstractMonomial, b::AbstractMonomial, ::Type{Reverse{O}}) where {O} = compare(b, a, O)
 
 """
     ordering(p::AbstractPolynomialLike)
@@ -325,7 +327,7 @@ end
 # 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}
+function compare(t1::AbstractTermLike, t2::AbstractTermLike, ::Type{O}) where {O<:AbstractMonomialOrdering}
     Δ = compare(monomial(t1), monomial(t2), O)
     if iszero(Δ)
         return _cmp_coefficient(coefficient(t1), coefficient(t2))
@@ -334,6 +336,8 @@ function compare(t1::AbstractTerm, t2::AbstractTerm, ::Type{O}) where {O<:Abstra
 end
 
 Base.cmp(t1::AbstractTermLike, t2::AbstractTermLike) = compare(t1, t2, ordering(t1))
+# TODO for backward compat, remove in next breaking release
+compare(t1::AbstractTermLike, t2::AbstractTermLike) = cmp(t1, t2)
 
 Base.isless(t1::AbstractTermLike, t2::AbstractTermLike) = cmp(t1, t2) < 0
 

test/commutative/comparison.jl

@@ -146,31 +146,21 @@
         grlex = Graded{lex}
         rinvlex = Reverse{InverseLexOrder}
         grevlex = Graded{rinvlex}
-        @test MP.compare([1, 0, 1], [1, 1, 0], grlex) == -1
-        @test MP.compare([1, 1, 0], [1, 0, 1], grlex) == 1
         Mod.@polyvar x y z
         # [CLO13, p. 58]
-        @test MP.compare(1:3, [3, 2, 0], lex) < 0
-        @test MP.compare(1:3, [3, 2, 0], grlex) > 0
-        @test MP.compare(1:3, [3, 2, 0], rinvlex) < 0
-        @test MP.compare(1:3, [3, 2, 0], grevlex) > 0
-        @test MP.compare([1, 2, 4], [1, 1, 5], lex) > 0
-        @test MP.compare([1, 2, 4], [1, 1, 5], grlex) > 0
-        @test MP.compare([1, 2, 4], [1, 1, 5], rinvlex) > 0
-        @test MP.compare([1, 2, 4], [1, 1, 5], grevlex) > 0
-        @test MP.compare(x * y^2 * z^3, x^3 * y^2, lex) < 0
-        @test MP.compare(x * y^2 * z^3, x^3 * y^2, grlex) > 0
-        @test MP.compare(x * y^2 * z^3, x^3 * y^2, rinvlex) < 0
-        @test MP.compare(x * y^2 * z^3, x^3 * y^2, grevlex) > 0
-        @test MP.compare(x * y^2 * z^4, x * y * z^5, lex) > 0
-        @test MP.compare(x * y^2 * z^4, x * y * z^5, grlex) > 0
-        @test MP.compare(x * y^2 * z^4, x * y * z^5, rinvlex) > 0
-        @test MP.compare(x * y^2 * z^4, x * y * z^5, grevlex) > 0
+        @test compare(x * y^2 * z^3, x^3 * y^2, lex) < 0
+        @test compare(x * y^2 * z^3, x^3 * y^2, grlex) > 0
+        @test compare(x * y^2 * z^3, x^3 * y^2, rinvlex) < 0
+        @test compare(x * y^2 * z^3, x^3 * y^2, grevlex) > 0
+        @test compare(x * y^2 * z^4, x * y * z^5, lex) > 0
+        @test compare(x * y^2 * z^4, x * y * z^5, grlex) > 0
+        @test compare(x * y^2 * z^4, x * y * z^5, rinvlex) > 0
+        @test compare(x * y^2 * z^4, x * y * z^5, grevlex) > 0
         # [CLO13, p. 59]
-        @test MP.compare(x^5 * y * z, x^4 * y * z^2, lex) > 0
-        @test MP.compare(x^5 * y * z, x^4 * y * z^2, grlex) > 0
-        @test MP.compare(x^5 * y * z, x^4 * y * z^2, rinvlex) > 0
-        @test MP.compare(x^5 * y * z, x^4 * y * z^2, grevlex) > 0
+        @test compare(x^5 * y * z, x^4 * y * z^2, lex) > 0
+        @test compare(x^5 * y * z, x^4 * y * z^2, grlex) > 0
+        @test compare(x^5 * y * z, x^4 * y * z^2, rinvlex) > 0
+        @test compare(x^5 * y * z, x^4 * y * z^2, grevlex) > 0
         # [CLO13] Cox, D., Little, J., & OShea, D.
         # *Ideals, varieties, and algorithms: an introduction to computational algebraic geometry and commutative algebra*.
         # Springer Science & Business Media, **2013**.