use coeffs() in place of p.coeffs

Author: jverzani

src/abstract.jl

@@ -35,7 +35,7 @@ macro register(name)
     poly = esc(name)
     quote
         Base.convert(::Type{P}, p::P) where {P<:$poly} = p
-        Base.convert(P::Type{<:$poly}, p::$poly) where {T} = P(p.coeffs, p.var)
+        Base.convert(P::Type{<:$poly}, p::$poly) where {T} = P(coeffs(p), p.var)
         Base.promote_rule(::Type{$poly{T}}, ::Type{$poly{S}}) where {T,S} =
             $poly{promote_type(T, S)}
         Base.promote_rule(::Type{$poly{T}}, ::Type{S}) where {T,S<:Number} =

src/common.jl

@@ -170,9 +170,9 @@ In-place version of [`truncate`](@ref)
 function truncate!(p::AbstractPolynomial{T};
     rtol::Real = Base.rtoldefault(real(T)),
     atol::Real = 0,) where {T}
-    max_coeff = maximum(abs, p.coeffs)
+    max_coeff = maximum(abs, coeffs(p))
     thresh = max_coeff * rtol + atol
-    map!(c->abs(c) <= thresh ? zero(T) : c, p.coeffs, p.coeffs)
+    map!(c->abs(c) <= thresh ? zero(T) : c, coeffs(p), coeffs(p))
     return chop!(p, rtol = rtol, atol = atol)
 end
 
@@ -286,14 +286,14 @@ Inspection =#
 
 The length of the polynomial.
 """
-Base.length(p::AbstractPolynomial) = length(p.coeffs)
+Base.length(p::AbstractPolynomial) = length(coeffs(p))
 """
     size(::AbstractPolynomial, [i])
 
 Returns the size of the polynomials coefficients, along axis `i` if provided.
 """
-Base.size(p::AbstractPolynomial) = size(p.coeffs)
-Base.size(p::AbstractPolynomial, i::Integer) = size(p.coeffs, i)
+Base.size(p::AbstractPolynomial) = size(coeffs(p))
+Base.size(p::AbstractPolynomial, i::Integer) = size(coeffs(p), i)
 Base.eltype(p::AbstractPolynomial{T}) where {T} = T
 Base.eltype(::Type{P}) where {P <: AbstractPolynomial} = P
 function Base.iszero(p::AbstractPolynomial)
@@ -318,7 +318,7 @@ has a nonzero coefficient. The degree of the zero polynomial is defined to be -1
 """
 degree(p::AbstractPolynomial) = iszero(p) ? -1 : length(p) - 1
 
-hasnan(p::AbstractPolynomial) = any(isnan.(p.coeffs))
+hasnan(p::AbstractPolynomial) = any(isnan.(coeffs(p)))
 
 """
     domain(::Type{<:AbstractPolynomial})
@@ -416,15 +416,15 @@ end
 function Base.getindex(p::AbstractPolynomial{T}, idx::Int) where {T <: Number}
     idx < 0 && throw(BoundsError(p, idx))
     idx ≥ length(p) && return zero(T)
-    return p.coeffs[idx + 1]
+    return coeffs(p)[idx + 1]
 end
 Base.getindex(p::AbstractPolynomial, idx::Number) = getindex(p, convert(Int, idx))
 Base.getindex(p::AbstractPolynomial, indices) = [getindex(p, i) for i in indices]
-Base.getindex(p::AbstractPolynomial, ::Colon) = p.coeffs
+Base.getindex(p::AbstractPolynomial, ::Colon) = coeffs(p)
 
 # setindex
 function Base.setindex!(p::AbstractPolynomial, value::Number, idx::Int)
-    n = length(p.coeffs)
+    n = length(coeffs(p))
     if n ≤ idx
         resize!(p.coeffs, idx + 1)
         p.coeffs[n + 1:idx] .= 0
@@ -446,8 +446,8 @@ Base.setindex!(p::AbstractPolynomial, values, ::Colon) =
 
 #=
 identity =#
-Base.copy(p::P) where {P <: AbstractPolynomial} = P(copy(p.coeffs), p.var)
-Base.hash(p::AbstractPolynomial, h::UInt) = hash(p.var, hash(p.coeffs, h))
+Base.copy(p::P) where {P <: AbstractPolynomial} = P(copy(coeffs(p)), p.var)
+Base.hash(p::AbstractPolynomial, h::UInt) = hash(p.var, hash(coeffs(p), h))
 """
     zero(::Type{<:AbstractPolynomial})
     zero(::AbstractPolynomial)
@@ -467,19 +467,19 @@ Base.one(p::P) where {P <: AbstractPolynomial} = one(P)
 
 #=
 arithmetic =#
-Base.:-(p::P) where {P <: AbstractPolynomial} = P(-p.coeffs, p.var)
+Base.:-(p::P) where {P <: AbstractPolynomial} = P(-coeffs(p), p.var)
 Base.:+(c::Number, p::AbstractPolynomial) = +(p, c)
 Base.:-(p::AbstractPolynomial, c::Number) = +(p, -c)
 Base.:-(c::Number, p::AbstractPolynomial) = +(-p, c)
 Base.:*(c::Number, p::AbstractPolynomial) = *(p, c)
 
 function Base.:*(p::P, c::S) where {P <: AbstractPolynomial,S}
     T = promote_type(P, S)
-    return T(p.coeffs .* c, p.var)
+    return T(coeffs(p) .* c, p.var)
 end
 function Base.:/(p::P, c::S) where {T,P <: AbstractPolynomial{T},S}
     R = promote_type(P, eltype(one(T) / one(S)))
-    return R(p.coeffs ./ c, p.var)
+    return R(coeffs(p) ./ c, p.var)
 end
 Base.:-(p1::AbstractPolynomial, p2::AbstractPolynomial) = +(p1, -p2)
 
@@ -547,8 +547,8 @@ Base.rem(n::AbstractPolynomial, d::AbstractPolynomial) = divrem(n, d)[2]
 Comparisons =#
 Base.isequal(p1::P, p2::P) where {P <: AbstractPolynomial} = hash(p1) == hash(p2)
 Base.:(==)(p1::AbstractPolynomial, p2::AbstractPolynomial) =
-    (p1.var == p2.var) && (p1.coeffs == p2.coeffs)
-Base.:(==)(p::AbstractPolynomial, n::Number) = p.coeffs == [n]
+    (p1.var == p2.var) && (coeffs(p1) == coeffs(p2))
+Base.:(==)(p::AbstractPolynomial, n::Number) = coeffs(p) == [n]
 Base.:(==)(n::Number, p::AbstractPolynomial) = p == n
 
 function Base.isapprox(p1::AbstractPolynomial{T},
@@ -564,7 +564,7 @@ function Base.isapprox(p1::AbstractPolynomial{T},
     if length(p1t) ≠ length(p2t)
         return false
     end
-    isapprox(p1t.coeffs, p2t.coeffs, rtol = rtol, atol = atol)
+    isapprox(coeffs(p1t), coeffs(p2t), rtol = rtol, atol = atol)
 end
 
 function Base.isapprox(p1::AbstractPolynomial{T},
@@ -575,7 +575,7 @@ function Base.isapprox(p1::AbstractPolynomial{T},
     if length(p1t) != 1
         return false
     end
-    isapprox(p1t.coeffs, [n], rtol = rtol, atol = atol)
+    isapprox(coeffs(p1t), [n], rtol = rtol, atol = atol)
 end
 
 Base.isapprox(n::S,