Upload 19 files

License

This dataset is licensed under a Creative Commons Attribution 4.0 International (CC BY 4.0) license.

This allows for the sharing and adaptation of the datasets for any purpose, provided that the appropriate credit is given.
Pawel Bielski

[email protected]

Karlsruhe Institute of Technology

Dustin Kottonau

Karlsruhe Institute of Technology
Additional Information

- staDynBenignLab.csv: 1086 features extracted from 595 files on MS Windows 7 and 8, obtained Program Files directory.

- staDynVxHeaven2698Lab.csv: 1087 features extracted from 2698 files of VxHeaven dataset.

- staDynVt2955Lab.csv: 1087 features extracted from 2955 provided by Virus Total in 2018.

Has Missing Values?

No
Variable Information

Static features: ASM, Hex dump and PE Header (discreate, continuous)

Dynamic features: extracted from a Cuckoo sandbox



Dataset Files
Reviews

There are no reviews for this dataset yet.
Write a Review
Comments


Install the ucimlrepo package

pip install ucimlrepo

Import the dataset into your code

from ucimlrepo import fetch_ucirepo

# fetch dataset
malware_static_and_dynamic_features_vxheaven_and_virus_total = fetch_ucirepo(id=541)

# data (as pandas dataframes)
X = malware_static_and_dynamic_features_vxheaven_and_virus_total.data.features
y = malware_static_and_dynamic_features_vxheaven_and_virus_total.data.targets

# metadata
print(malware_static_and_dynamic_features_vxheaven_and_virus_total.metadata)

# variable information
print(malware_static_and_dynamic_features_vxheaven_and_virus_total.variables)

View the full documentation
0 citations
4165 views
Citation

Malware static and dynamic features VxHeaven and Virus Total [Dataset]. (2019). UCI Machine Learning Repository. https://doi.org/10.24432/C58K6H.

Style:
DOI
10.24432/C58K6H
License

This dataset is licensed under a Creative Commons Attribution 4.0 International (CC BY 4.0) license.

This allows for the sharing and adaptation of the datasets for any purpose, provided that the appropriate credit is given.

DynamicPolynomials.jl

@@ -0,0 +1,47 @@
+module DynamicPolynomials
+
+using Reexport
+@reexport using MultivariatePolynomials
+const MP = MultivariatePolynomials
+
+
+include("var.jl")
+include("mono.jl")
+const DMonomialLike{C} = Union{Monomial{C}, PolyVar{C}}
+include("term.jl")
+include("monovec.jl")
+include("poly.jl")
+const TermPoly{C, T} = Union{Term{C, T}, Polynomial{C, T}}
+const PolyType{C} = Union{Polynomial{C}, Term{C}, Monomial{C}, PolyVar{C}}
+MP.constantmonomial(::Type{<:PolyType{C}}) where {C} = Monomial{C}()
+MP.constantmonomial(p::PolyType) = Monomial(_vars(p), zeros(Int, nvariables(p)))
+MP.monomialtype(::Type{<:PolyType{C}}) where C = Monomial{C}
+MP.monomialtype(::PolyType{C}) where C = Monomial{C}
+#function MP.constantmonomial(::Type{Monomial{C}}, vars=PolyVar{C}[]) where {C}
+#    return Monomial{C}(vars, zeros(Int, length(vars)))
+#end
+MP.termtype(::Union{TermPoly{C, T}, Type{<:TermPoly{C, T}}}) where {C, T} = Term{C, T}
+MP.termtype(::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{T}) where {C, T} = Term{C, T}
+MP.polynomial(p::PolyType) = Polynomial(p)
+function MP.polynomial(p::PolyType{C}, ::Type{T}) where {C, T}
+    return convert(Polynomial{C, T}, p)
+end
+MP.polynomialtype(::Type{Term{C, T}}) where {T, C} = Polynomial{C, T}
+MP.polynomialtype(::Type{T}, ::Type{<:DMonomialLike{C}}) where {T, C} = Polynomial{C, T}
+MP.polynomialtype(::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{T}) where {C, T} = Polynomial{C, T}
+_vars(p::AbstractArray{<:PolyType}) = mergevars(_vars.(p))[1]
+MP.variables(p::Union{PolyType, MonomialVector, AbstractArray{<:PolyType}}) = _vars(p) # tuple(_vars(p))
+MP.nvariables(p::Union{PolyType, MonomialVector, AbstractArray{<:PolyType}}) = length(_vars(p))
+MP.similarvariable(p::Union{PolyType{C}, Type{<:PolyType{C}}}, ::Type{Val{V}}) where {C, V} = PolyVar{C}(string(V))
+MP.similarvariable(p::Union{PolyType{C}, Type{<:PolyType{C}}}, V::Symbol) where {C} = PolyVar{C}(string(V))
+include("promote.jl")
+
+include("operators.jl")
+include("comp.jl")
+
+include("diff.jl")
+include("subs.jl")
+
+include("div.jl")
+
+end # module

appveyor.yml

@@ -0,0 +1,36 @@
+environment:
+  matrix:
+  - julia_version: 1.0
+  - julia_version: latest
+
+platform:
+  - x86 # 32-bit
+  - x64 # 64-bit
+
+## uncomment the following lines to allow failures on nightly julia
+## (tests will run but not make your overall status red)
+matrix:
+ allow_failures:
+ - julia_version: latest
+
+branches:
+  only:
+    - master
+    - /release-.*/
+
+notifications:
+  - provider: Email
+    on_build_success: false
+    on_build_failure: false
+    on_build_status_changed: false
+
+install:
+  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
+
+build_script:
+  - echo "%JL_BUILD_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
+
+test_script:
+  - echo "%JL_TEST_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"

cmult.jl

@@ -0,0 +1,65 @@
+# Product between PolyVar and Monomial -> Monomial
+function Base.:(*)(x::PolyVar{true}, y::PolyVar{true})
+    if x === y
+        Monomial{true}([x], [2])
+    else
+        Monomial{true}(x > y ? [x,y] : [y,x], [1,1])
+    end
+end
+function multiplyvar(v::Vector{PolyVar{true}}, x::PolyVar{true})
+    i = findfirst(w->w <= x, v)
+    if (i != nothing && i > 0) && v[i] == x
+        multiplyexistingvar(v, x, i)
+    else
+        insertvar(v, x, (i == nothing || i == 0) ? length(v)+1 : i)
+    end
+end
+function Base.:(*)(x::PolyVar{true}, y::Monomial{true})
+    w, updatez = multiplyvar(y.vars, x)
+    Monomial{true}(w, updatez(y.z))
+end
+Base.:(*)(y::MonomialVector{true}, x::PolyVar{true}) = x * y
+function Base.:(*)(x::PolyVar{true}, y::MonomialVector{true})
+    w, updatez = multiplyvar(y.vars, x)
+    MonomialVector{true}(w, updatez.(y.Z))
+end
+function multdivmono(v::Vector{PolyVar{true}}, x::Monomial{true}, op)
+    if v == x.vars
+        # /!\ no copy done here for efficiency, do not mess up with vars
+        w = v
+        updatez = z -> op.(z, x.z)
+    else
+        w, maps = mergevars([v, x.vars])
+        updatez = z -> begin
+            newz = zeros(Int, length(w))
+            I = maps[1]; i = 1; lI = length(I)
+            J = maps[2]; j = 1; lJ = length(J)
+            while i <= lI || j <= lJ
+                if i > lI || (j <= lJ && J[j] < I[i])
+                    newz[J[j]] = op(0, x.z[j])
+                    j += 1
+                elseif j > lJ || (i <= lI && I[i] < J[j])
+                    newz[I[i]] = op(z[i], 0)
+                    i += 1
+                else
+                    @assert I[i] == J[j]
+                    newz[I[i]] = op(z[i], x.z[j])
+                    i += 1
+                    j += 1
+                end
+            end
+            newz
+        end
+    end
+    w, updatez
+end
+function MP.mapexponents(f, x::Monomial{true}, y::Monomial{true})
+    w, updatez = multdivmono(x.vars, y, f)
+    Monomial{true}(w, updatez(x.z))
+end
+function Base.:(*)(x::Monomial{true}, y::MonomialVector{true})
+    w, updatez = multdivmono(y.vars, x, +)
+    MonomialVector{true}(w, updatez.(y.Z))
+end
+Base.:(*)(y::MonomialVector{true}, x::Monomial{true}) = x * y
+Base.:(*)(x::Monomial{true}, y::PolyVar{true}) = y * x

comp.jl

@@ -0,0 +1,162 @@
+import Base.==
+
+#Base.iszero(t::Term) = iszero(t.α)
+Base.iszero(p::Polynomial) = isempty(p)
+
+# TODO This should be in Base with T instead of PolyVar{C}.
+# See https://github.com/blegat/MultivariatePolynomials.jl/issues/3
+function (==)(x::Vector{PolyVar{C}}, y::Vector{PolyVar{C}}) where C
+    if length(x) != length(y)
+        false
+    else
+        #for (xi, yi) in zip(x, y)
+        for i in 1:length(x)
+            if x[i] != y[i]
+                return false
+            end
+        end
+        true
+    end
+end
+
+# Comparison of PolyVar
+
+function (==)(x::PolyVar{C}, y::PolyVar{C}) where C
+    x.id == y.id
+end
+
+Base.isless(x::PolyVar{C}, y::PolyVar{C}) where C = isless(y.id, x.id)
+
+# Comparison of Monomial
+
+# graded lex ordering
+function mycomp(x::Monomial{C}, y::Monomial{C}) where C
+    degx = degree(x)
+    degy = degree(y)
+    if degx != degy
+        degx - degy
+    else
+        i = j = 1
+        # since they have the same degree,
+        # if we get j > nvariables(y), the rest in x.z should be zeros
+        while i <= nvariables(x) && j <= nvariables(y)
+            if x.vars[i] > y.vars[j]
+                if x.z[i] == 0
+                    i += 1
+                else
+                    return 1
+                end
+            elseif x.vars[i] < y.vars[j]
+                if y.z[j] == 0
+                    j += 1
+                else
+                    return -1
+                end
+            elseif x.z[i] != y.z[j]
+                return x.z[i] - y.z[j]
+            else
+                i += 1
+                j += 1
+            end
+        end
+        0
+    end
+end
+
+function (==)(x::Monomial{C}, y::Monomial{C}) where C
+    mycomp(x, y) == 0
+end
+(==)(x::PolyVar{C}, y::Monomial{C}) where C = convert(Monomial{C}, x) == y
+
+# graded lex ordering
+function Base.isless(x::Monomial{C}, y::Monomial{C}) where C
+    mycomp(x, y) < 0
+end
+Base.isless(x::Monomial{C}, y::PolyVar{C}) where C = isless(x, convert(Monomial{C}, y))
+Base.isless(x::PolyVar{C}, y::Monomial{C}) where C = isless(convert(Monomial{C}, x), y)
+
+# Comparison of MonomialVector
+function (==)(x::MonomialVector{C}, y::MonomialVector{C}) where C
+    if length(x.Z) != length(y.Z)
+        return false
+    end
+    allvars, maps = mergevars([_vars(x), _vars(y)])
+    # Should be sorted in the same order since the non-common
+    # polyvar should have exponent 0
+    for (a, b) in zip(x.Z, y.Z)
+        A = zeros(length(allvars))
+        B = zeros(length(allvars))
+        A[maps[1]] = a
+        B[maps[2]] = b
+        if A != B
+            return false
+        end
+    end
+    return true
+end
+(==)(mv::AbstractVector, x::MonomialVector) = monovec(mv) == x
+(==)(x::MonomialVector, mv::AbstractVector) = x == monovec(mv)
+
+# Comparison of Term
+function (==)(p::Polynomial{C}, q::Polynomial{C}) where {C}
+    # terms should be sorted and without zeros
+    if length(p) != length(q)
+        return false
+    end
+    for i in 1:length(p)
+        if p.x[i] != q.x[i]
+            # There should not be zero terms
+            @assert p.a[i] != 0
+            @assert q.a[i] != 0
+            return false
+        end
+        if p.a[i] != q.a[i]
+            return false
+        end
+    end
+    return true
+end
+
+function grlex(x::Vector{Int}, y::Vector{Int})
+    @assert length(x) == length(y)
+    degx = sum(x)
+    degy = sum(y)
+    if degx != degy
+        degx < degy
+    else
+        for (a, b) in zip(x, y)
+            if a < b
+                return true
+            elseif a > b
+                return false
+            end
+        end
+        false
+    end
+end
+
+function Base.isapprox(p::Polynomial{C, S}, q::Polynomial{C, T};
+                       rtol::Real=Base.rtoldefault(S, T, 0), atol::Real=0,
+                       ztol::Real=iszero(atol) ? Base.rtoldefault(S, T, 0) : atol) where {C, S, T}
+    i = j = 1
+    while i <= length(p.x) || j <= length(q.x)
+        if i > length(p.x) || (j <= length(q.x) && q.x[j] > p.x[i])
+            if !isapproxzero(q.a[j], ztol=ztol)
+                return false
+            end
+            j += 1
+        elseif j > length(q.x) || p.x[i] > q.x[j]
+            if !isapproxzero(p.a[i], ztol=ztol)
+                return false
+            end
+            i += 1
+        else
+            if !isapprox(p.a[i], q.a[j], rtol=rtol, atol=atol)
+                return false
+            end
+            i += 1
+            j += 1
+        end
+    end
+    true
+end

diff.jl

@@ -0,0 +1,28 @@
+function MP.differentiate(m::Monomial{C}, x::PolyVar{C}) where C
+    i = findfirst(isequal(x), _vars(m))
+    if (i == nothing || i == 0) || m.z[i] == 0
+        zeroterm(m)
+    else
+        z = copy(m.z)
+        z[i] -= 1
+        m.z[i] * Monomial(_vars(m), z)
+    end
+end
+
+function MP.differentiate(p::Polynomial{C, T}, x::PolyVar{C}) where {C, T}
+    # grlex order preserved
+    i = something(findfirst(isequal(x), _vars(p)), 0)
+    S = typeof(zero(T) * 0)
+    if iszero(i)
+        zero(Polynomial{C, S})
+    else
+        keep = findall(z -> z[i] > 0, p.x.Z)
+        Z = copy.(p.x.Z[keep])
+        a = Vector{S}(undef, length(keep))
+        for j in 1:length(Z)
+            a[j] = p.a[keep[j]] * Z[j][i]
+            Z[j][i] -= 1
+        end
+        Polynomial(a, MonomialVector(_vars(p), Z))
+    end
+end

div.jl

@@ -0,0 +1,22 @@
+function MP.divides(m1::Monomial, m2::Monomial)
+    e1 = exponents(m1)
+    v1 = variables(m1)
+    e2 = exponents(m2)
+    v2 = variables(m2)
+    i = 1; lI = length(e1)
+    j = 1; lJ = length(e2)
+    while i <= lI || j <= lJ
+        if i > lI || (j <= lJ && v2[j] > v1[i])
+            j += 1
+        elseif j > lJ || (i <= lI && v1[i] > v2[j])
+            iszero(e1[i]) || return false
+            i += 1
+        else
+            @assert v1[i] == v2[j]
+            e1[i] <= e2[j] || return false
+            i += 1
+            j += 1
+        end
+    end
+    return true
+end

mono.jl

@@ -0,0 +1,81 @@
+export Monomial
+
+const TupOrVec{T} = Union{AbstractVector{T}, Tuple{Vararg{T}}}
+
+# Invariant:
+# vars is increasing
+# z may contain 0's (otherwise, getindex of MonomialVector would be inefficient)
+struct Monomial{C} <: AbstractMonomial
+    vars::Vector{PolyVar{C}}
+    z::Vector{Int}
+
+    function Monomial{C}(vars::Vector{PolyVar{C}}, z::Vector{Int}) where {C}
+        if length(vars) != length(z)
+            throw(ArgumentError("There should be as many vars than exponents"))
+        end
+        new(vars, z)
+    end
+end
+
+Monomial{C}(vars::Tuple{Vararg{PolyVar{C}}}, z::Vector{Int}) where C = Monomial{C}([vars...], z)
+
+iscomm(::Type{Monomial{C}}) where C = C
+Monomial{C}() where C = Monomial{C}(PolyVar{C}[], Int[])
+Monomial(vars::TupOrVec{PolyVar{C}}, z::Vector{Int}) where C = Monomial{C}(vars, z)
+function Base.convert(::Type{Monomial{C}}, x::PolyVar{C}) where C
+    return Monomial{C}([x], [1])
+end
+Monomial(x::PolyVar{C}) where C = convert(Monomial{C}, x)
+function MP.convertconstant(::Type{Monomial{C}}, α) where C
+    α == 1 || error("Cannot convert $α to a Monomial{$C} as it is not one")
+    Monomial{C}(PolyVar{C}[], Int[])
+end
+
+# defaults to commutative so that `Monomial(1)` is consistent with TypedPolynomials
+Monomial(α::Number) = convert(Monomial{true}, α)
+
+Base.broadcastable(m::Monomial) = Ref(m)
+Base.copy(m::M) where {M<:Monomial} = M(m.vars, copy(m.z))
+
+# Generate canonical reperesentation by removing variables that are not used
+function canonical(m::Monomial)
+    list = m.z .> 0
+    Monomial(_vars(m)[list], m.z[list])
+end
+function Base.hash(x::Monomial, u::UInt)
+    cx = canonical(x)
+    if iszero(nvariables(cx))
+        hash(1, u)
+    elseif nvariables(cx) == 1 && cx.z[1] == 1
+        hash(cx.vars[1], u)
+    else # TODO reduce power in MP
+        hash(_vars(cx), hash(cx.z, u))
+    end
+end
+
+MP.exponents(m::Monomial) = m.z
+# /!\ vars not copied, do not mess with vars
+_vars(m::Union{Monomial}) = m.vars
+
+MP.monomial(m::Monomial) = m
+# Does m1 divides m2 ?
+#function MP.divides(m1::Monomial, m2::Monomial)
+#    i = j = 1
+#    while i <= length(m1.z) && j <= length(m2.z)
+#        if m1.vars[i] == m2.vars[j]
+#            if m1.z[i] > m2.z[j]
+#                return false
+#            end
+#            i += 1
+#            j += 1
+#        elseif m1.vars[i] > m2.vars[j]
+#            if !iszero(m1.z[i])
+#                return false
+#            end
+#            i += 1
+#        else
+#            j += 1
+#        end
+#    end
+#    i > length(m1.z)
+#end

monovec.jl

@@ -0,0 +1,241 @@
+export MonomialVector
+
+# Invariant: Always sorted and no zero vector
+struct MonomialVector{C} <: AbstractVector{Monomial{C}}
+    vars::Vector{PolyVar{C}}
+    Z::Vector{Vector{Int}}
+
+    function MonomialVector{C}(vars::Vector{PolyVar{C}}, Z::Vector{Vector{Int}}) where {C}
+        @assert !C || issorted(vars, rev=true)
+        @assert all(z -> length(z) == length(vars), Z)
+        @assert issorted(Z, rev=true, lt=grlex)
+        new(vars, Z)
+    end
+end
+MonomialVector(vars::Vector{PolyVar{C}}, Z::Vector{Vector{Int}}) where {C} = MonomialVector{C}(vars, Z)
+MonomialVector{C}() where {C} = MonomialVector{C}(PolyVar{C}[], Vector{Int}[])
+
+# Generate canonical reperesentation by removing variables that are not used
+function canonical(m::MonomialVector)
+    v = zeros(Bool, nvariables(m))
+    for z in m.Z
+        v = [v[i] || z[i] > 0 for i in eachindex(v)]
+    end
+    MonomialVector(_vars(m)[v], Vector{Int}[z[v] for z in m.Z])
+end
+
+function Base.hash(m::MonomialVector, u::UInt)
+    cm = canonical(m)
+    if length(cm.Z) == 0
+        hash([], u)
+    elseif length(cm.Z) == 1
+        hash(Monomial(_vars(cm), cm.Z[1]), u)
+    else
+        hash(_vars(cm), hash(cm.Z, hash(u)))
+    end
+end
+
+# /!\ vars not copied, do not mess with vars
+Base.copy(m::MV) where {MV<:MonomialVector} = MV(m.vars, copy(m.Z))
+function Base.getindex(x::MV, I) where {MV<:MonomialVector}
+    MV(x.vars, x.Z[sort(I)])
+end
+Base.getindex(x::MonomialVector, i::Integer) = Monomial(x.vars, x.Z[i])
+
+Base.firstindex(x::MonomialVector) = firstindex(x.Z)
+Base.lastindex(x::MonomialVector) = lastindex(x.Z)
+Base.size(x::MonomialVector) = (length(x),)
+Base.length(x::MonomialVector) = length(x.Z)
+Base.isempty(x::MonomialVector) = length(x) == 0
+Base.iterate(x::MonomialVector) = isempty(x) ? nothing : (x[1], 1)
+function Base.iterate(x::MonomialVector, state::Int)
+    state < length(x) ? (x[state+1], state+1) : nothing
+end
+
+MultivariatePolynomials.extdegree(x::MonomialVector) = isempty(x) ? (0, 0) : extrema(sum.(x.Z))
+MultivariatePolynomials.mindegree(x::MonomialVector) = isempty(x) ? 0 : minimum(sum.(x.Z))
+MultivariatePolynomials.maxdegree(x::MonomialVector) = isempty(x) ? 0 : maximum(sum.(x.Z))
+
+_vars(m::Union{Monomial, MonomialVector}) = m.vars
+
+# Recognize arrays of monomials of this module
+# [x, y] -> Vector{PolyVar}
+# [x, x*y] -> Vector{Monomial}
+# [1, x] -> Vector{Term{Int}}
+const DMonoVecElemNonConstant{C} = Union{PolyVar{C}, Monomial{C}, Term{C}}
+# [1] -> Vector{Int}
+const DMonoVecElem{C} = Union{Int, DMonoVecElemNonConstant{C}}
+const DMonoVec{C} = AbstractVector{<:DMonoVecElem{C}}
+
+MP.emptymonovec(vars::AbstractVector{PolyVar{C}}) where {C} = MonomialVector{C}(vars, Vector{Int}[])
+MP.emptymonovec(t::DMonoVecElemNonConstant) = emptymonovec(_vars(t))
+MP.emptymonovec(::Type{<:DMonoVecElemNonConstant{C}}) where {C} = MonomialVector{C}()
+
+function fillZfordeg!(Z, n, deg, ::Type{Val{true}}, filter::Function)
+    z = zeros(Int, n)
+    z[1] = deg
+    while true
+        if filter(z)
+            push!(Z, z)
+            z = copy(z)
+        end
+        if z[end] == deg
+            break
+        end
+        sum = 1
+        for j in (n-1):-1:1
+            if z[j] != 0
+                z[j] -= 1
+                z[j+1] += sum
+                break
+            else
+                sum += z[j+1]
+                z[j+1] = 0
+            end
+        end
+    end
+end
+function fillZrec!(Z, z, i, n, deg, filter::Function)
+    if deg == 0
+        if filter(z)
+            push!(Z, copy(z))
+        end
+    else
+        for i in i:i+n-1
+            z[i] += 1
+            fillZrec!(Z, z, i, n, deg-1, filter)
+            z[i] -= 1
+        end
+    end
+end
+function fillZfordeg!(Z, n, deg, ::Type{Val{false}}, filter::Function)
+    z = zeros(Int, deg * n - deg + 1)
+    fillZrec!(Z, z, 1, n, deg, filter)
+end
+# List exponents in decreasing Graded Lexicographic Order
+function getZfordegs(n, degs::AbstractVector{Int}, ::Type{Val{C}}, filter::Function) where C
+    Z = Vector{Vector{Int}}()
+    for deg in sort(degs, rev=true)
+        fillZfordeg!(Z, n, deg, Val{C}, filter)
+    end
+    @assert issorted(Z, rev=true, lt=grlex)
+    Z
+end
+
+function MonomialVector(vars::Vector{PolyVar{true}}, degs::AbstractVector{Int}, filter::Function = x->true)
+    MonomialVector{true}(vars, getZfordegs(length(vars), degs, Val{true}, z -> filter(Monomial(vars, z))))
+end
+
+function getvarsforlength(vars::Vector{PolyVar{false}}, len::Int)
+    n = length(vars)
+    map(i -> vars[((i-1) % n) + 1], 1:len)
+end
+function MonomialVector(vars::Vector{PolyVar{false}}, degs::AbstractVector{Int}, filter::Function = x->true)
+    Z = getZfordegs(length(vars), degs, Val{false}, z -> filter(Monomial(getvarsforlength(vars, length(z)), z)))
+    v = isempty(Z) ? vars : getvarsforlength(vars, length(first(Z)))
+    MonomialVector{false}(v, Z)
+end
+MonomialVector(vars::Vector{<:PolyVar}, degs::Int, filter::Function = x->true) = MonomialVector(vars, [degs], filter)
+
+MP.monomials(vars::AbstractVector{<:PolyVar}, args...) = MonomialVector(vars, args...)
+MP.monomials(vars::Tuple{Vararg{PolyVar}}, args...) = monomials([vars...], args...)
+
+#function MP.monomials(vars::TupOrVec{PolyVar{true}}, degs::AbstractVector{Int}, filter::Function = x->true)
+#    Z = getZfordegs(length(vars), degs, true, z -> filter(Monomial(vars, z)))
+#    [Monomial{true}(vars, z) for z in Z]
+#end
+#function MP.monomials(vars::TupOrVec{PolyVar{false}}, degs::AbstractVector{Int}, filter::Function = x->true)
+#    Z = getZfordegs(length(vars), degs, false, z -> filter(Monomial(vars, z)))
+#    v = isempty(Z) ? vars : getvarsforlength(vars, length(first(Z)))
+#    [Monomial{false}(v, z) for z in Z]
+#end
+#MP.monomials(vars::TupOrVec{PV}, degs::Int, filter::Function = x->true) where {PV<:PolyVar} = monomials(vars, [degs], filter)
+
+function buildZvarsvec(::Type{PV}, X::DMonoVec) where {PV<:PolyVar}
+    varsvec = Vector{PV}[ (isa(x, DMonoVecElemNonConstant) ? _vars(x) : PolyVar[]) for x in X ]
+    allvars, maps = mergevars(varsvec)
+    nvars = length(allvars)
+    Z = [zeros(Int, nvars) for i in 1:length(X)]
+    offset = 0
+    for (i, x) in enumerate(X)
+        if isa(x, PolyVar)
+            @assert length(maps[i]) == 1
+            z = [1]
+        elseif isa(x, Monomial)
+            z = x.z
+        elseif isa(x, Term)
+            z = x.x.z
+        else
+            @assert isa(x, Int)
+            z = Int[]
+        end
+        Z[i][maps[i]] = z
+    end
+    allvars, Z
+end
+
+MP.sortmonovec(X::MonomialVector) = (1:length(X), X)
+function _sortmonovec(X::DMonoVec{C}) where {C}
+    allvars, Z = buildZvarsvec(PolyVar{C}, X)
+    σ = sortperm(Z, rev=true, lt=grlex)
+    allvars, Z, σ
+end
+function _removedups!(Z::Vector{Vector{Int}}, σ::Vector{Int})
+    dups = findall(i -> Z[σ[i]] == Z[σ[i-1]], 2:length(σ))
+    deleteat!(σ, dups)
+end
+function MP.sortmonovec(X::DMonoVec{C}) where {C}
+    if isempty(X)
+        Int[], MonomialVector{C}()
+    else
+        allvars, Z, σ = _sortmonovec(X)
+        _removedups!(Z, σ)
+        σ, MonomialVector{C}(allvars, Z[σ])
+    end
+end
+
+function MonomialVector{C}(X::DMonoVec{C}) where C
+    allvars, Z = buildZvarsvec(PolyVar{C}, X)
+    sort!(Z, rev=true, lt=grlex)
+    dups = findall(i -> Z[i] == Z[i-1], 2:length(Z))
+    deleteat!(Z, dups)
+    MonomialVector{C}(allvars, Z)
+end
+function MonomialVector(X)
+    monovectype(X)(X)
+end
+
+MP.monovectype(X::Union{DMonoVecElemNonConstant{C}, Type{<:DMonoVecElemNonConstant{C}}, DMonoVec{C}, Type{<:DMonoVec{C}}}) where {C} = MonomialVector{C}
+function MP.monovec(X::DMonoVec)
+    MonomialVector(X)
+end
+MP.monovec(a, mv::MonomialVector) = (a, mv)
+
+function MP.mergemonovec(ms::Vector{MonomialVector{C}}) where {C}
+    m = length(ms)
+    I = ones(Int, length(ms))
+    L = length.(ms)
+    X = Vector{Monomial{C}}()
+    while any(I .<= L)
+        max = nothing
+        for i in 1:m
+            if I[i] <= L[i]
+                x = ms[i][I[i]]
+                if max === nothing || max < x
+                    max = x
+                end
+            end
+        end
+        @assert max !== nothing
+        # to ensure that max is no more a union
+        max === nothing && return X
+        push!(X, max)
+        for i in 1:m
+            if I[i] <= L[i] && max == ms[i][I[i]]
+                I[i] += 1
+            end
+        end
+    end
+    # There is no duplicate by construction
+    return MonomialVector{C}(buildZvarsvec(PolyVar{C}, X)...)
+end

mult.jl

@@ -0,0 +1,101 @@
+function multiplyexistingvar(v::Vector{PolyVar{C}}, x::PolyVar{C}, i::Int) where {C}
+    updatez = z -> begin
+        newz = copy(z)
+        newz[i] += 1
+        newz
+    end
+    # /!\ v not copied for efficiency, do not mess up with vars
+    v, updatez
+end
+function insertvar(v::Vector{PolyVar{C}}, x::PolyVar{C}, i::Int) where {C}
+    n = length(v)
+    I = 1:i-1
+    J = i:n
+    K = J.+1
+    w = Vector{PolyVar{C}}(undef, n+1)
+    w[I] = v[I]
+    w[i] = x
+    w[K] = v[J]
+    updatez = z -> begin
+        newz = Vector{Int}(undef, n+1)
+        newz[I] = z[I]
+        newz[i] = 1
+        newz[K] = z[J]
+        newz
+    end
+    w, updatez
+end
+
+include("cmult.jl")
+include("ncmult.jl")
+
+MP.multconstant(α, x::Monomial)   = Term(α, x)
+MP.mapcoefficientsnz(f::Function, p::Polynomial) = Polynomial(f.(p.a), p.x)
+
+# I do not want to cast x to TermContainer because that would force the promotion of eltype(q) with Int
+function Base.:(*)(x::DMonomialLike, p::Polynomial)
+    # /!\ No copy of a is done
+    Polynomial(p.a, x*p.x)
+end
+function Base.:(*)(x::DMonomialLike{false}, p::Polynomial)
+    # /!\ No copy of a is done
+    # Order may change, e.g. y * (x + y) = y^2 + yx
+    Polynomial(monovec(p.a, [x*m for m in p.x])...)
+end
+function Base.:(*)(p::Polynomial, x::DMonomialLike)
+    # /!\ No copy of a is done
+    Polynomial(p.a, p.x*x)
+end
+
+function _term_poly_mult(t::Term{C, S}, p::Polynomial{C, T}, op::Function) where {C, S, T}
+    U = Base.promote_op(op, S, T)
+    if iszero(t)
+        zero(Polynomial{C, U})
+    else
+        n = nterms(p)
+        allvars, maps = mergevars([t.x.vars, p.x.vars])
+        nv = length(allvars)
+        # Necessary to annotate the type in case it is empty
+        Z = Vector{Int}[zeros(Int, nv) for i in 1:n]
+        for i in 1:n
+            Z[i][maps[1]] = t.x.z
+            Z[i][maps[2]] += p.x.Z[i]
+        end
+        Polynomial(op.(t.α, p.a), MonomialVector(allvars, Z))
+    end
+end
+Base.:(*)(p::Polynomial, t::Term) = _term_poly_mult(t, p, (α, β) -> β * α)
+Base.:(*)(t::Term, p::Polynomial) = _term_poly_mult(t, p, *)
+_sumprod(a, b) = a * b + a * b
+function Base.:(*)(p::Polynomial{C, S}, q::Polynomial{C, T}) where {C, S, T}
+    U = Base.promote_op(_sumprod, S, T)
+    if iszero(p) || iszero(q)
+        zero(Polynomial{C, U})
+    else
+        samevars = _vars(p) == _vars(q)
+        if samevars
+            allvars = _vars(p)
+        else
+            allvars, maps = mergevars([_vars(p), _vars(q)])
+        end
+        N = length(p)*length(q)
+        Z = Vector{Vector{Int}}(undef, N)
+        a = Vector{U}(undef, N)
+        i = 0
+        for u in p
+            for v in q
+                if samevars
+                    z = u.x.z + v.x.z
+                else
+                    z = zeros(Int, length(allvars))
+                    z[maps[1]] += u.x.z
+                    z[maps[2]] += v.x.z
+                end
+                i += 1
+                Z[i] = z
+                a[i] = u.α * v.α
+            end
+        end
+        polynomialclean(allvars, a, Z)
+    end
+end

ncmult.jl

@@ -0,0 +1,123 @@
+function Base.:(*)(x::PolyVar{false}, y::PolyVar{false})
+    if x === y
+        Monomial{false}([x], [2])
+    else
+        Monomial{false}([x, y], [1, 1])
+    end
+end
+
+function multiplyvar(v::Vector{PolyVar{false}}, z::Vector{Int}, x::PolyVar{false})
+    i = length(v)
+    while i > 0 && z[i] == 0
+        i -= 1
+    end
+    if v[i] == x
+        multiplyexistingvar(v, x, i)
+    else
+        #   ---->
+        # \  |\  |\
+        #  \ | \ | \
+        #   \|  \|  \
+        # If z[i] > x, we wait either for a rise (v[i] > v[i-1]) or v[i] < x
+        # Otherwise, we first wait for a drop and then wait for the same thing
+        ndrop = 0
+        if v[i] > x
+            droplim1 = 0
+            droplim2 = 1
+        else
+            droplim1 = 1
+            droplim2 = 2
+        end
+        i += 1
+        while i <= length(v) && v[i] != x
+            if v[i] > v[i-1]
+                ndrop += 1
+            end
+            if ndrop >= droplim2 || (ndrop >= droplim1 && v[i] < x)
+                break
+            end
+            i += 1
+        end
+
+        if i <= length(v) && v[i] == x
+            multiplyexistingvar(v, x, i)
+        else
+            insertvar(v, x, i)
+        end
+    end
+end
+function multiplyvar(x::PolyVar{false}, v::Vector{PolyVar{false}}, z::Vector{Int})
+    i = 1
+    while i <= length(v) && z[i] == 0
+        i += 1
+    end
+    if v[i] == x
+        multiplyexistingvar(v, x, i)
+    else
+        #   <----
+        # \  |\  |\
+        #  \ | \ | \
+        #   \|  \|  \
+        # If z[i] < x, we wait either for a drop (v[i] < v[i+1]) or v[i] > x
+        # Otherwise, we first wait for a drop and then wait for the same thing
+        ndrop = 0
+        if v[i] < x
+            droplim1 = 0
+            droplim2 = 1
+        else
+            droplim1 = 1
+            droplim2 = 2
+        end
+        i -= 1
+        while i > 0 && v[i] != x
+            if v[i] < v[i+1]
+                ndrop += 1
+            end
+            if ndrop >= droplim2 || (ndrop >= droplim1 && v[i] > x)
+                break
+            end
+            i -= 1
+        end
+        if i > 0 && v[i] == x
+            multiplyexistingvar(v, x, i)
+        else
+            insertvar(v, x, i+1)
+        end
+    end
+end
+function Base.:(*)(x::PolyVar{false}, y::Monomial{false})
+    w, updatez = multiplyvar(x, y.vars, y.z)
+    Monomial{false}(w, updatez(y.z))
+end
+function Base.:(*)(y::Monomial{false}, x::PolyVar{false})
+    w, updatez = multiplyvar(y.vars, y.z, x)
+    Monomial{false}(w, updatez(y.z))
+end
+
+function Base.:(*)(x::Monomial{false}, y::Monomial{false})
+    i = findlast(z -> z > 0, x.z)
+    if i == nothing || i == 0
+        return y
+    end
+    j = findfirst(z -> z > 0, y.z)
+    if j == nothing || j == 0
+        return x
+    end
+    if x.vars[i] == y.vars[j]
+        w = [x.vars[1:i]; y.vars[j+1:end]]
+        z = [x.z[1:i-1]; x.z[i] + y.z[j]; y.z[j+1:end]]
+    else
+        w = [x.vars[1:i]; y.vars[j:end]]
+        z = [x.z[1:i]; y.z[j:end]]
+    end
+    return Monomial{false}(w, z)
+end
+
+function Base.:(*)(y::MonomialVector{false}, x::DMonomialLike{false})
+    MonomialVector{false}([yi * x for yi in y])
+end
+function Base.:(*)(x::DMonomialLike{false}, y::MonomialVector{false})
+    # The order may change
+    # Example: y * [x^2, y^2] == [y^3, yx^2]
+    MonomialVector{false}([x * yi for yi in y])
+end

operators.jl

@@ -0,0 +1,66 @@
+# In Base/intfuncs.jl, x^p returns zero(x) when p == 0
+# Since one(PolyVar) and one(Monomial) do not return
+# a PolyVar and a Monomial, this results in type instability
+# Defining the specific methods solve this problem and also make
+# them a lot faster
+Base.:(^)(x::PolyVar{C}, i::Int) where {C} = Monomial{C}([x], [i])
+Base.:(^)(x::Monomial{true}, i::Int) = Monomial{true}(x.vars, i*x.z)
+
+myminivect(x::T, y::T) where {T} = [x, y]
+function myminivect(x::S, y::T) where {S,T}
+    U = promote_type(S, T)
+    [U(x), U(y)]
+end
+
+Base.:(+)(x::DMonomialLike, y::DMonomialLike) = Term(x) + Term(y)
+Base.:(-)(x::DMonomialLike, y::DMonomialLike) = Term(x) - Term(y)
+
+_getindex(p::Polynomial, i) = p[i]
+_getindex(t::Term, i) = t
+function plusorminus(p::TermPoly{C, S}, q::TermPoly{C, T}, op) where {C, S, T}
+    varsvec = [_vars(p), _vars(q)]
+    allvars, maps = mergevars(varsvec)
+    nvars = length(allvars)
+    U = Base.promote_op(op, S, T)
+    a = Vector{U}()
+    Z = Vector{Vector{Int}}()
+    i = j = 1
+    while i <= nterms(p) || j <= nterms(q)
+        z = zeros(Int, nvars)
+        if j > nterms(q) || (i <= nterms(p) && _getindex(p, i).x > _getindex(q, j).x)
+            t = _getindex(p, i)
+            z[maps[1]] = t.x.z
+            α = convert(U, t.α)
+            i += 1
+        elseif i > nterms(p) || _getindex(q, j).x > _getindex(p, i).x
+            t = _getindex(q, j)
+            z[maps[2]] = t.x.z
+            α = convert(U, op(t.α))
+            j += 1
+        else
+            t = _getindex(p, i)
+            z[maps[1]] = t.x.z
+            s = _getindex(q, j)
+            α = op(t.α, s.α)
+            i += 1
+            j += 1
+        end
+        push!(a, α)
+        push!(Z, z)
+    end
+
+    Polynomial(a, MonomialVector{C}(allvars, Z))
+end
+
+
+Base.:(+)(x::TermPoly{C}, y::TermPoly{C}) where C = plusorminus(x, y, +)
+Base.:(-)(x::TermPoly{C}, y::TermPoly{C}) where C = plusorminus(x, y, -)
+Base.:(+)(x::TermPoly{C}, y::Union{Monomial,PolyVar}) where C = x + Term{C}(y)
+Base.:(+)(x::Union{Monomial,PolyVar}, y::TermPoly{C}) where C = Term{C}(x) + y
+
+Base.:(-)(x::TermPoly{T}, y::DMonomialLike) where T = x - Term{T}(y)
+Base.:(-)(x::DMonomialLike, y::TermPoly{T}) where T = Term{T}(x) - y
+
+Base.:(-)(p::Polynomial) = Polynomial(-p.a, p.x)
+
+include("mult.jl")

poly.jl

@@ -0,0 +1,230 @@
+export Polynomial
+
+# Invariant:
+# a and x might be empty: meaning it is the zero polynomial
+# a does not contain any zeros
+# x is increasing in the monomial order (i.e. grlex)
+struct Polynomial{C, T} <: AbstractPolynomial{T}
+    a::Vector{T}
+    x::MonomialVector{C}
+
+    function Polynomial{C, T}(a::Vector{T}, x::MonomialVector{C}) where {C, T}
+        length(a) == length(x) || throw(ArgumentError("There should be as many coefficient than monomials"))
+        zeroidx = Int[]
+        for (i,α) in enumerate(a)
+            if iszero(α)
+                push!(zeroidx, i)
+            end
+        end
+        if !isempty(zeroidx)
+            isnz = ones(Bool, length(a))
+            isnz[zeroidx] .= false
+            nzidx = findall(isnz)
+            a = a[nzidx]
+            x = x[nzidx]
+        end
+        new{C, T}(a, x)
+    end
+end
+
+iscomm(::Type{Polynomial{C, T}}) where {C, T} = C
+
+Base.broadcastable(p::Polynomial) = Ref(p)
+Base.copy(p::Polynomial{C, T}) where {C, T} = Polynomial{C, T}(copy(p.a), copy(p.x))
+Base.zero(::Type{Polynomial{C, T}}) where {C, T} = Polynomial(T[], MonomialVector{C}())
+Base.one(::Type{Polynomial{C, T}}) where {C, T} = Polynomial([one(T)], MonomialVector{C}(PolyVar{C}[], [Int[]]))
+Base.zero(p::Polynomial{C, T}) where {C, T} = Polynomial(T[], emptymonovec(_vars(p)))
+Base.one(p::Polynomial{C, T}) where {C, T} = Polynomial([one(T)], MonomialVector(_vars(p), [zeros(Int, nvariables(p))]))
+
+Polynomial{C, T}(a::AbstractVector, x::MonomialVector) where {C, T} = Polynomial{C, T}(Vector{T}(a), x)
+Polynomial{C, T}(a::AbstractVector, X::DMonoVec) where {C, T} = Polynomial{C, T}(monovec(a, X)...)
+Polynomial{C}(a::Vector{T}, x) where {C, T} = Polynomial{C, T}(a, x)
+Polynomial(af::Union{Function, Vector}, x::DMonoVec{C}) where {C} = Polynomial{C}(af, x)
+
+# TODO Remove with MP v0.2.8
+Polynomial{C, T}(p::Polynomial{C, T}) where {C, T} = p
+
+Base.convert(::Type{Polynomial{C, T}}, p::Polynomial{C, T}) where {C, T} = p
+function Base.convert(::Type{Polynomial{C, T}},
+                      p::Polynomial{C, S}) where {C, S, T}
+    return Polynomial{C}(convert(Vector{T}, p.a), p.x)
+end
+#function convert(::Type{Polynomial{C, T}},
+#                 p::AbstractPolynomialLike) where {C, T}
+#    return convert(Polynomial{C, T}, polynomial(p, T))
+#end
+function Base.convert(::Type{Polynomial{C, T}}, t::Term{C}) where {C, T}
+    return Polynomial{C, T}(T[t.α], [t.x])
+end
+function Base.convert(::Type{Polynomial{C, T}}, m::DMonomialLike{C}) where {C, T}
+    return Polynomial(convert(Term{C, T}, m))
+end
+function MP.convertconstant(::Type{Polynomial{C, T}}, α) where {C, T}
+    return Polynomial(convert(Term{C, T}, α))
+end
+
+Polynomial{C}(p::Union{Polynomial{C}, Term{C}, Monomial{C}, PolyVar{C}}) where {C} = Polynomial(p)
+Polynomial{C}(α) where {C} = Polynomial(Term{C}(α))
+
+Polynomial(p::Polynomial) = p
+Polynomial(t::Term{C, T}) where {C, T} = Polynomial{C, T}([t.α], [t.x])
+Polynomial(x::Union{PolyVar{C}, Monomial{C}}) where {C} = Polynomial(Term{C}(x))
+
+#Base.convert(::Type{TermContainer{C, T}}, p::Polynomial{C}) where {C, T} = Polynomial{C, T}(p)
+
+function Polynomial{C, T}(f::Function, x::MonomialVector{C}) where {C, T}
+    a = T[f(i) for i in 1:length(x)]
+    Polynomial{C, T}(a, x)
+end
+function Polynomial{C, T}(f::Function, x::AbstractVector) where {C, T}
+    σ, X = sortmonovec(x)
+    a = T[f(i) for i in σ]
+    Polynomial{C, T}(a, X)
+end
+Polynomial{C}(f::Function, x) where {C} = Polynomial{C, Base.promote_op(f, Int)}(f, x)
+
+#Base.convert(::Type{PolyType{C}}, p::TermContainer{C}) where {C} = p
+
+# needed to build [p Q; Q p] where p is a polynomial and Q is a matpolynomial in Julia v0.5
+#Base.convert(::Type{TermType{C}}, p::TermContainer{C}) where {C} = p
+#Base.convert(::Type{TermType{C, T}}, p::TermContainer{C, T}) where {C, T} = p
+
+Base.length(p::Polynomial) = length(p.a)
+Base.isempty(p::Polynomial) = isempty(p.a)
+Base.iterate(p::Polynomial) = isempty(p) ? nothing : (p[1], 1)
+function Base.iterate(p::Polynomial, state::Int)
+    state < length(p) ? (p[state+1], state+1) : nothing
+end
+#eltype(::Type{Polynomial{C, T}}) where {C, T} = T
+Base.getindex(p::Polynomial, I::Int) = Term(p.a[I[1]], p.x[I[1]])
+
+#Base.transpose(p::Polynomial) = Polynomial(map(transpose, p.a), p.x) # FIXME invalid age range update
+
+struct TermIterator{C, T} <: AbstractVector{Term{C, T}}
+    p::Polynomial{C, T}
+end
+Base.firstindex(p::TermIterator) = firstindex(p.p.a)
+Base.lastindex(p::TermIterator) = lastindex(p.p.a)
+Base.length(p::TermIterator) = length(p.p.a)
+Base.size(p::TermIterator) = (length(p),)
+Base.isempty(p::TermIterator) = isempty(p.p.a)
+Base.iterate(p::TermIterator) = isempty(p) ? nothing : (p[1], 1)
+function Base.iterate(p::TermIterator, state::Int)
+    state < length(p) ? (p[state+1], state+1) : nothing
+end
+
+Base.getindex(p::TermIterator, I::Int) = Term(p.p.a[I[1]], p.p.x[I[1]])
+
+MP.terms(p::Polynomial) = TermIterator(p)
+MP.coefficients(p::Polynomial) = p.a
+MP.monomials(p::Polynomial) = p.x
+_vars(p::Polynomial) = _vars(p.x)
+
+MP.extdegree(p::Polynomial) = extdegree(p.x)
+MP.mindegree(p::Polynomial) = mindegree(p.x)
+MP.maxdegree(p::Polynomial) = maxdegree(p.x)
+
+MP.leadingcoefficient(p::Polynomial{C, T}) where {C, T} = iszero(p) ? zero(T) : first(p.a)
+MP.leadingmonomial(p::Polynomial) = iszero(p) ? constantmonomial(p) : first(p.x)
+MP.leadingterm(p::Polynomial) = iszero(p) ? zeroterm(p) : first(terms(p))
+
+function MP.removeleadingterm(p::Polynomial)
+    Polynomial(p.a[2:end], p.x[2:end])
+end
+function MP.removemonomials(p::Polynomial, x::MonomialVector)
+    # use the fact that monomials are sorted to do this O(n) instead of O(n^2)
+    j = 1
+    I = Int[]
+    for (i,t) in enumerate(p)
+        while j <= length(x) && x[j] > t.x
+            j += 1
+        end
+        if j > length(x) || x[j] != t.x
+            push!(I, i)
+        end
+    end
+    Polynomial(p.a[I], p.x[I])
+end
+MP.removemonomials(p::Polynomial, x::Vector) = removemonomials(p, MonomialVector(x))
+
+function removedups(adup::Vector{T}, Zdup::Vector{Vector{Int}}) where {T}
+    σ = sortperm(Zdup, rev=true, lt=grlex)
+    Z = Vector{Vector{Int}}()
+    a = Vector{T}()
+    i = 0
+    j = 1
+    while j <= length(adup)
+        k = σ[j]
+        if j == 1 || Zdup[k] != Zdup[σ[j-1]]
+            push!(Z, Zdup[k])
+            push!(a, adup[k])
+            i += 1
+        else
+            a[i] += adup[k]
+        end
+        j += 1
+    end
+    a, Z
+end
+function polynomialclean(vars::Vector{PolyVar{C}}, adup::Vector{T}, Zdup::Vector{Vector{Int}}) where {C, T}
+    a, Z = removedups(adup, Zdup)
+    Polynomial{C, T}(a, MonomialVector{C}(vars, Z))
+end
+
+MP.polynomial(a::AbstractVector, x::DMonoVec, s::MP.ListState) = Polynomial(collect(a), x)
+
+#MP.polynomial(f::Function, x::AbstractVector) = Polynomial(f, x)
+#MP.polynomial(ts::AbstractVector{Term{C, T}}) where {C, T} = Polynomial(coefficient.(ts), monomial.(ts)) # FIXME invalid age range update
+
+# i < j
+function trimap(i, j, n)
+    div(n*(n+1), 2) - div((n-i+1)*(n-i+2), 2) + j-i+1
+end
+MP.polynomial(Q::AbstractMatrix{T}, mv::MonomialVector) where T = MP.polynomial(Q, mv, Base.promote_op(+, T, T))
+function MP.polynomial(Q::AbstractMatrix, mv::MonomialVector{C}, ::Type{T}) where {C, T}
+    if isempty(Q)
+        zero(Polynomial{C, T})
+    else
+        n = length(mv)
+        if C
+            N = trimap(n, n, n)
+            Z = Vector{Vector{Int}}(undef, N)
+            a = Vector{T}(undef, N)
+            for i in 1:n
+                for j in i:n
+                    k = trimap(i, j, n)
+                    Z[k] = mv.Z[i] + mv.Z[j]
+                    if i == j
+                        a[k] = Q[i, j]
+                    else
+                        a[k] = Q[i, j] + Q[j, i]
+                    end
+                end
+            end
+            v = _vars(mv)
+        else
+            N = n^2
+            x = Vector{Monomial{C}}(undef, N)
+            a = Vector{T}(undef, N)
+            offset = 0
+            for i in 1:n
+                # for j in 1:n wouldn't be cache friendly for Q
+                for j in i:n
+                    k = trimap(i, j, n)
+                    q = Q[i, j]
+                    x[offset+k] = mv[i] * mv[j]
+                    a[offset+k] = q
+                    if i != j
+                        offset += 1
+                        x[offset+k] = mv[j] * mv[i]
+                        a[offset+k] = q
+                    end
+                end
+            end
+            a, X = monovec(a, x)
+            v = _vars(X)
+            Z = X.Z
+        end
+        polynomialclean(v, a, Z)
+    end
+end

promote.jl

@@ -0,0 +1,27 @@
+# Promotion with PolyVar and Monomial
+Base.promote_rule(::Type{PolyVar{C}}, ::Type{PolyVar{C}}) where {C} = PolyVar{C}
+Base.promote_rule(::Type{<:DMonomialLike{C}}, ::Type{<:DMonomialLike{C}}) where {C} = Monomial{C}
+#promote_rule{S<:Union{Monomial, PolyVar}, T<:Union{Monomial, PolyVar}}(::Type{S}, ::Type{T}) = Monomial{iscomm{S}}
+
+Base.promote_rule(::Type{Polynomial{C, S}}, ::Type{Polynomial{C, T}}) where {S, C, T} = Polynomial{C, promote_type(S, T)}
+Base.promote_rule(::Type{<:AbstractPolynomialLike{S}}, ::Type{Polynomial{C, T}}) where {S, C, T} = Polynomial{C, promote_type(S, T)}
+Base.promote_rule(::Type{Polynomial{C, T}}, ::Type{<:AbstractPolynomialLike{S}}) where {S, C, T} = Polynomial{C, promote_type(S, T)}
+Base.promote_rule(::Type{<:DMonomialLike{S}}, ::Type{Polynomial{C, T}}) where {S, C, T} = Polynomial{C, promote_type(T, Int)}
+Base.promote_rule(::Type{Polynomial{C, T}}, ::Type{<:DMonomialLike{S}}) where {S, C, T} = Polynomial{C, promote_type(T, Int)}
+
+MP.promote_rule_constant(::Type{T}, ::Type{<:DMonomialLike{C}}) where {C, T} = Term{C, promote_type(T, Int)}
+MP.promote_rule_constant(::Type{S}, ::Type{Term{C, T}}) where {S, C, T} = Term{C, promote_type(S, T)}
+MP.promote_rule_constant(::Type{S}, ::Type{<:TermPoly{C, T}}) where {S, C, T} = Polynomial{C, promote_type(S, T)}
+
+# Promotion with Term
+Base.promote_rule(::Type{Term{C, S}}, ::Type{Term{C, T}}) where {C,S,T} = Term{C, promote_type(S, T)}
+Base.promote_rule(::Type{<:DMonomialLike{C}}, ::Type{Term{C, T}}) where {C,T} = Term{C, promote_type(T, Int)}
+Base.promote_rule(::Type{Term{C, T}}, ::Type{<:DMonomialLike{C}}) where {C,T} = Term{C, promote_type(T, Int)}
+
+# Promotion with Polynomial
+#Base.promote_rule(::Type{Polynomial{C, S}}, ::Type{Term{C, T}}) where {C, S, T} = Polynomial{C, promote_type(S, T)}
+#Base.promote_rule(::Type{Term{C, T}}, ::Type{Polynomial{C, S}}) where {C, S, T} = Polynomial{C, promote_type(S, T)}
+
+#Base.promote_rule(::Type{<:TermPoly{C, S}}, ::Type{<:TermPoly{C, T}}) where {C, S, T} = Polynomial{C, promote_type(S, T)}
+#Base.promote_rule(::Type{<:TermPoly{C, T}}, ::Type{<:DMonomialLike{C}}) where {C, T} = Polynomial{C, promote_type(T, Int)}
+#Base.promote_rule(::Type{<:DMonomialLike{C}}, ::Type{<:TermPoly{C, T}}) where {C, T} = Polynomial{C, promote_type(T, Int)}

subs.jl

@@ -0,0 +1,106 @@
+function fillmap!(vals, vars, s::MP.Substitution)
+    j = findfirst(isequal(s.first), vars)
+    if j !== nothing
+        vals[j] = s.second
+    end
+end
+function fillmap!(vals, vars, s::MP.AbstractMultiSubstitution)
+    for (v, x) in zip(s.first, s.second)
+        fillmap!(vals, vars, v => x)
+    end
+end
+
+function fillmap!(vals, vars, s1::MP.AbstractSubstitution, s2::MP.AbstractSubstitution...)
+    fillmap!(vals, vars, s1)
+    fillmap!(vals, vars, s2...)
+end
+
+_eltype(::T) where {T} = T
+_eltype(t::Tuple) = Base.promote_typeof(t...)
+_eltype(::Tuple{Vararg{T}}) where {T} = T
+_eltype(::AbstractVector{T}) where {T} = T
+_substype(s::MP.AbstractSubstitution) = _eltype(s.second)
+_substype(s1::MP.AbstractSubstitution, s2::MP.AbstractSubstitution...) = promote_type(_substype(s1), _substype(s2...))
+_substype(s::MP.Substitutions) = _substype(s...)
+
+function _subsmap(::MP.Eval, vars, s::MP.Substitutions)
+    # Every variable will be replaced by some value of type T
+    vals = Vector{_substype(s)}(undef, length(vars))
+    fillmap!(vals, vars, s...)
+    for i in 1:length(vals)
+        @assert isassigned(vals, i) "Variable $(vars[i]) was not assigned a value"
+    end
+    vals
+end
+function _subsmap(::MP.Subs, vars::Vector{PolyVar{C}}, s::MP.Substitutions) where {C}
+    # Some variable may not be replaced
+    vals = Vector{promote_type(_substype(s), PolyVar{C})}(undef, length(vars))
+    copyto!(vals, vars)
+    fillmap!(vals, vars, s...)
+    vals
+end
+
+subsmap(st, vars, s::MP.Substitutions) = _subsmap(st, vars, s)
+_vec(a::AbstractVector) = a
+_vec(a::Tuple) = [a...]
+function subsmap(st, vars, s::Tuple{MP.VectorMultiSubstitution})
+    if vars === s[1].first || vars == s[1].first # shortcut, === happens when the user do p(variables(p) => ...)
+        _vec(s[1].second)
+    else
+        _subsmap(st, vars, s)
+    end
+end
+
+function monoeval(z::Vector{Int}, vals::AbstractVector)
+    @assert length(z) == length(vals)
+    @assert !isempty(z)
+    val = vals[1]^z[1]
+    for i in 2:length(vals)
+        if z[i] > 0
+            val *= vals[i]^z[i]
+        end
+    end
+    val
+end
+
+_subs(st, ::PolyVar, vals) = monoeval([1], vals::AbstractVector)
+_subs(st, m::Monomial, vals) = monoeval(m.z, vals::AbstractVector)
+_subs(st, t::Term, vals) = t.α * monoeval(t.x.z, vals::AbstractVector)
+function _subs(::MP.Eval, p::Polynomial{C, T}, vals::AbstractVector{S}) where {C, T, S}
+    # I need to check for iszero otherwise I get : ArgumentError: reducing over an empty collection is not allowed
+    if iszero(p)
+        zero(Base.promote_op(*, S, T))
+    else
+        sum(i -> p.a[i] * monoeval(p.x.Z[i], vals), 1:length(p))
+    end
+end
+function _subs(::MP.Subs, p::Polynomial{C, T}, vals::AbstractVector{S}) where {C, T, S}
+    Tout = Base.promote_op(*, T, MP.coefficienttype(S))
+    # I need to check for iszero otherwise I get : ArgumentError: reducing over an empty collection is not allowed
+    if iszero(p)
+        zero(Polynomial{C, Tout})
+    else
+        convert(Polynomial{C, Tout}, sum(i -> p.a[i] * monoeval(p.x.Z[i], vals), 1:length(p)))
+    end
+
+end
+
+function MP.substitute(st::MP.AbstractSubstitutionType, p::PolyType, s::MP.Substitutions)
+    _subs(st, p, subsmap(st, _vars(p), s))
+end
+
+(v::PolyVar)(s::MP.AbstractSubstitution...)    = MP.substitute(MP.Eval(), v, s)
+(m::Monomial)(s::MP.AbstractSubstitution...)   = MP.substitute(MP.Eval(), m, s)
+(t::Term)(s::MP.AbstractSubstitution...)       = MP.substitute(MP.Eval(), t, s)
+(p::Polynomial)(s::MP.AbstractSubstitution...) = MP.substitute(MP.Eval(), p, s)
+
+(p::PolyVar)(x::Number) = x
+(p::Monomial)(x::NTuple{N, <:Number}) where N = MP.substitute(MP.Eval(), p, variables(p)=>x)
+(p::Monomial)(x::AbstractVector{<:Number}) = MP.substitute(MP.Eval(), p, variables(p)=>x)
+(p::Monomial)(x::Number...) = MP.substitute(MP.Eval(), p, variables(p)=>x)
+(p::Term)(x::NTuple{N, <:Number}) where N = MP.substitute(MP.Eval(), p, variables(p)=>x)
+(p::Term)(x::AbstractVector{<:Number}) = MP.substitute(MP.Eval(), p, variables(p)=>x)
+(p::Term)(x::Number...) = MP.substitute(MP.Eval(), p, variables(p)=>x)
+(p::Polynomial)(x::NTuple{N, <:Number}) where N = MP.substitute(MP.Eval(), p, variables(p)=>x)
+(p::Polynomial)(x::AbstractVector{<:Number}) = MP.substitute(MP.Eval(), p, variables(p)=>x)
+(p::Polynomial)(x::Number...) = MP.substitute(MP.Eval(), p, variables(p)=>x)

term.jl

@@ -0,0 +1,52 @@
+export Term
+
+struct Term{C, T} <: AbstractTerm{T}
+    α::T
+    x::Monomial{C}
+end
+
+iscomm(::Type{Term{C, T}}) where {C, T} = C
+
+Base.convert(::Type{Term{C, T}}, t::Term{C, T}) where {C, T} = t
+function Base.convert(::Type{Term{C, T}}, t::Term{C}) where {C, T}
+    return Term{C, T}(T(t.α), t.x)
+end
+Term(t::Term) = t
+
+function Base.convert(::Type{Term{C, T}}, x::Monomial{C}) where {C, T}
+    return Term{C, T}(one(T), x)
+end
+Term{C}(x::Monomial{C}) where C = convert(Term{C, Int}, x)
+Term(x::Monomial{C}) where C = Term{C}(x)
+
+function Base.convert(::Type{Term{C, T}}, x::PolyVar{C}) where {C, T}
+    return convert(Term{C, T}, convert(Monomial{C}, x))
+end
+Term{C}(x::PolyVar{C}) where C = Term{C}(convert(Monomial{C}, x))
+Term(x::PolyVar{C}) where C = Term{C}(x)
+
+function MP.convertconstant(::Type{Term{C, T}}, α) where {C, T}
+    return Term{C}(convert(T, α))
+end
+Term{C}(α::T) where {C, T} = Term{C, T}(α, Monomial{C}())
+
+Base.broadcastable(t::Term) = Ref(t)
+#(::Type{TermContainer{C}}){C}(x::PolyVar{C}) = Term(x)
+#(::Type{TermContainer{C}}){C}(x::Monomial{C}) = Term(x)
+#(::Type{TermContainer{C}}){C}(t::TermContainer{C}) = t
+#TermContainer(x::PolyVar) = Term(x)
+#TermContainer(x::Monomial) = Term(x)
+#TermContainer(t::TermContainer) = t
+
+#Base.convert{C, T}(::Type{TermContainer{C, T}}, x::Union{Monomial{C},PolyVar{C}}) = Term{C, T}(x)
+#Base.convert{C, T}(::Type{TermContainer{C, T}}, α::T) = Term{C, T}(α, Monomial{C}())
+#Base.convert{C, S, T}(::Type{TermContainer{C, T}}, α::S) = TermContainer{C, T}(T(α))
+#(::Type{TermContainer{C}}){C, T}(α::T) = TermContainer{C, T}(α)
+
+#Base.convert{C, T}(::Type{TermContainer{C, T}}, t::Term{C}) = Term{C, T}(t)
+
+Base.copy(t::T) where {T<:Term} = T(copy(t.α), copy(t.x))
+
+MP.coefficient(t::Term) = t.α
+MP.monomial(t::Term) = t.x
+_vars(t) = _vars(t.x)

var.jl

@@ -0,0 +1,101 @@
+export PolyVar, @polyvar, @ncpolyvar
+export polyvecvar
+
+
+function polyarrayvar(::Type{PV}, prefix, indices...) where {PV}
+    map(i -> PV("$(prefix)[$(join(i, ","))]"), Iterators.product(indices...))
+end
+
+function buildpolyvar(::Type{PV}, var) where {PV}
+    if isa(var, Symbol)
+        var, :($(esc(var)) = $PV($"$var"))
+    else
+        isa(var, Expr) || error("Expected $var to be a variable name")
+        Base.Meta.isexpr(var, :ref) || error("Expected $var to be of the form varname[idxset]")
+        (2 ≤ length(var.args)) || error("Expected $var to have at least one index set")
+        varname = var.args[1]
+        prefix = string(varname)
+        varname, :($(esc(varname)) = polyarrayvar($PV, $prefix, $(esc.(var.args[2:end])...)))
+    end
+end
+
+function buildpolyvars(::Type{PV}, args) where {PV}
+    vars = Symbol[]
+    exprs = []
+    for arg in args
+        var, expr = buildpolyvar(PV, arg)
+        push!(vars, var)
+        push!(exprs, expr)
+    end
+    vars, exprs
+end
+
+# Variable vector x returned garanteed to be sorted so that if p is built with x then vars(p) == x
+macro polyvar(args...)
+    vars, exprs = buildpolyvars(PolyVar{true}, args)
+    :($(foldl((x,y) -> :($x; $y), exprs, init=:())); $(Expr(:tuple, esc.(vars)...)))
+end
+
+macro ncpolyvar(args...)
+    vars, exprs = buildpolyvars(PolyVar{false}, args)
+    :($(foldl((x,y) -> :($x; $y), exprs, init=:())); $(Expr(:tuple, esc.(vars)...)))
+end
+
+struct PolyVar{C} <: AbstractVariable
+    id::Int
+    name::String
+
+    function PolyVar{C}(name::AbstractString) where {C}
+        # gensym returns something like Symbol("##42")
+        # we first remove "##" and then parse it into an Int
+        id = parse(Int, string(gensym())[3:end])
+        new(id, convert(String, name))
+    end
+end
+
+Base.hash(x::PolyVar, u::UInt) = hash(x.id, u)
+Base.broadcastable(x::PolyVar) = Ref(x)
+
+MP.name(v::PolyVar) = v.name
+function MP.name_base_indices(v::PolyVar)
+    splits = split(v.name, r"[\[,\]]\s*", keepempty=false)
+    if length(splits) == 1
+        return v.name, Int[]
+    else
+        return splits[1], parse.(Int, splits[2:end])
+    end
+end
+
+MP.monomial(v::PolyVar) = Monomial(v)
+_vars(v::PolyVar) = [v]
+
+iscomm(::Type{PolyVar{C}}) where {C} = C
+
+function mergevars(varsvec::Vector{Vector{PV}}) where {PV<:PolyVar}
+    n = length(varsvec)
+    is = ones(Int, n)
+    maps = zeros.(Int, length.(varsvec))
+    nonempty = BitSet(findall(!isempty, varsvec))
+    vars = Vector{PV}()
+    while !isempty(nonempty)
+        imin = 0
+        for i in nonempty
+            if imin == 0 || varsvec[i][is[i]] > varsvec[imin][is[imin]]
+                imin = i
+            end
+        end
+        var = varsvec[imin][is[imin]]
+        push!(vars, var)
+        for i in nonempty
+            if var == varsvec[i][is[i]]
+                maps[i][is[i]] = length(vars)
+                if is[i] == length(varsvec[i])
+                    pop!(nonempty, i)
+                else
+                    is[i] += 1
+                end
+            end
+        end
+    end
+    vars, maps
+end