Merge pull request #141 from JeffreySarnoff/attobot_fixes

Attobot fixes

Author: jverzani

src/Polynomials.jl

@@ -1,6 +1,7 @@
 # Poly type manipulations
 
-isdefined(Base, :__precompile__) && __precompile__()
+__precompile__()
+
 
 module Polynomials
 #todo: sparse polynomials?
@@ -76,7 +77,7 @@ Poly(0.5 - 0.5⋅x^2)
 struct Poly{T}
   a::Vector{T}
   var::Symbol
-  function (::Type{Poly})(a::AbstractVector{T}, var::SymbolLike = :x) where {T<:Number}
+  function Poly(a::AbstractVector{T}, var::SymbolLike = :x) where {T<:Number}
     # if a == [] we replace it with a = [0]
     if length(a) == 0
       return new{T}(zeros(T,1),Symbol(var))
@@ -90,7 +91,7 @@ struct Poly{T}
 end
 
 Poly(n::Number, var::SymbolLike = :x) = Poly([n], var)
-(::Type{Poly{T}})(x::AbstractVector{S}, var::SymbolLike = :x) where {T,S} =
+Poly{T}(x::AbstractVector{S}, var::SymbolLike = :x) where {T,S} =
   Poly(convert(Vector{T}, x), var)
 
 # create a Poly object from its roots
@@ -403,21 +404,21 @@ given `norm` function. The tolerances `rtol` and `atol` are passed to both
 `truncate` and `isapprox`.
 """
 function isapprox(p1::Poly{T}, p2::Poly{S};
-  rtol::Real = (@compat Base.rtoldefault(T,S, 0)), atol::Real = 0, norm::Function = vecnorm) where {T,S}
+  rtol::Real = (Base.rtoldefault(T,S, 0)), atol::Real = 0, norm::Function = vecnorm) where {T,S}
   p1.var == p2.var || error("Polynomials must have same variable")
   p1t = truncate(p1; rtol = rtol, atol = atol)
   p2t = truncate(p2; rtol = rtol, atol = atol)
   length(p1t) == length(p2t) && isapprox(coeffs(p1t), coeffs(p2t); rtol = rtol,
     atol = atol, norm = norm)
 end
 
-function isapprox(p1::Poly{T}, n::S; rtol::Real = (@compat Base.rtoldefault(T,S, 0)),
+function isapprox(p1::Poly{T}, n::S; rtol::Real = (Base.rtoldefault(T,S, 0)),
   atol::Real = 0) where {T,S<:Number}
   p1t = truncate(p1; rtol = rtol, atol = atol)
   degree(p1t) == 0 && isapprox(coeffs(p1), [n]; rtol = rtol, atol = atol)
 end
 
-isapprox(n::S, p1::Poly{T}; rtol::Real= (@compat Base.rtoldefault(T,S, 0)),
+isapprox(n::S, p1::Poly{T}; rtol::Real= (Base.rtoldefault(T,S, 0)),
   atol::Real = 0)  where {T,S<:Number}  = isapprox(p1, n; rtol = rtol, atol = atol)
 
 hash(f::Poly, h::UInt) = hash(f.var, hash(f.a, h))
@@ -505,7 +506,7 @@ polyint(p::Poly{T}, k::S) where {T,S<:Number} = _polyint(p, k)
 function _polyint(p::Poly{T}, k::S) where {T,S<:Number}
     n = length(p)
     R = promote_type(typeof(one(T)/1), S)
-    a2 = @compat Vector{R}(undef, n+1)
+    a2 = Vector{R}(undef, n+1)
     a2[1] = k
     for i = 1:n
         a2[i+1] = p[i-1] / i
@@ -566,7 +567,7 @@ end
 
 function _polyder(p::Poly{T}, order::Int=1) where {T}
   n = length(p)
-  a2 = @compat Vector{T}(undef, n-order)
+  a2 = Vector{T}(undef, n-order)
   for i = order:n-1
     a2[i-order+1] = p[i] * prod((i-order+1):i)
   end
@@ -634,7 +635,7 @@ function roots(p::Poly{T}) where {T}
     n = lastindex(p)-(num_leading_zeros + num_trailing_zeros)
     n < 1 && return zeros(R, length(p) - num_trailing_zeros - 1)
 
-    companion = @compat diagm(-1 => ones(R, n-1))
+    companion = diagm(-1 => ones(R, n-1))
     an = p[end-num_trailing_zeros]
     companion[1,:] = -p[(end-num_trailing_zeros-1):-1:num_leading_zeros] / an
 

src/pade.jl

@@ -2,16 +2,16 @@ struct Pade{T<:Number,S<:Number}
     p::Poly{T}
     q::Poly{S}
     var::Symbol
-    function (::Type{Pade{T,S}})(p::Poly{T},q::Poly{S}) where {T,S}
+    function Pade{T,S}(p::Poly{T},q::Poly{S}) where {T,S}
         if p.var != q.var
             error("Polynomials must have same variable")
         end
         new{T,S}(p, q, p.var)
     end
 end
-(::Type{Pade})(p::Poly{T}, q::Poly{S}) where {T<:Number,S<:Number}= Pade{T,S}(p,q)
+Pade(p::Poly{T}, q::Poly{S}) where {T<:Number,S<:Number}= Pade{T,S}(p,q)
 
-function (::Type{Pade})(c::Poly{T},m::Int,n::Int) where {T}
+function Pade(c::Poly{T},m::Int,n::Int) where {T}
     @assert m+n < length(c)
     rold,rnew = Poly([zeros(T,m+n+1);one(T)],c.var),Poly(c.a[1:m+n+1],c.var)
     uold,vold = Poly([one(T)],c.var),Poly([zero(T)],c.var)

src/show.jl

@@ -78,9 +78,9 @@ default, the terms are in order of ascending powers, matching the order in
 
 # Examples
 ```jldoctest
-julia> printpoly(STDOUT, Poly([1,2,3], :y))
+julia> printpoly(stdout, Poly([1,2,3], :y))
 1 + 2*y + 3*y^2
-julia> printpoly(STDOUT, Poly([1,2,3], :y), descending_powers=true)
+julia> printpoly(stdout, Poly([1,2,3], :y), descending_powers=true)
 3*y^2 + 2*y + 1
 ```
 """

test/runtests.jl

@@ -150,7 +150,7 @@ const _γ = 0.5772156649015
 println("Test for the summation of a factorially divergent series.")
 d = Poly(convert(Vector{BigInt},(-1).^(0:60).* map(gamma,BigFloat(1):BigFloat(61.0))).//1,"x")
 PQexpint = Pade(d,30,30)
-@compat println("The approximate sum of the divergent series is:  ", Float64(padeval(PQexpint,1.0)))
+println("The approximate sum of the divergent series is:  ", Float64(padeval(PQexpint,1.0)))
 println("The approximate sum of the convergent series is: ",exp(1)*(-_γ-sum([(-1).^k/k./gamma(k+1) for k=1:20])))
 @test isapprox(convert(Float64, padeval(PQexpint,1.0)),
                exp(1)*(-_γ-sum([(-1).^k/k./gamma(k+1) for k=1:20])))
@@ -290,15 +290,6 @@ end
 @test printpoly_to_string(Poly([1,2,3], "y"), descending_powers=true) == "3*y^2 + 2*y + 1"
 
 ## want to be able to copy and paste
-if VERSION < v"0.6.0-dev"
-    string_eval_poly(p,x) = eval(Expr(:function, Expr(:call, :f, :x), parse(string(p)[6:end-1])))(x)
-    p = Poly([1,2,3]) # copy and paste
-    q = Poly([1//1, 2//1, 3//1])
-    r = Poly([1.0, 2, 3])
-    @test string_eval_poly(p, 5) == p(5)
-    @test string_eval_poly(q, 5) == q(5)
-    @test string_eval_poly(r, 5) == r(5)
-end
 ## check hashing
 p = poly([1,2,3])
 q = poly([1,2,3])