Add division with remainder

Author: blegat

src/MultivariatePolynomials.jl

@@ -32,6 +32,8 @@ include("subs.jl")
 include("algebraicset.jl")
 include("norm.jl")
 
+include("div.jl")
+
 include("show.jl")
 
 end # module

src/calg.jl

@@ -4,21 +4,7 @@
 # Any op T # ambig with Polytype op Any
 # PolyType op T # breaks ambig
 
-import Base.(^), Base.dot, Base.(.+), Base.(.-), Base.(.*), Base.(./), Base.(.^)
-
-(.+)(p::PolyType, α) = p+α
-(.+)(α, p::PolyType) = α+p
-(.+)(p::PolyType, q::PolyType) = p+q
-(.-)(p::PolyType, α) = p-α
-(.-)(α, p::PolyType) = α-p
-(.-)(p::PolyType, q::PolyType) = p-q
-(.*)(p::PolyType, α) = p*α
-(.*)(α, p::PolyType) = α*p
-(.*)(p::PolyType, q::PolyType) = p*q
-(./)(p::PolyType, α) = p/α
-(./)(α, p::PolyType) = α/p
-(./)(p::PolyType, q::PolyType) = p/q
-(.^)(p::PolyType, i::Int) = p^i
+import Base.(^), Base.dot
 
 import Base.transpose
 Base.transpose(p::PolyType) = p
@@ -55,28 +41,28 @@ function (*)(x::PolyVar{true}, y::MonomialVector{true})
     w, updatez = multiplyvar(y.vars, x)
     MonomialVector{true}(w, updatez.(y.Z))
 end
-function multiplymono(v::Vector{PolyVar{true}}, x::Monomial{true})
+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 -> z + x.z
+        updatez = z -> op(z, x.z)
     else
         w, maps = myunion([v, x.vars])
         updatez = z -> begin
             newz = zeros(Int, length(w))
-            newz[maps[1]] += z
-            newz[maps[2]] += x.z
+            newz[maps[1]] = op(newz[maps[1]], z)
+            newz[maps[2]] = op(newz[maps[2]], x.z)
             newz
         end
     end
     w, updatez
 end
 function (*)(x::Monomial{true}, y::Monomial{true})
-    w, updatez = multiplymono(y.vars, x)
+    w, updatez = multdivmono(y.vars, x, +)
     Monomial{true}(w, updatez(y.z))
 end
 function (*)(x::Monomial{true}, y::MonomialVector{true})
-    w, updatez = multiplymono(y.vars, x)
+    w, updatez = multdivmono(y.vars, x, +)
     MonomialVector{true}(w, updatez.(y.Z))
 end
 (*)(x::Monomial{true}, y::PolyVar{true}) = y * x

src/div.jl

@@ -0,0 +1,40 @@
+# _div(a, b) assumes that b divides a
+function _div(m1::Monomial{true}, m2::Monomial{true})
+    w, updatez = multdivmono(m1.vars, m2, -)
+    Monomial{true}(w, updatez(m1.z))
+end
+function _div(t::Term, m::Monomial)
+    t1.α * _div(monomial(t), m)
+end
+function _div(t1::Term, t2::Term)
+    (t1.α / t2.α) * _div(monomial(t1), monomial(t2))
+end
+
+proddiff(x, y) = x*y - x*y
+
+function Base.divrem{C, T, S}(f::Polynomial{C, T}, g::Polynomial{C, S})
+    rf = Polynomial{C, promote_op(proddiff, T, S)}(f)
+    q = r = zero(f - g / 2)
+    lt = leadingterm(g)
+    rg = removeleadingterm(g)
+    lm = monomial(lt)
+    while !iszero(rf)
+        ltf = leadingterm(rf)
+        if divides(lm, ltf)
+            qt = _div(ltf, lt)
+            q += qt
+            rf = removeleadingterm(rf) - qt * rg
+        elseif lm > monomial(ltf)
+            # Since the monomials are sorted in decreasing order,
+            # lm is larger than all of them hence it cannot divide any of them
+            r += rf
+            break
+        else
+            r += ltf
+            rf = removeleadingterm(rf)
+        end
+    end
+    q, r
+end
+Base.div(f::PolyType, g::PolyType) = divrem(f, g)[1]
+Base.rem(f::PolyType, g::PolyType) = divrem(f, g)[2]

src/measure.jl

@@ -10,7 +10,7 @@ type Measure{C, T}
     a::Vector{T}
     x::MonomialVector{C}
 
-    function Measure(a::Vector{T}, x::MonomialVector{C})
+    function Measure{C, T}(a::Vector{T}, x::MonomialVector{C}) where {C, T}
         if length(a) != length(x)
             error("There should be as many coefficient than monomials")
         end

src/mono.jl

@@ -30,7 +30,7 @@ end
 immutable PolyVar{C} <: PolyType{C}
     id::Int
     name::AbstractString
-    function PolyVar(name::AbstractString)
+    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])
@@ -84,7 +84,7 @@ type Monomial{C} <: PolyType{C}
     vars::Vector{PolyVar{C}}
     z::Vector{Int}
 
-    function Monomial(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
@@ -122,12 +122,35 @@ isconstant(x::Monomial) = deg(x) == 0
 zero{C}(::Type{Monomial{C}}) = zero(PolyType{C})
 one{C}(::Type{Monomial{C}}) = one(PolyType{C})
 
+monomial(m::Monomial) = m
+# Does m1 divides m2 ?
+function 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
+
 # Invariant: Always sorted and no zero vector
 type MonomialVector{C} <: PolyType{C}
     vars::Vector{PolyVar{C}}
     Z::Vector{Vector{Int}}
 
-    function MonomialVector(vars::Vector{PolyVar{C}}, Z::Vector{Vector{Int}})
+    function MonomialVector{C}(vars::Vector{PolyVar{C}}, Z::Vector{Vector{Int}}) where {C}
         for z in Z
             if length(vars) != length(z)
                 throw(ArgumentError("There should be as many vars than exponents"))
@@ -166,11 +189,12 @@ function getindex{MV<:MonomialVector}(x::MV, I)
     MV(x.vars, x.Z[sort(I)])
 end
 
-length(x::MonomialVector) = length(x.Z)
-isempty(x::MonomialVector) = length(x) == 0
-start(::MonomialVector) = 1
-done(x::MonomialVector, state) = length(x) < state
-next(x::MonomialVector, state) = (x[state], state+1)
+Base.endof(x::MonomialVector) = length(x)
+Base.length(x::MonomialVector) = length(x.Z)
+Base.isempty(x::MonomialVector) = length(x) == 0
+Base.start(::MonomialVector) = 1
+Base.done(x::MonomialVector, state) = length(x) < state
+Base.next(x::MonomialVector, state) = (x[state], state+1)
 
 extdeg(x::MonomialVector) = extrema(sum.(x.Z))
 mindeg(x::MonomialVector) = minimum(sum.(x.Z))
@@ -289,7 +313,7 @@ function sortmonovec{C, T<:Union{PolyType,Int}}(::Type{PolyVar{C}}, X::Vector{T}
         σ, MonomialVector{C}(allvars, Z[σ])
     end
 end
-typealias VectorOfPolyType{C} Union{PolyType{C},Int}
+VectorOfPolyType{C} = Union{PolyType{C},Int}
 sortmonovec{T<:VectorOfPolyType{false}}(x::Vector{T}) = sortmonovec(PolyVar{false}, x)
 sortmonovec{T<:VectorOfPolyType{true}}(x::Vector{T}) = sortmonovec(PolyVar{true}, x)
 function (::Type{MonomialVector{C}}){C}(X::Vector)

src/poly.jl

@@ -1,4 +1,7 @@
-export Term, Polynomial, MatPolynomial, SOSDecomposition, TermType, getmat, monomials, removemonomials
+export Term, Polynomial, MatPolynomial, SOSDecomposition, TermType
+export monomial, monomials, removeleadingterm, removemonomials
+export leadingcoef, leadingmonomial, leadingterm
+export getmat, divides
 
 @compat abstract type TermType{C, T} <: PolyType{C} end
 eltype{C, T}(::Type{TermType{C, T}}) = T
@@ -65,6 +68,9 @@ done(::Term, state) = state
 next(t::Term, state) = (t, true)
 getindex(t::Term, I::Int) = t
 
+monomial(t::Term) = t.x
+divides(t1::Union{Term, Monomial}, t2::Union{Term, Monomial}) = divides(monomial(t1), monomial(t2))
+
 # Invariant:
 # a and x might be empty: meaning it is the zero polynomial
 # a does not contain any zeros
@@ -73,9 +79,8 @@ type Polynomial{C, T} <: TermContainer{C, T}
     a::Vector{T}
     x::MonomialVector{C}
 
-    function Polynomial(a::Vector{T}, x::MonomialVector{C})
-        if length(a) != length(x)
-            throw(ArgumentError("There should be as many coefficient than monomials"))
+    function Polynomial{C, T}(a::Vector{T}, x::MonomialVector{C}) where {C, T}
+        if length(a) != length(x) throw(ArgumentError("There should be as many coefficient than monomials"))
         end
         zeroidx = Int[]
         for (i,α) in enumerate(a)
@@ -90,7 +95,7 @@ type Polynomial{C, T} <: TermContainer{C, T}
             a = a[nzidx]
             x = x[nzidx]
         end
-        new(a, x)
+        new{C, T}(a, x)
     end
 end
 iscomm{C, T}(::Type{Polynomial{C, T}}) = C
@@ -172,18 +177,26 @@ end
 vars(p::Polynomial) = vars(p.x)
 nvars(p::Polynomial) = nvars(p.x)
 
-length(p::Polynomial) = length(p.a)
-isempty(p::Polynomial) = isempty(p.a)
-start(::Polynomial) = 1
-done(p::Polynomial, state) = length(p) < state
-next(p::Polynomial, state) = (p[state], state+1)
+Base.endof(p::Polynomial) = length(p)
+Base.length(p::Polynomial) = length(p.a)
+Base.isempty(p::Polynomial) = isempty(p.a)
+Base.start(::Polynomial) = 1
+Base.done(p::Polynomial, state) = length(p) < state
+Base.next(p::Polynomial, state) = (p[state], state+1)
 
 extdeg(p::Polynomial) = extdeg(p.x)
 mindeg(p::Polynomial) = mindeg(p.x)
 maxdeg(p::Polynomial) = maxdeg(p.x)
 
+leadingcoef(p::Polynomial) = first(p.a)
+leadingmonomial(p::Polynomial) = first(p.x)
+leadingterm(p::Polynomial) = first(p)
+
 monomials(p::Polynomial) = p.x
 
+function removeleadingterm(p::Polynomial)
+    Polynomial(p.a[2:end], p.x[2:end])
+end
 function removemonomials(p::Polynomial, x::MonomialVector)
     # use the fact that monomials are sorted to do this O(n) instead of O(n^2)
     j = 1
@@ -347,14 +360,14 @@ TermContainer(p::MatPolynomial) = Polynomial(p)
 
 type SOSDecomposition{C, T} <: TermType{C, T}
     ps::Vector{Polynomial{C, T}}
-    function SOSDecomposition(ps::Vector{Polynomial{C, T}})
+    function SOSDecomposition{C, T}(ps::Vector{Polynomial{C, T}}) where {C, T}
         new(ps)
     end
 end
-function (::Type{SOSDecomposition{C, T}}){C, T}(ps::Vector)
+function SOSDecomposition{C, T}(ps::Vector) where {C, T}
     SOSDecomposition(Vector{Polynomial{C, T}}(ps))
 end
-function (::Type{SOSDecomposition{C}}){C}(ps::Vector)
+function SOSDecomposition{C}(ps::Vector) where {C}
     T = reduce(promote_type, Int, map(eltype, ps))
     SOSDecomposition{C, T}(ps)
 end

test/div.jl

@@ -0,0 +1,27 @@
+@testset "Division" begin
+    # Taken from
+    # Ideals, Varieties, and Algorithms
+    # Cox, Little and O'Shea, Fourth edition
+    # They have been adapted to the grlex ordering
+    @testset "Divides" begin
+        @polyvar x y z
+        @test divides(x*y, x^2*y)
+        @test divides(x*y, x*y^2)
+        @test divides(y*z, x*y*z)
+        @test !divides(y*z, x*z)
+        @test !divides(x^2*y, x*y^2)
+    end
+    @testset "Leading function" begin
+        @polyvar x y z
+        # See page 60
+        p = 4x*y^2*z + 4z^2 + 7x^2*z^2 - 5x^3
+        @test leadingcoef(p) == 7
+        @test leadingmonomial(p) == x^2*z^2
+        @test leadingterm(p) == 7x^2*z^2
+    end
+    @testset "Division examples" begin
+        @polyvar x y
+        @test div(x*y^2 + 1, x*y + 1) == y
+        @test rem(x*y^2 + 1, x*y + 1) == -y + 1
+    end
+end

test/runtests.jl

@@ -17,6 +17,7 @@ include("subs.jl")
 include("algebraicset.jl")
 include("norm.jl")
 include("hash.jl")
+include("div.jl")
 
 include("show.jl")