breaking changes (#381)

* work around domain

* remove dependency on Intervals

* close #374 (#377)

* V3 drop 1 0 (#379)

* drop support for older versions of Julia

* V3 docs (#380)

* Qr (#384)

* remove depwarn

* add Val(:x) as means to specify the symbol

Author: jverzani

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.0' # lowest supported version
+          - '1.6' # lowest supported version
           - '1'   # last released version
         os:
           - ubuntu-latest

Project.toml

@@ -2,19 +2,17 @@ name = "Polynomials"
 uuid = "f27b6e38-b328-58d1-80ce-0feddd5e7a45"
 license = "MIT"
 author = "JuliaMath"
-version = "2.0.25"
+version = "3.0.0"
 
 [deps]
-Intervals = "d8418881-c3e1-53bb-8760-2df7ec849ed5"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MutableArithmetics = "d8a4904e-b15c-11e9-3269-09a3773c0cb0"
 RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
 
 [compat]
-Intervals = "0.5, 1.0, 1.3"
-MutableArithmetics = "0.3, 1.0"
+MutableArithmetics = "0.3,1"
 RecipesBase = "0.7, 0.8, 1"
-julia = "1"
+julia = "1.6"
 
 [extras]
 DualNumbers = "fa6b7ba4-c1ee-5f82-b5fc-ecf0adba8f74"

README.md

@@ -13,9 +13,11 @@ Basic arithmetic, integration, differentiation, evaluation, and root finding ove
 (v1.6) pkg> add Polynomials
 ```
 
+This package supports Julia v1.6 and later.
+
 ## Available Types of Polynomials
 
-* `Polynomial` –⁠ standard basis polynomials, `a(x) = a₀ + a₁ x + a₂ x² + … + aₙ xⁿ`,  `n ∈ ℕ`
+* `Polynomial` –⁠ standard basis polynomials, `a(x) = a₀ + a₁ x + a₂ x² + … + aₙ xⁿ`,  `n ≥ 0`
 * `ImmutablePolynomial` –⁠ standard basis polynomials backed by a [Tuple type](https://docs.julialang.org/en/v1/manual/functions/#Tuples-1) for faster evaluation of values
 * `SparsePolynomial` –⁠ standard basis polynomial backed by a [dictionary](https://docs.julialang.org/en/v1/base/collections/#Dictionaries-1) to hold  sparse high-degree  polynomials
 * `LaurentPolynomial` –⁠ [Laurent polynomials](https://docs.julialang.org/en/v1/base/collections/#Dictionaries-1), `a(x) = aₘ xᵐ + … + aₙ xⁿ` `m ≤ n`, `m,n ∈ ℤ` backed by an [offset array](https://github.com/JuliaArrays/OffsetArrays.jl); for example, if `m<0` and `n>0`, `a(x) = aₘ xᵐ + … + a₋₁ x⁻¹ + a₀ + a₁ x + … +  aₙ xⁿ`
@@ -99,7 +101,7 @@ julia> q ÷ p # `div`, also `rem` and `divrem`
 Polynomial(0.25 - 0.5*x)
 ```
 
-Operations involving polynomials with different variables will error.
+Most operations involving polynomials with different variables will error.
 
 ```jldoctest
 julia> p = Polynomial([1, 2, 3], :x);
@@ -189,8 +191,9 @@ julia> integrate(Polynomial([1, 0, -1]), 2)
 Polynomial(2.0 + 1.0*x - 0.3333333333333333*x^3)
 ```
 
-Differentiate the polynomial `p` term by term. The degree of the
-resulting polynomial is one lower than the degree of `p`.
+Differentiate the polynomial `p` term by term. For non-zero
+polynomials the degree of the resulting polynomial is one lower than
+the degree of `p`.
 
 ```jldoctest
 julia> derivative(Polynomial([1, 3, -1]))
@@ -242,16 +245,17 @@ Visual example:
 
 Polynomial objects also have other methods:
 
-* 0-based indexing is used to extract the coefficients of `[a0, a1, a2, ...]`, coefficients may be changed using indexing
-  notation.
+* For standard basis polynomials, 0-based indexing is used to extract
+  the coefficients of `[a0, a1, a2, ...]`; for mutable polynomials,
+  coefficients may be changed using indexing notation.
 
-* `coeffs`: returns the entire coefficient vector
+* `coeffs`: returns the coefficients
 
 * `degree`: returns the polynomial degree, `length` is number of stored coefficients
 
-* `variable`: returns the polynomial symbol as polynomial in the underlying type
+* `variable`: returns the polynomial symbol as a polynomial in the underlying type
 
-* `norm`: find the `p`-norm of a polynomial
+* `LinearAlgebra.norm`: find the `p`-norm of a polynomial
 
 * `conj`: finds the conjugate of a polynomial over a complex field
 
@@ -283,7 +287,7 @@ Polynomial objects also have other methods:
 
 * [CommutativeAlgebra.jl](https://github.com/KlausC/CommutativeRings.jl) the start of a computer algebra system specialized to discrete calculations with support for polynomials.
 
-* [PolynomialRoots.jl](https://github.com/giordano/PolynomialRoots.jl) for a fast complex polynomial root finder. For larger degree problems, also [FastPolynomialRoots](https://github.com/andreasnoack/FastPolynomialRoots.jl) and [AMRVW](https://github.com/jverzani/AMRVW.jl).
+* [PolynomialRoots.jl](https://github.com/giordano/PolynomialRoots.jl) for a fast complex polynomial root finder. For larger degree problems, also [FastPolynomialRoots](https://github.com/andreasnoack/FastPolynomialRoots.jl) and [AMRVW](https://github.com/jverzani/AMRVW.jl). For real roots only [RealPolynomialRoots](https://github.com/jverzani/RealPolynomialRoots.jl).
 
 
 * [SpecialPolynomials.jl](https://github.com/jverzani/SpecialPolynomials.jl) A package providing various polynomial types beyond the standard basis polynomials in `Polynomials.jl`. Includes interpolating polynomials, Bernstein polynomials, and classical orthogonal polynomials.

docs/src/extending.md

@@ -22,7 +22,7 @@ As always, if the default implementation does not work or there are more efficie
 | Type function (`(::P)(x)`) | x | |
 | `convert(::Polynomial, ...)` | | Not required, but the library is built off the [`Polynomial`](@ref) type, so all operations are guaranteed to work with it. Also consider writing the inverse conversion method. |
 | `Polynomials.evalpoly(x, p::P)` |  to evaluate the polynomial at `x` (`Base.evalpoly` okay post `v"1.4.0"`) |
-| `domain` | x | Should return an  [`AbstractInterval`](https://invenia.github.io/Intervals.jl/stable/#Intervals-1) |
+| `Polynomials.domain` | x | Should return a `Polynomials.Interval` instance|
 | `vander` | | Required for [`fit`](@ref) |
 | `companion` | | Required for [`roots`](@ref) |
 | `*(::P, ::P)` | | Multiplication of polynomials |

docs/src/index.md

@@ -10,7 +10,9 @@ To install the package, run
 (v1.6) pkg> add Polynomials
 ```
 
-The package can then be loaded into the current session using
+As of version `v3.0.0` Julia version `1.6` or higher is required.
+
+The package can then be loaded into the current session through
 
 ```julia
 using Polynomials
@@ -132,7 +134,8 @@ Polynomial(2.0 + 1.0*x - 0.3333333333333333*x^3)
 ```
 
 Differentiate the polynomial `p` term by term. The degree of the
-resulting polynomial is one lower than the degree of `p`.
+resulting polynomial is one lower than the degree of `p`, unless `p`
+is a zero polynomial.
 
 ```jldoctest
 julia> derivative(Polynomial([1, 3, -1]))
@@ -361,9 +364,9 @@ Most of the root finding algorithms have issues when the roots have
 multiplicities. For example, both `ANewDsc` and `Hecke.roots` assume a
 square free polynomial. For non-square free polynomials:
 
-* The `Polynomials.Multroot.multroot` function is available (version `v"1.2"` or greater) for finding the roots of a polynomial and their multiplicities. This is based on work of Zeng.
+* The `Polynomials.Multroot.multroot` function is available  for finding the roots of a polynomial and their multiplicities. This is based on work of Zeng.
 
-Here we see `IntervalRootsFindings.roots` having trouble isolating the roots due to the multiplicites:
+Here we see `IntervalRootFinding.roots` having trouble isolating the roots due to the multiplicites:
 
 ```
 julia> p = fromroots(Polynomial, [1,2,2,3,3])
@@ -553,7 +556,7 @@ Polynomial(24 - 50*x + 35*x^2 - 10*x^3 + x^4)
 julia> q = convert(FactoredPolynomial, p) # noisy form of `factor`:
 FactoredPolynomial((x - 4.0000000000000036) * (x - 2.9999999999999942) * (x - 1.0000000000000002) * (x - 2.0000000000000018))
 
-julia> map(round, q, digits=10)
+julia> map(x -> round(x, digits=10), q)
 FactoredPolynomial((x - 4.0) * (x - 2.0) * (x - 3.0) * (x - 1.0))
 ```
 
@@ -818,7 +821,7 @@ savefig("rational_function.svg"); nothing # hide
 
 * [AbstractAlgebra.jl](https://github.com/wbhart/AbstractAlgebra.jl), [Nemo.jl](https://github.com/wbhart/Nemo.jl) for generic polynomial rings, matrix spaces, fraction fields, residue rings, power series, [Hecke.jl](https://github.com/thofma/Hecke.jl) for algebraic number theory.
 
-* [LaurentPolynomials.jl](https://github.com/jmichel7/LaurentPolynomials.jl) A package for Laurent polynom
+* [LaurentPolynomials.jl](https://github.com/jmichel7/LaurentPolynomials.jl) A package for Laurent polynomials.
 
 * [CommutativeAlgebra.jl](https://github.com/KlausC/CommutativeRings.jl) the start of a computer algebra system specialized to discrete calculations with support for polynomials.
 

docs/src/reference.md

@@ -19,7 +19,7 @@ coeffs
 degree
 length
 size
-domain
+Polynomials.domain
 mapdomain
 chop
 chop!
@@ -105,10 +105,9 @@ chebs = [
   ChebyshevT([0, 0, 0, 0, 1]),
 ]
 colors = ["#4063D8", "#389826", "#CB3C33", "#9558B2"]
-itr = zip(chebs, colors)
-(cheb,col), state = iterate(itr)
-p = plot(cheb, c=col,  lw=5, legend=false, label="")
-for (cheb, col) in Base.Iterators.rest(itr, state)
+
+p = plot(legend=false, label="")
+for (cheb, col) in zip(chebs, colors)
   plot!(cheb, c=col, lw=5)
 end
 savefig("chebs.svg"); nothing # hide

src/Polynomials.jl

@@ -2,11 +2,7 @@ module Polynomials
 
 #  using GenericLinearAlgebra ## remove for now. cf: https://github.com/JuliaLinearAlgebra/GenericLinearAlgebra.jl/pull/71#issuecomment-743928205
 using LinearAlgebra
-using Intervals
-
-if VERSION >= v"1.4.0"
-    import Base: evalpoly
-end
+import Base: evalpoly
 
 include("abstract.jl")
 include("show.jl")
@@ -16,7 +12,6 @@ include("contrib.jl")
 # Interface for all AbstractPolynomials
 include("common.jl")
 
-
 # Polynomials
 include("polynomials/standard-basis.jl")
 include("polynomials/mutable-arithmetics.jl")
@@ -32,13 +27,11 @@ include("polynomials/multroot.jl")
 include("polynomials/ChebyshevT.jl")
 
 # Rational functions
-if VERSION >= v"1.2.0"
-    include("rational-functions/common.jl")
-    include("rational-functions/rational-function.jl")
-    include("rational-functions/fit.jl")
-    #include("rational-transfer-function.jl")
-    include("rational-functions/plot-recipes.jl")
-end
+include("rational-functions/common.jl")
+include("rational-functions/rational-function.jl")
+include("rational-functions/fit.jl")
+#include("rational-functions/rational-transfer-function.jl")
+include("rational-functions/plot-recipes.jl")
 
 
 # compat; opt-in with `using Polynomials.PolyCompat`

src/abstract.jl

@@ -7,6 +7,8 @@ Var(x::Symbol) = Var{x}()
 Symbol(::Var{T}) where {T} = T
 
 const SymbolLike = Union{AbstractString,Char,Symbol, Var{T} where T}
+Base.Symbol(::Val{T}) where {T} = Symbol(T)
+
 
 """
     AbstractPolynomial{T,X}
@@ -25,8 +27,8 @@ A polynomial type holds an indeterminate `X`; coefficients of type `T`, stored i
 Some `T`s will not be successful
 
 * scalar mult: `c::Number * p::Polynomial` should be defined
-* scalar mult: `c::T * p:Polynomial{T}` An  ambiguity when `T <: AbstractPolynomial`
-* scalar mult: `p:Polynomial{T} * c::T` need not commute
+* scalar mult: `c::T * p::Polynomial{T}` An  ambiguity when `T <: AbstractPolynomial`
+* scalar mult: `p::Polynomial{T} * c::T` need not commute
 
 * scalar add/sub: `p::Polynomial{T} + q::Polynomial{T}` should be defined
 * scalar sub: `p::Polynomial{T} - p::Polynomial{T}`  generally needs `zeros(T,1)` defined for `zero(Polynomial{T})`
@@ -49,7 +51,7 @@ abstract type AbstractPolynomial{T,X} end
 
 
 ## -----
-# We want  ⟒(P{α…,T}) = P{α…}; this default
+# We want  ⟒(P{α…,T,X}) = P{α…}; this default
 # works for most cases
 ⟒(P::Type{<:AbstractPolynomial}) = constructorof(P)
 
@@ -87,27 +89,36 @@ macro register(name)
         Base.promote_rule(::Type{<:$poly{T,X}}, ::Type{<:$poly{S,X}}) where {T,S,X} =  $poly{promote_type(T, S),X}
         Base.promote_rule(::Type{<:$poly{T,X}}, ::Type{S}) where {T,S<:Number,X} =
             $poly{promote_type(T, S),X}
-        $poly(coeffs::AbstractVector{T}) where {T} =
-            $poly{T, :x}(coeffs)
-        $poly(coeffs::AbstractVector{T}, var::SymbolLike) where {T} =
+
+        $poly(coeffs::AbstractVector{T}, var::SymbolLike=Var(:x)) where {T} =
             $poly{T, Symbol(var)}(coeffs)
-        $poly{T}(x::AbstractVector{S}, var::SymbolLike = :x) where {T,S} =
+        $poly{T}(x::AbstractVector{S}, var::SymbolLike=Var(:x)) where {T,S} =
             $poly{T,Symbol(var)}(T.(x))
-        function $poly(coeffs::G, var::SymbolLike=:x) where {G}
+
+        function $poly{T}(coeffs::G, var::SymbolLike=Var(x)) where {T,G}
+            !Base.isiterable(G) && throw(ArgumentError("coeffs is not iterable"))
+            cs = collect(T, coeffs)
+            $poly{T, Symbol(var)}(cs)
+        end
+        function $poly(coeffs::G, var::SymbolLike=Var(:x)) where {G}
             !Base.isiterable(G) && throw(ArgumentError("coeffs is not iterable"))
             cs = collect(coeffs)
             $poly{eltype(cs), Symbol(var)}(cs)
         end
+
         $poly{T,X}(c::AbstractPolynomial{S,Y}) where {T,X,S,Y} = convert($poly{T,X}, c)
         $poly{T}(c::AbstractPolynomial{S,Y}) where {T,S,Y} = convert($poly{T}, c)
         $poly(c::AbstractPolynomial{S,Y}) where {S,Y} = convert($poly, c)
+
         $poly{T,X}(n::S) where {T, X, S<:Number} =
             T(n) *  one($poly{T, X})
-        $poly{T}(n::S, var::SymbolLike = :x) where {T, S<:Number} =
+        $poly{T}(n::S, var::SymbolLike = Var(:x)) where {T, S<:Number} =
             T(n) *  one($poly{T, Symbol(var)})
-        $poly(n::S, var::SymbolLike = :x)  where {S  <: Number} = n * one($poly{S, Symbol(var)})
-        $poly{T}(var::SymbolLike=:x) where {T} = variable($poly{T, Symbol(var)})
-        $poly(var::SymbolLike=:x) = variable($poly, Symbol(var))
+        $poly(n::S, var::SymbolLike = Var(:x))  where {S  <: Number} = n * one($poly{S, Symbol(var)})
+
+        $poly{T}(var::SymbolLike=Var(:x)) where {T} = variable($poly{T, Symbol(var)})
+        $poly(var::SymbolLike=Var(:x)) = variable($poly, Symbol(var))
+
         (p::$poly)(x) = evalpoly(x, p)
     end
 end
@@ -125,21 +136,22 @@ macro registerN(name, params...)
         Base.promote_rule(::Type{<:$poly{$(αs...),T,X}}, ::Type{S}) where {$(αs...),T,X,S<:Number} =
             $poly{$(αs...),promote_type(T,S),X}
 
-        function $poly{$(αs...),T}(x::AbstractVector{S}, var::SymbolLike = :x) where {$(αs...),T,S}
+        function $poly{$(αs...),T}(x::AbstractVector{S}, var::SymbolLike = Var(:x)) where {$(αs...),T,S}
             $poly{$(αs...),T,Symbol(var)}(T.(x))
         end
-        $poly{$(αs...)}(coeffs::AbstractVector{T}, var::SymbolLike=:x) where {$(αs...),T} =
+        $poly{$(αs...)}(coeffs::AbstractVector{T}, var::SymbolLike=Var(:x)) where {$(αs...),T} =
             $poly{$(αs...),T,Symbol(var)}(coeffs)
         $poly{$(αs...),T,X}(c::AbstractPolynomial{S,Y}) where {$(αs...),T,X,S,Y} = convert($poly{$(αs...),T,X}, c)
         $poly{$(αs...),T}(c::AbstractPolynomial{S,Y}) where {$(αs...),T,S,Y} = convert($poly{$(αs...),T}, c)
         $poly{$(αs...),}(c::AbstractPolynomial{S,Y}) where {$(αs...),S,Y} = convert($poly{$(αs...),}, c)
 
         $poly{$(αs...),T,X}(n::Number) where {$(αs...),T,X} = T(n)*one($poly{$(αs...),T,X})
-        $poly{$(αs...),T}(n::Number, var::SymbolLike = :x) where {$(αs...),T} = T(n)*one($poly{$(αs...),T,Symbol(var)})
-        $poly{$(αs...)}(n::S, var::SymbolLike = :x) where {$(αs...), S<:Number} =
+        $poly{$(αs...),T}(n::Number, var::SymbolLike = Var(:x)) where {$(αs...),T} = T(n)*one($poly{$(αs...),T,Symbol(var)})
+        $poly{$(αs...)}(n::S, var::SymbolLike = Var(:x)) where {$(αs...), S<:Number} =
             n*one($poly{$(αs...),S,Symbol(var)})
-        $poly{$(αs...),T}(var::SymbolLike=:x) where {$(αs...), T} = variable($poly{$(αs...),T,Symbol(var)})
-        $poly{$(αs...)}(var::SymbolLike=:x) where {$(αs...)} = variable($poly{$(αs...)},Symbol(var))
+        $poly{$(αs...),T}(var::SymbolLike=Var(:x)) where {$(αs...), T} =
+            variable($poly{$(αs...),T,Symbol(var)})
+        $poly{$(αs...)}(var::SymbolLike=Var(:x)) where {$(αs...)} = variable($poly{$(αs...)},Symbol(var))
         (p::$poly)(x) = evalpoly(x, p)
     end
 end