Fixes

Author: blegat

src/monomial_vector.jl

@@ -148,62 +148,6 @@ function _error_for_negative_degree(deg)
     end
 end
 
-const _Lex = Union{MP.LexOrder,MP.InverseLexOrder}
-
-_last_lex_index(n, ::Type{MP.LexOrder}) = n
-_prev_lex_index(i, ::Type{MP.LexOrder}) = i - 1
-_not_first_indices(n, ::Type{MP.LexOrder}) = n:-1:2
-_last_lex_index(_, ::Type{MP.InverseLexOrder}) = 1
-_prev_lex_index(i, ::Type{MP.InverseLexOrder}) = i + 1
-_not_first_indices(n, ::Type{MP.InverseLexOrder}) = 1:(n-1)
-
-function _fill_exponents!(Z, n, degs, ::Type{Commutative}, M::Type{<:_Lex}, filter::Function)
-    _error_for_negative_degree.(degs)
-    maxdeg = maximum(degs, init = 0)
-    I = _not_first_indices(n, M)
-    z = zeros(Int, n)
-    while true
-        deg = sum(z)
-        if deg in degs && filter(z)
-            push!(Z, z)
-            z = copy(z)
-        end
-        if deg == maxdeg
-            i = findfirst(i -> !iszero(z[i]), I)
-            if isnothing(i)
-                break
-            end
-            j = I[i]
-            z[j] = 0
-            z[_prev_lex_index(j, M)] += 1
-        else
-            z[_last_lex_index(n, M)] += 1
-        end
-    end
-end
-
-function _fill_exponents!(Z, n, deg, ::Type{Commutative}, M::Type{<:_Lex}, filter::Function, ::Int)
-    _error_for_negative_degree(deg)
-    I = _not_first_indices(n, M)
-    z = zeros(Int, n)
-    z[_last_lex_index(n, M)] = deg
-    while true
-        if filter(z)
-            push!(Z, z)
-            z = copy(z)
-        end
-        i = findfirst(i -> !iszero(z[i]), I)
-        if isnothing(i)
-            break
-        end
-        j = I[i]
-        p = z[j]
-        z[j] = 0
-        z[_last_lex_index(n, M)] = p - 1
-        z[_prev_lex_index(j, M)] += 1
-    end
-end
-
 function _fill_noncomm_exponents_rec!(Z, z, i, n, deg, ::Type{MP.LexOrder}, filter::Function)
     if deg == 0
         if filter(z)
@@ -235,68 +179,12 @@ function _fill_exponents!(
     return reverse!(view(Z, start:length(Z)))
 end
 
-function _fill_exponents!(Z, n, deg, ::Type{V}, ::Type{MP.Reverse{M}}, args...) where {V,M}
-    prev = lastindex(Z)
-    _fill_exponents!(Z, n, deg, V, M, args...)
-    reverse!(view(Z, (prev + 1):lastindex(Z)))
-    return
-end
-
-function _fill_exponents!(
-    Z::Vector{Vector{Int}},
-    n,
-    degs::AbstractVector{Int},
-    ::Type{V},
-    ::Type{MP.Graded{M}},
-    filter::Function,
-) where {V,M}
-    # For non-commutative, lower degree need to create a vector of exponent as large as for the highest degree
-    maxdeg = maximum(degs, init = 0)
-    for deg in sort(degs)
-        _fill_exponents!(Z, n, deg, V, M, filter, maxdeg)
-    end
-    return
-end
-
 # List exponents in decreasing Graded Lexicographic Order
-function _all_exponents(
-    n,
-    degs::AbstractVector{Int},
-    ::Type{V},
-    ::Type{M},
-    filter::Function,
-) where {V,M}
-    Z = Vector{Int}[]
-    _fill_exponents!(Z, n, degs, V, M, filter)
-    _isless = let M = M
-        (a, b) -> MP.compare(a, b, M) < 0
-    end
-    @assert issorted(Z, lt = _isless)
-    return Z
-end
-
-function MonomialVector(
-    vars::Vector{<:Variable{<:Commutative,M}},
-    degs::AbstractVector{Int},
-    filter::Function = x -> true,
-) where {M}
-    vars = unique!(sort(vars, rev = true))
-    return MonomialVector(
-        vars,
-        _all_exponents(
-            length(vars),
-            degs,
-            Commutative,
-            M,
-            z -> filter(Monomial(vars, z)),
-        ),
-    )
-end
-
 function getvarsforlength(vars::Vector{<:Variable{<:NonCommutative}}, len::Int)
     n = length(vars)
     return map(i -> vars[((i-1)%n)+1], 1:len)
 end
+
 function MonomialVector(
     vars::Vector{<:Variable{<:NonCommutative,M}},
     degs::AbstractVector{Int},
@@ -313,6 +201,23 @@ function MonomialVector(
     v = isempty(Z) ? vars : getvarsforlength(vars, length(first(Z)))
     return MonomialVector(v, Z)
 end
+
+function MonomialVector(
+    vars::Vector{<:Variable{<:Commutative,M}},
+    degs::AbstractVector{Int},
+    filter::Function = x -> true,
+) where {M}
+    vars = unique!(sort(vars, rev = true))
+    Z = Iterators.Filter(MP.ExponentsIterator{M}(
+        zeros(Int, length(vars));
+        mindegree = minimum(degs),
+        maxdegree = maximum(degs),
+    )) do z
+        filter(Monomial(vars, z))
+    end
+    return MonomialVector(v, Z)
+end
+
 function MonomialVector(
     vars::Vector{<:Variable},
     degs::Int,
@@ -324,6 +229,7 @@ end
 function MP.monomials(vars::AbstractVector{<:Variable}, args...)
     return MonomialVector(vars, args...)
 end
+
 function MP.monomials(vars::Tuple{Vararg{Variable}}, args...)
     return monomials([vars...], args...)
 end

src/promote.jl

@@ -1,3 +1,15 @@
+function MP.promote_variables(m1::Monomial, m2::Monomial)
+    if MP.variables(m1) == MP.variables(m2)
+        return m1, m2
+    end
+    allvars, maps = mergevars([MP.variables(m1), MP.variables(m2)])
+    z1 = zeros(Int, length(allvars))
+    z1[maps[1]] = m1.z
+    z2 = zeros(Int, length(allvars))
+    z2[maps[2]] = m2.z
+    return Monomial(allvars, z1), Monomial(allvars, z2)
+end
+
 function MP.promote_rule_constant(
     ::Type{T},
     ::Type{<:DMonomialLike{V,M}},

src/var.jl

@@ -291,15 +291,3 @@ function mergevars_of(::Type{Variable{V,M}}, polys::AbstractVector) where {V,M}
     # TODO avoid computing `maps`
     return mergevars(varsvec)
 end
-
-function MP.promote_variables(m1::Monomial, m2::Monomial)
-    if MP.variables(m1) == MP.variables(m2)
-        return m1, m2
-    end
-    allvars, maps = mergevars([MP.variables(m1), MP.variables(m2)])
-    z1 = zeros(Int, length(allvars))
-    z1[maps[1]] = m1.z
-    z2 = zeros(Int, length(allvars))
-    z2[maps[2]] = m2.z
-    return Monomial(allvars, z1), Monomial(allvars, z2)
-end