Merge pull request #22 from JuliaAlgebra/bl/stopbaseimport

stop importing base methods

Author: blegat

src/DynamicPolynomials.jl

@@ -2,8 +2,6 @@ __precompile__()
 
 module DynamicPolynomials
 
-import Base: length, getindex, vect, isless, isempty, start, done, next, zero, one, *, +, -
-
 using Compat
 
 using MultivariatePolynomials
@@ -13,8 +11,8 @@ using Nullables
 
 #const PolyType{C} = Union{DMonomialLike{C}, RationalPoly{C}}
 #iscomm(::PolyType{C}) where {C} = C
-#zero(p::PolyType{C}) where {C} = zero(typeof(p))
-#one(p::PolyType{C}) where {C} = one(typeof(p))
+#Base.zero(p::PolyType{C}) where {C} = zero(typeof(p))
+#Base.one(p::PolyType{C}) where {C} = one(typeof(p))
 
 include("var.jl")
 include("mono.jl")

src/cmult.jl

@@ -1,5 +1,5 @@
 # Product between PolyVar and Monomial -> Monomial
-function (*)(x::PolyVar{true}, y::PolyVar{true})
+function Base.:(*)(x::PolyVar{true}, y::PolyVar{true})
     if x === y
         Monomial{true}([x], [2])
     else
@@ -14,12 +14,12 @@ function multiplyvar(v::Vector{PolyVar{true}}, x::PolyVar{true})
         insertvar(v, x, (i == nothing || i == 0) ? length(v)+1 : i)
     end
 end
-function (*)(x::PolyVar{true}, y::Monomial{true})
+function Base.:(*)(x::PolyVar{true}, y::Monomial{true})
     w, updatez = multiplyvar(y.vars, x)
     Monomial{true}(w, updatez(y.z))
 end
-(*)(y::MonomialVector{true}, x::PolyVar{true}) = x * y
-function (*)(x::PolyVar{true}, y::MonomialVector{true})
+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
@@ -57,9 +57,9 @@ 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 (*)(x::Monomial{true}, y::MonomialVector{true})
+function Base.:(*)(x::Monomial{true}, y::MonomialVector{true})
     w, updatez = multdivmono(y.vars, x, +)
     MonomialVector{true}(w, updatez.(y.Z))
 end
-(*)(y::MonomialVector{true}, x::Monomial{true}) = x * y
-(*)(x::Monomial{true}, y::PolyVar{true}) = y * x
+Base.:(*)(y::MonomialVector{true}, x::Monomial{true}) = x * y
+Base.:(*)(x::Monomial{true}, y::PolyVar{true}) = y * x

src/mult.jl

@@ -33,16 +33,16 @@ 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 *(x::DMonomialLike, p::Polynomial)
+function Base.:(*)(x::DMonomialLike, p::Polynomial)
     # /!\ No copy of a is done
     Polynomial(p.a, x*p.x)
 end
-function *(x::DMonomialLike{false}, p::Polynomial)
+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 *(p::Polynomial, x::DMonomialLike)
+function Base.:(*)(p::Polynomial, x::DMonomialLike)
     # /!\ No copy of a is done
     Polynomial(p.a, p.x*x)
 end
@@ -64,10 +64,10 @@ function _term_poly_mult(t::Term{C, S}, p::Polynomial{C, T}, op::Function) where
         Polynomial(op.(t.α, p.a), MonomialVector(allvars, Z))
     end
 end
-*(p::Polynomial, t::Term) = _term_poly_mult(t, p, (α, β) -> β * α)
-*(t::Term, p::Polynomial) = _term_poly_mult(t, p, *)
+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 *(p::Polynomial{C, S}, q::Polynomial{C, T}) where {C, S, T}
+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})

src/ncmult.jl

@@ -1,4 +1,4 @@
-function (*)(x::PolyVar{false}, y::PolyVar{false})
+function Base.:(*)(x::PolyVar{false}, y::PolyVar{false})
     if x === y
         Monomial{false}([x], [2])
     else
@@ -85,16 +85,16 @@ function multiplyvar(x::PolyVar{false}, v::Vector{PolyVar{false}}, z::Vector{Int
         end
     end
 end
-function (*)(x::PolyVar{false}, y::Monomial{false})
+function Base.:(*)(x::PolyVar{false}, y::Monomial{false})
     w, updatez = multiplyvar(x, y.vars, y.z)
     Monomial{false}(w, updatez(y.z))
 end
-function (*)(y::Monomial{false}, x::PolyVar{false})
+function Base.:(*)(y::Monomial{false}, x::PolyVar{false})
     w, updatez = multiplyvar(y.vars, y.z, x)
     Monomial{false}(w, updatez(y.z))
 end
 
-function (*)(x::Monomial{false}, y::Monomial{false})
+function Base.:(*)(x::Monomial{false}, y::Monomial{false})
     i = findlast(z -> z > 0, x.z)
     if i == nothing || i == 0
         return y
@@ -113,10 +113,10 @@ function (*)(x::Monomial{false}, y::Monomial{false})
     return Monomial{false}(w, z)
 end
 
-function (*)(y::MonomialVector{false}, x::DMonomialLike{false})
+function Base.:(*)(y::MonomialVector{false}, x::DMonomialLike{false})
     MonomialVector{false}([yi * x for yi in y])
 end
-function (*)(x::DMonomialLike{false}, y::MonomialVector{false})
+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])

src/operators.jl

@@ -1,21 +1,19 @@
-import Base.(^), Base.(+)
-
 # 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
-^(x::PolyVar{C}, i::Int) where {C} = Monomial{C}([x], [i])
-^(x::Monomial{true}, i::Int) = Monomial{true}(x.vars, i*x.z)
+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
 
-(+)(x::DMonomialLike, y::DMonomialLike) = Term(x) + Term(y)
-(-)(x::DMonomialLike, y::DMonomialLike) = Term(x) - Term(y)
+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
@@ -55,14 +53,14 @@ function plusorminus(p::TermPoly{C, S}, q::TermPoly{C, T}, op) where {C, S, T}
 end
 
 
-(+)(x::TermPoly{C}, y::TermPoly{C}) where C = plusorminus(x, y, +)
-(-)(x::TermPoly{C}, y::TermPoly{C}) where C = plusorminus(x, y, -)
-(+)(x::TermPoly{C, T}, y::Union{Monomial,PolyVar}) where {C, T} = x + Term{C, T}(y)
-(+)(x::Union{Monomial,PolyVar}, y::TermPoly{C, T}) where {C, T} = Term{C, T}(x) + y
+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, T}, y::Union{Monomial,PolyVar}) where {C, T} = x + Term{C, T}(y)
+Base.:(+)(x::Union{Monomial,PolyVar}, y::TermPoly{C, T}) where {C, T} = Term{C, T}(x) + y
 
-(-)(x::TermPoly{T}, y::DMonomialLike) where T = x - Term{T}(y)
-(-)(x::DMonomialLike, y::TermPoly{T}) where T = Term{T}(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
 
-(-)(p::Polynomial) = Polynomial(-p.a, p.x)
+Base.:(-)(p::Polynomial) = Polynomial(-p.a, p.x)
 
 include("mult.jl")