Add tests for ordering (#146)

* Add tests for ordering

* Update url

README.md

@@ -16,7 +16,7 @@ The following types are defined:
 
 All common algebraic operations between those types are designed to be as efficient as possible without doing any assumption on `T`.
 Typically, one imagine `T` to be a subtype of `Number` but it can be anything.
-This is useful for example in the package [PolyJuMP](https://github.com/JuliaOpt/PolyJuMP.jl) where `T` is often an affine expression of [JuMP](https://github.com/JuliaOpt/JuMP.jl) decision variables.
+This is useful for example in the package [PolyJuMP](https://github.com/jump-dev/PolyJuMP.jl) where `T` is often an affine expression of [JuMP](https://github.com/jump-dev/JuMP.jl) decision variables.
 The commutativity of `T` with `*` is not assumed, even if it is the coefficient of a monomial of commutative variables.
 However, commutativity of `T` and of the variables `+` is always assumed.
 This allows to keep the terms sorted (Graded Lexicographic order is used) in polynomial and measure which enables more efficient operations.

src/DynamicPolynomials.jl

@@ -36,6 +36,7 @@ function MP.constant_monomial(p::PolyType)
 end
 MP.monomial_type(::Type{<:PolyType{V,M}}) where {V,M} = Monomial{V,M}
 MP.monomial_type(::PolyType{V,M}) where {V,M} = Monomial{V,M}
+MP.ordering(p::PolyType) = MP.ordering(MP.variable_union_type(p))
 #function MP.constant_monomial(::Type{Monomial{V,M}}, vars=Variable{V,M}[]) where {V,M}
 #    return Monomial{V,M}(vars, zeros(Int, length(vars)))
 #end

src/monomial_vector.jl

@@ -15,7 +15,6 @@ struct MonomialVector{V,M} <: AbstractVector{Monomial{V,M}}
         _isless = let M = M
             (a, b) -> MP.compare(a, b, M) < 0
         end
-        @assert issorted(Z, lt = _isless)
         return new{V,M}(vars, Z)
     end
 end

src/var.jl

@@ -26,8 +26,8 @@ function buildpolyvar(var, variable_order, monomial_order)
         varname,
         :(
             $(esc(varname)) = polyarrayvar(
-                $variable_order,
-                $monomial_order,
+                $(variable_order),
+                $(monomial_order),
                 $prefix,
                 $(esc.(var.args[2:end])...),
             )
@@ -53,9 +53,9 @@ function _extract_kw_args(args, variable_order)
     for arg in args
         if Base.Meta.isexpr(arg, :(=))
             if arg.args[1] == :variable_order
-                variable_order = arg.args[2]
+                variable_order = esc(arg.args[2])
             elseif arg.args[1] == :monomial_order
-                monomial_order = arg.args[2]
+                monomial_order = esc(arg.args[2])
             else
                 error("Unrecognized keyword argument `$(arg.args[1])`")
             end
@@ -145,6 +145,7 @@ end
 
 MP.monomial(v::Variable) = Monomial(v)
 MP.variables(v::Variable) = [v]
+MP.ordering(::Variable{V,M}) where {V,M} = M
 
 iscomm(::Type{Variable{C}}) where {C} = C
 

test/comp.jl

@@ -1,8 +1,14 @@
+using Test
+using DynamicPolynomials
+import DynamicPolynomials: Commutative, CreationOrder # to test hygiene
 @testset "Variable order" begin
     @polyvar x
     z = x
     @polyvar x
     @test z != x
+    order = Commutative{CreationOrder}
+    @polyvar x variable_order = order
+    @test z != x
 end
 @testset "README example" begin
     function p(x, y, z)
@@ -19,3 +25,11 @@ end
     @polyvar x y z monomial_order = Graded{Reverse{InverseLexOrder}}
     @test p(x, y, z) == "4z² - 5x³ + 7x²z² + 4xy²z"
 end
+# See https://github.com/JuliaAlgebra/DynamicPolynomials.jl/issues/138
+# Also tests `ordering`
+@testset "InverseLexOrder" begin
+    order = Graded{InverseLexOrder}
+    @polyvar x[1:2] monomial_order = order
+    @test ordering(x[1]) == order
+    @test issorted(monomials(x[1], 0:2))
+end