Merge pull request #11 from JuliaAlgebra/fix-0.7

Fixes for Julia v0.7

Author: blegat

.travis.yml

@@ -11,6 +11,11 @@ notifications:
 matrix:
   allow_failures:
     - julia: nightly
+
+before_script:
+  - julia -e 'Pkg.add("MultivariatePolynomials")'
+  - julia -e 'Pkg.checkout("MultivariatePolynomials", "bl/fix-0.7bis")'
+
 after_success:
   # push coverage results to Coveralls
   - julia -e 'cd(Pkg.dir("DynamicPolynomials")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(Coveralls.process_folder())'

REQUIRE

@@ -1,3 +1,4 @@
 julia 0.6
 MultivariatePolynomials 0.1.0
 Nullables
+Compat 0.49

src/DynamicPolynomials.jl

@@ -2,7 +2,9 @@ __precompile__()
 
 module DynamicPolynomials
 
-import Base: length, getindex, vect, isless, isempty, start, done, next, convert, dot, copy, eltype, zero, one, *, +, -
+import Base: length, getindex, vect, isless, isempty, start, done, next, zero, one, *, +, -
+
+using Compat
 
 using MultivariatePolynomials
 const MP = MultivariatePolynomials

src/comp.jl

@@ -135,7 +135,7 @@ function grlex(x::Vector{Int}, y::Vector{Int})
     end
 end
 
-function Base.isapprox(p::Polynomial{C, S}, q::Polynomial{C, T}; rtol::Real=Base.rtoldefault(S, T), atol::Real=0, ztol::Real=Base.rtoldefault(S, T)) where {C, S, T}
+function Base.isapprox(p::Polynomial{C, S}, q::Polynomial{C, T}; rtol::Real=Base.rtoldefault(S, T, 0), atol::Real=0, ztol::Real=Base.rtoldefault(S, T, 0)) 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])

src/diff.jl

@@ -1,5 +1,5 @@
 function MP.differentiate(m::Monomial{C}, x::PolyVar{C}) where C
-    i = findfirst(_vars(m), x)
+    i = findfirst(equalto(x), _vars(m))
     if (i == nothing || i == 0) || m.z[i] == 0
         zeroterm(m)
     else
@@ -11,14 +11,14 @@ end
 
 function MP.differentiate(p::Polynomial{C, T}, x::PolyVar{C}) where {C, T}
     # grlex order preserved
-    i = findfirst(_vars(p), x)
+    i = findfirst(equalto(x), _vars(p))
     S = Base.promote_op(*, T, Int)
-    if i == nothing || i == 0
+    if i === nothing || i == 0
         zero(Polynomial{C, S})
     else
-        keep = find([z[i] > 0 for z in p.x.Z])
-        Z = [copy(p.x.Z[i]) for i in keep]
-        a = Vector{S}(length(keep))
+        keep = findall(z -> z[i] > 0, p.x.Z)
+        Z = copy.(p.x.Z[keep])
+        a = Vector{S}(uninitialized, length(keep))
         for j in 1:length(Z)
             a[j] = p.a[keep[j]] * Z[j][i]
             Z[j][i] -= 1

src/mono.jl

@@ -19,13 +19,13 @@ 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[])
+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)
-Monomial(x::PolyVar{C}) where {C} = Monomial{C}(x)
+Monomial{C}(x::PolyVar{C}) where C = Monomial{C}([x], [1])
+Monomial(x::PolyVar{C}) where C = Monomial{C}(x)
 
 Base.copy(m::M) where {M<:Monomial} = M(m.vars, copy(m.z))
-Base.convert(::Type{Monomial{C}}, x::PolyVar{C}) where C = Monomial{C}([x], [1])
 
 # Generate canonical reperesentation by removing variables that are not used
 function canonical(m::Monomial)

src/monovec.jl

@@ -182,7 +182,7 @@ function _sortmonovec(X::DMonoVec{C}) where {C}
     allvars, Z, σ
 end
 function _removedups!(Z::Vector{Vector{Int}}, σ::Vector{Int})
-    dups = find(i -> Z[σ[i]] == Z[σ[i-1]], 2:length(σ))
+    dups = findall(i -> Z[σ[i]] == Z[σ[i-1]], 2:length(σ))
     deleteat!(σ, dups)
 end
 function MP.sortmonovec(X::DMonoVec{C}) where {C}
@@ -198,7 +198,7 @@ end
 function MonomialVector{C}(X::DMonoVec{C}) where C
     allvars, Z = buildZvarsvec(PolyVar{C}, X)
     sort!(Z, rev=true, lt=grlex)
-    dups = find(i -> Z[i] == Z[i-1], 2:length(Z))
+    dups = findall(i -> Z[i] == Z[i-1], 2:length(Z))
     deleteat!(Z, dups)
     MonomialVector{C}(allvars, Z)
 end

src/mult.jl

@@ -11,13 +11,13 @@ 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}}(n+1)
+    K = J.+1
+    w = Vector{PolyVar{C}}(uninitialized, n+1)
     w[I] = v[I]
     w[i] = x
     w[K] = v[J]
     updatez = z -> begin
-        newz = Vector{Int}(n+1)
+        newz = Vector{Int}(uninitialized, n+1)
         newz[I] = z[I]
         newz[i] = 1
         newz[K] = z[J]
@@ -79,8 +79,8 @@ function *(p::Polynomial{C, S}, q::Polynomial{C, T}) where {C, S, T}
             allvars, maps = mergevars([_vars(p), _vars(q)])
         end
         N = length(p)*length(q)
-        Z = Vector{Vector{Int}}(N)
-        a = Vector{U}(N)
+        Z = Vector{Vector{Int}}(uninitialized, N)
+        a = Vector{U}(uninitialized, N)
         i = 0
         for u in p
             for v in q

src/poly.jl

@@ -9,8 +9,7 @@ struct Polynomial{C, T} <: AbstractPolynomial{T}
     x::MonomialVector{C}
 
     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
+        length(a) == length(x) || throw(ArgumentError("There should be as many coefficient than monomials"))
         zeroidx = Int[]
         for (i,α) in enumerate(a)
             if iszero(α)
@@ -20,7 +19,7 @@ struct Polynomial{C, T} <: AbstractPolynomial{T}
         if !isempty(zeroidx)
             isnz = ones(Bool, length(a))
             isnz[zeroidx] = false
-            nzidx = find(isnz)
+            nzidx = findall(isnz)
             a = a[nzidx]
             x = x[nzidx]
         end
@@ -41,18 +40,19 @@ Polynomial{C, T}(a::AbstractVector, X::DMonoVec) where {C, T} = Polynomial{C, T}
 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)
 
-Polynomial{C}(α) where {C} = Polynomial(Term{C}(α))
-Polynomial(x::Union{PolyVar{C}, Monomial{C}}) where {C} = Polynomial(Term{C}(x))
+Polynomial{C, T}(p::Polynomial{C, T}) where {C, T} = p
+Polynomial{C, T}(p::Polynomial{C, S}) where {C, S, T} = Polynomial{C}(Vector{T}(p.a), p.x)
+Polynomial{C, T}(p::AbstractPolynomialLike) where {C, T} = Polynomial{C, T}(polynomial(p, T))
+Polynomial{C, T}(t::Term{C}) where {C, T} = Polynomial{C, T}([T(t.α)], [t.x])
+Polynomial{C, T}(m::DMonomialLike{C}) where {C, T} = Polynomial(Term{C, T}(m))
+Polynomial{C, T}(α) where {C, T} = Polynomial(Term{C, T}(α))
+
 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])
-Base.convert(::Type{Polynomial{C, T}}, α) where {C, T} = Polynomial(Term{C, T}(α))
-Base.convert(::Type{Polynomial{C, T}}, m::DMonomialLike{C}) where {C, T} = Polynomial(Term{C, T}(m))
-Base.convert(::Type{Polynomial{C, T}}, t::Term{C}) where {C, T} = Polynomial{C, T}([T(t.α)], [t.x])
-Base.convert(::Type{Polynomial{C, T}}, p::Polynomial{C, T}) where {C, T} = p
-Base.convert(::Type{Polynomial{C, T}}, p::Polynomial{C, S}) where {C, S, T} = Polynomial{C}(Vector{T}(p.a), p.x)
-Base.convert(::Type{Polynomial{C, T}}, p::AbstractPolynomialLike) where {C, T} = Polynomial{C, T}(polynomial(p, T))
+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)
 
@@ -168,8 +168,8 @@ function MP.polynomial(Q::AbstractMatrix, mv::MonomialVector{C}, ::Type{T}) wher
         n = length(mv)
         if C
             N = trimap(n, n, n)
-            Z = Vector{Vector{Int}}(N)
-            a = Vector{T}(N)
+            Z = Vector{Vector{Int}}(uninitialized, N)
+            a = Vector{T}(uninitialized, N)
             for i in 1:n
                 for j in i:n
                     k = trimap(i, j, n)
@@ -184,8 +184,8 @@ function MP.polynomial(Q::AbstractMatrix, mv::MonomialVector{C}, ::Type{T}) wher
             v = _vars(mv)
         else
             N = n^2
-            x = Vector{Monomial{C}}(N)
-            a = Vector{T}(N)
+            x = Vector{Monomial{C}}(uninitialized, N)
+            a = Vector{T}(uninitialized, N)
             offset = 0
             for i in 1:n
                 # for j in 1:n wouldn't be cache friendly for Q

src/subs.jl

@@ -1,5 +1,5 @@
 function fillmap!(vals, vars, s::MP.Substitution)
-    j = findfirst(vars, s.first)
+    j = findfirst(equalto(s.first), vars)
     # 0.6 behaviour:
     # If j == 0, that means that the variable is not present
     # so it is ignored
@@ -28,7 +28,7 @@ _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)}(length(vars))
+    vals = Vector{_substype(s)}(uninitialized, length(vars))
     fillmap!(vals, vars, s...)
     for i in 1:length(vals)
         @assert isassigned(vals, i) "Variable $(vars[i]) was not assigned a value"
@@ -37,8 +37,8 @@ function _subsmap(::MP.Eval, vars, s::MP.Substitutions)
 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})}(length(vars))
-    copy!(vals, vars)
+    vals = Vector{promote_type(_substype(s), PolyVar{C})}(uninitialized, length(vars))
+    copyto!(vals, vars)
     fillmap!(vals, vars, s...)
     vals
 end