Use Polynomials 1.0 API (JuliaDSP#361)

* Use Polynomials 1.0 API

Instead of using the compatibility interface provided by Polynomials.jl for
backwards compatibility, I have changed calls to Polynomials.jl from DSP.jl so
that they use the new API.

Related to JuliaDSP#359.

* Remove redundant `using` statement for Polynomials.jl

src/Filters/Filters.jl

@@ -1,7 +1,7 @@
 module Filters
 using ..Unwrap
-using Polynomials, ..Util
-using Polynomials.PolyCompat
+using ..Util
+using Polynomials: Polynomial, coeffs, roots, fromroots
 
 import Base: *
 using LinearAlgebra: I, mul!, rmul!

src/Filters/coefficients.jl

@@ -42,11 +42,11 @@ Base.promote_rule(::Type{ZeroPoleGain{Z1,P1,K1}}, ::Type{ZeroPoleGain{Z2,P2,K2}}
 #
 
 struct PolynomialRatio{T<:Number} <: FilterCoefficients
- b::Poly{T}
- a::Poly{T}
+ b::Polynomial{T}
+ a::Polynomial{T}
 
- PolynomialRatio{Ti}(b::Poly, a::Poly) where {Ti<:Number} =
- new{Ti}(convert(Poly{Ti}, b/a[end]), convert(Poly{Ti}, a/a[end]))
+ PolynomialRatio{Ti}(b::Polynomial, a::Polynomial) where {Ti<:Number} =
+ new{Ti}(convert(Polynomial{Ti}, b/a[end]), convert(Polynomial{Ti}, a/a[end]))
 end
 """
  PolynomialRatio(b, a)
@@ -63,16 +63,16 @@ H(z) = \\frac{\\verb!b[1]! + \\ldots + \\verb!b[n]! z^{-n+1}}{\\verb!a[1]! + \\l
 `b` and `a` may be specified as `Polynomial` objects or
 vectors ordered from highest power to lowest.
 """
-PolynomialRatio(b::Poly{T}, a::Poly{T}) where {T<:Number} = PolynomialRatio{T}(b, a)
-PolynomialRatio(b::Poly, a::Poly) = PolynomialRatio(promote(b, a)...)
+PolynomialRatio(b::Polynomial{T}, a::Polynomial{T}) where {T<:Number} = PolynomialRatio{T}(b, a)
+PolynomialRatio(b::Polynomial, a::Polynomial) = PolynomialRatio(promote(b, a)...)
 
 # The DSP convention is highest power first. The Polynomials.jl
 # convention is lowest power first.
 function PolynomialRatio{T}(b::Union{Number,Vector{<:Number}}, a::Union{Number,Vector{<:Number}}) where {T}
  if all(iszero, b) || all(iszero, a)
  throw(ArgumentError("filter must have non-zero numerator and denominator"))
  end
- PolynomialRatio{T}(Poly(reverse(b)), Poly(reverse(a)))
+ PolynomialRatio{T}(Polynomial(reverse(b)), Polynomial(reverse(a)))
 end
 PolynomialRatio(b::Union{T,Vector{T}}, a::Union{S,Vector{S}}) where {T<:Number,S<:Number} =
  PolynomialRatio{promote_type(T,S)}(b, a)
@@ -83,9 +83,9 @@ PolynomialRatio(f::PolynomialRatio{T}) where {T} = PolynomialRatio{T}(f)
 Base.promote_rule(::Type{PolynomialRatio{T}}, ::Type{PolynomialRatio{S}}) where {T,S} = PolynomialRatio{promote_type(T,S)}
 
 function PolynomialRatio{T}(f::ZeroPoleGain) where T<:Real
- b = f.k*poly(f.z)
- a = poly(f.p)
- PolynomialRatio{T}(Poly(real(b.a)), Poly(real(a.a)))
+ b = f.k * fromroots(f.z)
+ a = fromroots(f.p)
+ PolynomialRatio{T}(Polynomial(real(coeffs(b))), Polynomial(real(coeffs(a))))
 end
 PolynomialRatio(f::ZeroPoleGain{Z,P,K}) where {Z,P,K} =
  PolynomialRatio{promote_type(real(Z),real(P),K)}(f)
@@ -108,7 +108,7 @@ ZeroPoleGain(f::PolynomialRatio{T}) where {T} =
 Coefficients of the numerator of a PolynomialRatio object, highest power
 first, i.e., the `b` passed to `filt()`
 """
-coefb(f::PolynomialRatio) = reverse(f.b.a)
+coefb(f::PolynomialRatio) = reverse(coeffs(f.b))
 coefb(f::FilterCoefficients) = coefb(PolynomialRatio(f))
 
 """
@@ -117,7 +117,7 @@ coefb(f::FilterCoefficients) = coefb(PolynomialRatio(f))
 Coefficients of the denominator of a PolynomialRatio object, highest power
 first, i.e., the `a` passed to `filt()`
 """
-coefa(f::PolynomialRatio) = reverse(f.a.a)
+coefa(f::PolynomialRatio) = reverse(coeffs(f.a))
 coefa(f::FilterCoefficients) = coefa(PolynomialRatio(f))
 
 #

src/Filters/filt.jl

@@ -160,8 +160,8 @@ function filt!(out::AbstractVector, f::DF2TFilter{PolynomialRatio{T},Vector{S}},
  si = f.state
  # Note: these are in the Polynomials.jl convention, which is
  # reversed WRT the usual DSP convention
- b = f.coef.b.a
- a = f.coef.a.a
+ b = coeffs(f.coef.b)
+ a = coeffs(f.coef.a)
  n = length(b)
  if n == 1
  mul!(out, x, b[1])

src/Filters/response.jl

@@ -7,7 +7,7 @@
 function freqz(filter::FilterCoefficients, w::Number)
  filter = convert(PolynomialRatio, filter)
  ejw = exp(-im * w)
- polyval(filter.b, ejw) ./ polyval(filter.a, ejw)
+ filter.b(ejw) ./ filter.a(ejw)
 end
 
 function freqz(filter::ZeroPoleGain, w::Number)
@@ -88,7 +88,7 @@ or frequencies `w` in radians/sample.
 function freqs(filter::FilterCoefficients, w::Number)
  filter = convert(PolynomialRatio, filter)
  s = im * w
- polyval(filter.b, s) ./ polyval(filter.a, s)
+ filter.b(s) ./ filter.a(s)
 end
 
 function freqs(filter::ZeroPoleGain, w::Number)

test/filter_conversion.jl

@@ -234,9 +234,13 @@ end
  @test Biquad(2.0, 0.0, 0.0, 0.0, 0.0)*2 == Biquad(4.0, 0.0, 0.0, 0.0, 0.0)
  @test convert(Biquad{Float64}, f1) == convert(Biquad, f1)
  f = PolynomialRatio(Float64[1.0], Float64[1.0])
- empty!(f.b.a)
- empty!(f.a.a)
+
+ # I don't understand why this tests is necessary, it's impossible to make a
+ # PolynomialRatio with empty coefficients in the first place.
+ empty!(f.b.coeffs)
+ empty!(f.a.coeffs)
  @test_throws ArgumentError convert(Biquad, f)
+
  @test_throws ArgumentError convert(SecondOrderSections, ZeroPoleGain([0.5 + 0.5im, 0.5 + 0.5im], [0.5 + 0.5im, 0.5 - 0.5im], 1))
  @test_throws ArgumentError convert(SecondOrderSections, ZeroPoleGain([0.5 + 0.5im, 0.5 - 0.5im], [0.5 + 0.5im, 0.5 + 0.5im], 1))