Merge pull request #80 from JuliaAlgebra/bl/import

Stop importing Base functions

Author: blegat

src/MultivariatePolynomials.jl

@@ -4,9 +4,6 @@ module MultivariatePolynomials
 
 #using DocStringExtensions
 
-import Base: *, +, -, /, ^, ==,
-    promote_rule, convert, show, isless, size, getindex,
-    one, zero, isapprox, @pure, copy
 using Compat
 import Compat.LinearAlgebra: dot, norm
 

src/comparison.jl

@@ -7,14 +7,14 @@ Base.iszero(t::AbstractPolynomial) = iszero(nterms(t))
 
 # See https://github.com/blegat/MultivariatePolynomials.jl/issues/22
 # avoids the call to be transfered to eqconstant
-(==)(α::Nothing, x::APL) = false
-(==)(x::APL, α::Nothing) = false
-(==)(α::Dict, x::APL) = false
-(==)(x::APL, α::Dict) = false
-(==)(α::Nothing, x::RationalPoly) = false
-(==)(x::RationalPoly, α::Nothing) = false
-(==)(α::Dict, x::RationalPoly) = false
-(==)(x::RationalPoly, α::Dict) = false
+Base.:(==)(α::Nothing, x::APL) = false
+Base.:(==)(x::APL, α::Nothing) = false
+Base.:(==)(α::Dict, x::APL) = false
+Base.:(==)(x::APL, α::Dict) = false
+Base.:(==)(α::Nothing, x::RationalPoly) = false
+Base.:(==)(x::RationalPoly, α::Nothing) = false
+Base.:(==)(α::Dict, x::RationalPoly) = false
+Base.:(==)(x::RationalPoly, α::Dict) = false
 
 function polyeqterm(p::AbstractPolynomial, t)
     if iszero(p)
@@ -40,7 +40,7 @@ eqconstant(t::AbstractTermLike, α) = _termeqconstant(t, α)
 eqconstant(α, p::APL) = polyeqterm(p, α)
 eqconstant(p::APL, α) = polyeqterm(p, α)
 
-function (==)(t1::AbstractTerm, t2::AbstractTerm)
+function Base.:(==)(t1::AbstractTerm, t2::AbstractTerm)
     c1 = coefficient(t1)
     c2 = coefficient(t2)
     if iszero(c1)
@@ -49,8 +49,8 @@ function (==)(t1::AbstractTerm, t2::AbstractTerm)
         c1 == c2 && monomial(t1) == monomial(t2)
     end
 end
-(==)(p::AbstractPolynomial, t::AbstractTerm) = polyeqterm(p, t)
-(==)(t::AbstractTerm, p::AbstractPolynomial) = polyeqterm(p, t)
+Base.:(==)(p::AbstractPolynomial, t::AbstractTerm) = polyeqterm(p, t)
+Base.:(==)(t::AbstractTerm, p::AbstractPolynomial) = polyeqterm(p, t)
 
 function compare_terms(p1::AbstractPolynomial, p2::AbstractPolynomial, isz, op)
     i1 = 1
@@ -89,14 +89,14 @@ end
 #    end
 #    return true
 #end
-(==)(p1::AbstractPolynomial, p2::AbstractPolynomial) = compare_terms(p1, p2, iszero, ==)
+Base.:(==)(p1::AbstractPolynomial, p2::AbstractPolynomial) = compare_terms(p1, p2, iszero, ==)
 
-(==)(p::RationalPoly, q::RationalPoly) = p.num*q.den == q.num*p.den
+Base.:(==)(p::RationalPoly, q::RationalPoly) = p.num*q.den == q.num*p.den
 # Solve ambiguity with (::PolyType, ::Any)
-(==)(p::APL, q::RationalPoly) = p*q.den == q.num
-(==)(q::RationalPoly, p::APL) = p == q
-(==)(α, q::RationalPoly) = α*q.den == q.num
-(==)(q::RationalPoly, α) = α == q
+Base.:(==)(p::APL, q::RationalPoly) = p*q.den == q.num
+Base.:(==)(q::RationalPoly, p::APL) = p == q
+Base.:(==)(α, q::RationalPoly) = α*q.den == q.num
+Base.:(==)(q::RationalPoly, α) = α == q
 
 # α could be a JuMP affine expression
 isapproxzero(α; ztol::Real=0.) = false

src/conversion.jl

@@ -1,8 +1,8 @@
 export variable
 
 convertconstant(::Type{P}, α) where P<:APL = P(α)
-convert(::Type{P}, α) where P<:APL = convertconstant(P, α)
-convert(::Type{P}, p::APL) where P<:AbstractPolynomial = P(polynomial(p))
+Base.convert(::Type{P}, α) where P<:APL = convertconstant(P, α)
+Base.convert(::Type{P}, p::APL) where P<:AbstractPolynomial = P(polynomial(p))
 
 Base.convert(::Type{Any}, p::APL) = p
 # Conversion polynomial -> scalar

src/differentiation.jl

@@ -1,4 +1,3 @@
-# I do not use it but I import the function to add a method
 export differentiate
 
 """
@@ -104,4 +103,4 @@ else
             differentiate(differentiate(p, x), x, Val{N - 1}())
         end
     end
-end
+end

src/operators.jl

@@ -1,9 +1,9 @@
 # We reverse the order of comparisons here so that the result
 # of x < y is equal to the result of Monomial(x) < Monomial(y)
-@pure isless(v1::AbstractVariable, v2::AbstractVariable) = name(v1) > name(v2)
-isless(m1::AbstractTermLike, m2::AbstractTermLike) = isless(promote(m1, m2)...)
+Base.@pure Base.isless(v1::AbstractVariable, v2::AbstractVariable) = name(v1) > name(v2)
+Base.isless(m1::AbstractTermLike, m2::AbstractTermLike) = isless(promote(m1, m2)...)
 
-function isless(t1::AbstractTerm, t2::AbstractTerm)
+function Base.isless(t1::AbstractTerm, t2::AbstractTerm)
     if monomial(t1) < monomial(t2)
         true
     elseif monomial(t1) == monomial(t2)
@@ -18,22 +18,22 @@ end
 # is a polynomial of JuMP affine expression but if we promote it would be a
 # polynomial of quadratic expression
 for op in [:+, :-, :(==)]
-    @eval $op(p1::APL, p2::APL) = $op(promote(p1, p2)...)
+    @eval Base.$op(p1::APL, p2::APL) = $op(promote(p1, p2)...)
 end
-isapprox(p1::APL, p2::APL; kwargs...) = isapprox(promote(p1, p2)...; kwargs...)
+Base.isapprox(p1::APL, p2::APL; kwargs...) = isapprox(promote(p1, p2)...; kwargs...)
 
 # @eval $op(p::APL, α) = $op(promote(p, α)...) would be less efficient
 for (op, fun) in [(:+, :plusconstant), (:-, :minusconstant), (:*, :multconstant), (:(==), :eqconstant)]
-    @eval $op(p::APL, α) = $fun(p, α)
-    @eval $op(α, p::APL) = $fun(α, p)
+    @eval Base.$op(p::APL, α) = $fun(p, α)
+    @eval Base.$op(α, p::APL) = $fun(α, p)
 end
-isapprox(p::APL, α; kwargs...) = isapprox(promote(p, α)...; kwargs...)
-isapprox(α, p::APL; kwargs...) = isapprox(promote(p, α)...; kwargs...)
+Base.isapprox(p::APL, α; kwargs...) = isapprox(promote(p, α)...; kwargs...)
+Base.isapprox(α, p::APL; kwargs...) = isapprox(promote(p, α)...; kwargs...)
 
-(-)(m::AbstractMonomialLike) = (-1) * m
-(-)(t::AbstractTermLike) = (-coefficient(t)) * monomial(t)
-(-)(p::APL) = polynomial((-).(terms(p)))
-(+)(p::Union{APL, RationalPoly}) = p
+Base.:-(m::AbstractMonomialLike) = (-1) * m
+Base.:-(t::AbstractTermLike) = (-coefficient(t)) * monomial(t)
+Base.:-(p::APL) = polynomial((-).(terms(p)))
+Base.:+(p::Union{APL, RationalPoly}) = p
 
 # Avoid adding a zero constant that might artificially increase the Newton polytope
 # Need to add polynomial conversion for type stability
@@ -59,16 +59,16 @@ _multconstant(α, f, p::AbstractPolynomialLike) = _multconstant(α, f, polynomia
 multconstant(α, p::AbstractPolynomialLike) = _multconstant(α, β -> α*β, p)
 multconstant(p::AbstractPolynomialLike, α) = _multconstant(α, β -> β*α, p)
 
-(*)(m1::AbstractMonomialLike, m2::AbstractMonomialLike) = mapexponents(+, m1, m2)
-#(*)(m1::AbstractMonomialLike, m2::AbstractMonomialLike) = *(monomial(m1), monomial(m2))
+Base.:*(m1::AbstractMonomialLike, m2::AbstractMonomialLike) = mapexponents(+, m1, m2)
+#Base.:*(m1::AbstractMonomialLike, m2::AbstractMonomialLike) = *(monomial(m1), monomial(m2))
 
-(*)(m::AbstractMonomialLike, t::AbstractTermLike) = coefficient(t) * (m * monomial(t))
-(*)(t::AbstractTermLike, m::AbstractMonomialLike) = coefficient(t) * (monomial(t) * m)
-(*)(t1::AbstractTermLike, t2::AbstractTermLike) = (coefficient(t1) * coefficient(t2)) * (monomial(t1) * monomial(t2))
+Base.:*(m::AbstractMonomialLike, t::AbstractTermLike) = coefficient(t) * (m * monomial(t))
+Base.:*(t::AbstractTermLike, m::AbstractMonomialLike) = coefficient(t) * (monomial(t) * m)
+Base.:*(t1::AbstractTermLike, t2::AbstractTermLike) = (coefficient(t1) * coefficient(t2)) * (monomial(t1) * monomial(t2))
 
-(*)(t::AbstractTermLike, p::APL) = polynomial(map(te -> t * te, terms(p)))
-(*)(p::APL, t::AbstractTermLike) = polynomial(map(te -> te * t, terms(p)))
-(*)(p::APL, q::APL) = polynomial(p) * polynomial(q)
+Base.:*(t::AbstractTermLike, p::APL) = polynomial(map(te -> t * te, terms(p)))
+Base.:*(p::APL, t::AbstractTermLike) = polynomial(map(te -> te * t, terms(p)))
+Base.:*(p::APL, q::APL) = polynomial(p) * polynomial(q)
 
 # guaranteed that monomial(t1) > monomial(t2)
 function _polynomial_2terms(t1::TT, t2::TT, ::Type{T}) where {TT<:AbstractTerm, T}
@@ -82,9 +82,9 @@ function _polynomial_2terms(t1::TT, t2::TT, ::Type{T}) where {TT<:AbstractTerm,
 end
 for op in [:+, :-]
     @eval begin
-        $op(t1::AbstractTermLike, t2::AbstractTermLike) = $op(term(t1), term(t2))
-        $op(t1::AbstractTerm, t2::AbstractTerm) = $op(promote(t1, t2)...)
-        function $op(t1::TT, t2::TT) where {T, TT <: AbstractTerm{T}}
+        Base.$op(t1::AbstractTermLike, t2::AbstractTermLike) = $op(term(t1), term(t2))
+        Base.$op(t1::AbstractTerm, t2::AbstractTerm) = $op(promote(t1, t2)...)
+        function Base.$op(t1::TT, t2::TT) where {T, TT <: AbstractTerm{T}}
             S = Base.promote_op($op, T, T)
             # t1 > t2 would compare the coefficient in case the monomials are equal
             # and it will throw a MethodError in case the coefficients are not comparable
@@ -104,9 +104,9 @@ adjoint_operator(m::AbstractMonomial) = m
 adjoint_operator(t::T) where {T <: AbstractTerm} = adjoint_operator(coefficient(t)) * monomial(t)
 adjoint_operator(p::AbstractPolynomialLike) = polynomial(map(adjoint_operator, terms(p)))
 
-dot(p1::AbstractPolynomialLike, p2::AbstractPolynomialLike) = p1' * p2
-dot(x, p::AbstractPolynomialLike) = x' * p
-dot(p::AbstractPolynomialLike, x) = p' * x
+Base.dot(p1::AbstractPolynomialLike, p2::AbstractPolynomialLike) = p1' * p2
+Base.dot(x, p::AbstractPolynomialLike) = x' * p
+Base.dot(p::AbstractPolynomialLike, x) = p' * x
 
 # Amazingly, this works! Thanks, StaticArrays.jl!
 """
@@ -117,4 +117,4 @@ Base.vec(vars::Tuple{Vararg{AbstractVariable}}) = [vars...]
 # vec(vars::Tuple{Vararg{<:TypedVariable}}) = SVector(vars)
 
 # https://github.com/JuliaLang/julia/pull/23332
-^(x::AbstractPolynomialLike, p::Integer) = Base.power_by_squaring(x, p)
+Base.:^(x::AbstractPolynomialLike, p::Integer) = Base.power_by_squaring(x, p)

src/rational.jl

@@ -1,5 +1,4 @@
 export RationalPoly
-import Base.+, Base.-, Base.*, Base./
 
 # TODO We should take gcd between numerator and denominator
 struct RationalPoly{NT <: APL, DT <: APL}
@@ -25,43 +24,43 @@ end
 
 Base.inv(r::RationalPoly) = r.den / r.num
 Base.inv(p::APL{T}) where T = one(T) / p
-(/)(r::RationalPoly, p) = r.num / (r.den * p)
-function (/)(num::NT, den::DT) where {NT <: APL, DT <: APL}
+Base.:/(r::RationalPoly, p) = r.num / (r.den * p)
+function Base.:/(num::NT, den::DT) where {NT <: APL, DT <: APL}
     RationalPoly{NT, DT}(num, den)
 end
-function (/)(num, den::APL)
+function Base.:/(num, den::APL)
     constantterm(num, den) / den
 end
 # Polynomial divided by coefficient is a polynomial not a rational polynomial
 # (1/den) * num would not be correct in case of noncommutative coefficients
-(/)(num::APL, den) = mapcoefficientsnz(α -> α/den, num)
+Base.:/(num::APL, den) = mapcoefficientsnz(α -> α/den, num)
 
-function (+)(r::RationalPoly, s::RationalPoly)
+function Base.:+(r::RationalPoly, s::RationalPoly)
     (r.num*s.den + r.den*s.num) / (r.den * s.den)
 end
 function _plus(r::RationalPoly, p)
     (p*r.den + r.num) / r.den
 end
-(+)(p::APL, r::RationalPoly) = _plus(r, p)
-(+)(r::RationalPoly, p::APL) = _plus(r, p)
-(+)(r::RationalPoly, α) = _plus(r, α)
-(+)(α, r::RationalPoly) = _plus(r, α)
-function (-)(r::RationalPoly, s::RationalPoly)
+Base.:+(p::APL, r::RationalPoly) = _plus(r, p)
+Base.:+(r::RationalPoly, p::APL) = _plus(r, p)
+Base.:+(r::RationalPoly, α) = _plus(r, α)
+Base.:+(α, r::RationalPoly) = _plus(r, α)
+function Base.:-(r::RationalPoly, s::RationalPoly)
     (r.num*s.den - r.den*s.num) / (r.den * s.den)
 end
 _minus(p, s::RationalPoly) = (p * s.den - s.num) / s.den
 _minus(s::RationalPoly, p) = (s.num - p * s.den) / s.den
-(-)(p::APL, r::RationalPoly) = _minus(p, r)
-(-)(r::RationalPoly, p::APL) = _minus(r, p)
-(-)(r::RationalPoly, α) = _minus(r, α)
-(-)(α, r::RationalPoly) = _minus(α, r)
-(-)(r::RationalPoly) = (-r.num) / r.den
+Base.:-(p::APL, r::RationalPoly) = _minus(p, r)
+Base.:-(r::RationalPoly, p::APL) = _minus(r, p)
+Base.:-(r::RationalPoly, α) = _minus(r, α)
+Base.:-(α, r::RationalPoly) = _minus(α, r)
+Base.:-(r::RationalPoly) = (-r.num) / r.den
 
-(*)(r::RationalPoly, s::RationalPoly) = (r.num*s.num) / (r.den*s.den)
-(*)(p::APL, r::RationalPoly)          = (p * r.num) / r.den
-(*)(r::RationalPoly, p::APL)          = (r.num * p) / r.den
-(*)(α, r::RationalPoly)               = (α * r.num) / r.den
-(*)(r::RationalPoly, α)               = (r.num * α) / r.den
+Base.:*(r::RationalPoly, s::RationalPoly) = (r.num*s.num) / (r.den*s.den)
+Base.:*(p::APL, r::RationalPoly)          = (p * r.num) / r.den
+Base.:*(r::RationalPoly, p::APL)          = (r.num * p) / r.den
+Base.:*(α, r::RationalPoly)               = (α * r.num) / r.den
+Base.:*(r::RationalPoly, α)               = (r.num * α) / r.den
 
 Base.zero(::RationalPoly{NT}) where {NT} = zero(NT)
 Base.zero(::Type{RationalPoly{NT, DT}}) where {NT, DT} = zero(NT)

src/show.jl

@@ -1,12 +1,12 @@
-function show(io::IO, v::AbstractVariable)
+function Base.show(io::IO, v::AbstractVariable)
     print(io, name(v))
 end
 
 if VERSION < v"0.7.0-DEV.1144" # Define `isone` for base types JuliaLang/julia#22846
     isone(x::T) where T = x == one(T)
 end
 
-function show(io::IO, m::AbstractMonomial)
+function Base.show(io::IO, m::AbstractMonomial)
     if isconstant(m)
         print(io, '1')
     else