New methods for evaluate for Taylor1{TaylorN}} (#377)

* Add methods for evaluate of Taylor1{TaylorN}, and aff_normalize

* Clean up (support Julia v1.10 onwards)

* Remove Requires.jl dependency

Author: lbenet

Project.toml

@@ -6,7 +6,6 @@ version = "0.18.3"
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
-Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
 [weakdeps]
@@ -28,7 +27,6 @@ JLD2 = "0.5"
 LinearAlgebra = "<0.0.1, 1"
 Markdown = "<0.0.1, 1"
 RecursiveArrayTools = "2, 3"
-Requires = "0.5.2, 1"
 SparseArrays = "<0.0.1, 1"
 StaticArrays = "1"
 Test = "<0.0.1, 1"

ext/TaylorSeriesIAExt.jl

@@ -4,9 +4,9 @@ using TaylorSeries
 
 import Base: ^, log, asin, acos, acosh, atanh, power_by_squaring
 
-import TaylorSeries: evaluate, _evaluate, normalize_taylor, square
+import TaylorSeries: evaluate, _evaluate, normalize_taylor, aff_normalize, square
 
-isdefined(Base, :get_extension) ? (using IntervalArithmetic) : (using ..IntervalArithmetic)
+using IntervalArithmetic
 
 for T in (:Taylor1, :TaylorN)
     @eval begin
@@ -188,16 +188,11 @@ function evaluate(a::Taylor1, dx::Interval{S}) where {S<:Real}
     return sum_even + sum_odd*dx
 end
 
-function evaluate(a::TaylorN, dx::IntervalBox{N,T}) where {T<:Real,N}
-    @assert N == get_numvars()
-    a_length = length(a)
-    suma = zero(constant_term(a)) + Interval{T}(0, 0)
-    @inbounds for homPol in reverse(eachindex(a))
-        suma += evaluate(a[homPol], dx)
-    end
+evaluate(a::Taylor1{TaylorN{T}}, dx::IntervalBox{N,S}) where {T<:Real, N, S} =
+    evaluate(a, dx.v)
 
-    return suma
-end
+evaluate(a::TaylorN{T}, dx::IntervalBox{N,S}) where {T<:Real, N, S} =
+    evaluate(a, dx.v)
 
 function evaluate(a::HomogeneousPolynomial, dx::IntervalBox{N,T}) where {T<:Real,N}
     @assert N == get_numvars()
@@ -261,29 +256,28 @@ are mapped by an affine transformation to the intervals `-1..1`
 normalize_taylor(a::TaylorN, I::IntervalBox{N,T}, symI::Bool=true) where {T<:Real,N} =
     _normalize(a, I, Val(symI))
 
+aff_normalize(x, I::Interval, ::Val{true})  = mid(I) + x*radius(I)
+aff_normalize(x, I::Interval, ::Val{false}) = inf(I) + x*diam(I)
+
 #  I -> -1..1
 function _normalize(a::Taylor1, I::Interval{T}, ::Val{true}) where {T<:Real}
-    order = get_order(a)
-    t = Taylor1(T, order)
-    tnew = mid(I) + t*radius(I)
-    return a(tnew)
+    t = Taylor1(T, get_order(a))
+    return a(aff_normalize(t, I, Val(true)))
 end
 
 #  I -> 0..1
 function _normalize(a::Taylor1, I::Interval{T}, ::Val{false}) where {T<:Real}
-    order = get_order(a)
-    t = Taylor1(T, order)
-    tnew = inf(I) + t*diam(I)
-    return a(tnew)
+    t = Taylor1(T, get_order(a))
+    return a(aff_normalize(t, I, Val(false)))
 end
 
 #  I -> IntervalBox(-1..1, Val(N))
 function _normalize(a::TaylorN, I::IntervalBox{N,T}, ::Val{true}) where {T<:Real,N}
     order = get_order(a)
     x = Vector{typeof(a)}(undef, N)
     for ind in eachindex(x)
-        x[ind] = mid(I[ind]) + TaylorN(ind, order=order)*radius(I[ind])
-    end
+        x[ind] = aff_normalize(TaylorN(ind, order=order), I[ind], Val(true))
+end
     return a(x)
 end
 
@@ -292,7 +286,7 @@ function _normalize(a::TaylorN, I::IntervalBox{N,T}, ::Val{false}) where {T<:Rea
     order = get_order(a)
     x = Vector{typeof(a)}(undef, N)
     for ind in eachindex(x)
-        x[ind] = inf(I[ind]) + TaylorN(ind, order=order)*diam(I[ind])
+        x[ind] = aff_normalize(TaylorN(ind, order=order), I[ind], Val(false))
     end
     return a(x)
 end

ext/TaylorSeriesJLD2Ext.jl

@@ -3,11 +3,7 @@ module TaylorSeriesJLD2Ext
 import Base: convert
 using TaylorSeries
 
-if isdefined(Base, :get_extension)
-    import JLD2: writeas
-else
-    import ..JLD2: writeas
-end
+import JLD2: writeas
 
 @doc raw"""
     TaylorNSerialization{T}

ext/TaylorSeriesRATExt.jl

@@ -2,7 +2,7 @@ module TaylorSeriesRATExt
 
 using TaylorSeries
 
-isdefined(Base, :get_extension) ? (import RecursiveArrayTools) : (import ..RecursiveArrayTools)
+import RecursiveArrayTools
 
 function RecursiveArrayTools.recursivecopy(a::AbstractArray{<:AbstractSeries, N}) where N
     deepcopy(a)

ext/TaylorSeriesSAExt.jl

@@ -5,7 +5,7 @@ using TaylorSeries
 import Base.promote_op
 import LinearAlgebra: matprod
 
-isdefined(Base, :get_extension) ? (using StaticArrays) : (using ..StaticArrays)
+using StaticArrays
 
 promote_op(::typeof(adjoint), ::Type{T}) where {T<:AbstractSeries} = T
 promote_op(::typeof(matprod), ::Type{T}, ::Type{U}) where {T <: AbstractSeries, U <: AbstractFloat} = T

src/TaylorSeries.jl

@@ -20,17 +20,9 @@ module TaylorSeries
 using SparseArrays: SparseMatrixCSC
 using Markdown
 
-if !isdefined(Base, :get_extension)
-    using Requires
-end
-
 using LinearAlgebra: norm, mul!,
     lu, lu!, LinearAlgebra.lutype, LinearAlgebra.copy_oftype,
-    LinearAlgebra.issuccess
-
-if VERSION >= v"1.7.0-DEV.1188"
-    using LinearAlgebra: NoPivot, RowMaximum
-end
+    LinearAlgebra.issuccess, NoPivot, RowMaximum
 
 import LinearAlgebra: norm, mul!, lu
 
@@ -81,18 +73,5 @@ include("dictmutfunct.jl")
 include("broadcasting.jl")
 include("printing.jl")
 
-function __init__()
-    @static if !isdefined(Base, :get_extension)
-        @require IntervalArithmetic = "d1acc4aa-44c8-5952-acd4-ba5d80a2a253" begin
-            include("../ext/TaylorSeriesIAExt.jl")
-        end
-        @require StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" begin
-            include("../ext/TaylorSeriesSAExt.jl")
-        end
-        @require JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819" begin
-            include("../ext/TaylorSeriesJLD2Ext.jl")
-        end
-    end
-end
 
 end # module

src/arithmetic.jl

@@ -1283,8 +1283,8 @@ end
 # end
 
 # see https://github.com/JuliaLang/julia/pull/40623
-const LU_RowMaximum = VERSION >= v"1.7.0-DEV.1188" ? RowMaximum() : Val(true)
-const LU_NoPivot = VERSION >= v"1.7.0-DEV.1188" ? NoPivot() : Val(false)
+const LU_RowMaximum = RowMaximum()
+const LU_NoPivot = NoPivot()
 
 # Adapted from (Julia v1.2) stdlib/v1.2/LinearAlgebra/src/lu.jl#240-253
 # and (Julia v1.4.0-dev) stdlib/LinearAlgebra/v1.4/src/lu.jl#270-274,

src/auxiliary.jl

@@ -244,6 +244,7 @@ Returns the type of the elements of the coefficients of `a`.
 
 # Dumb methods included to properly export normalize_taylor (if IntervalArithmetic is loaded)
 @inline normalize_taylor(a::AbstractSeries) = a
+@inline aff_normalize(a::AbstractSeries) = a
 
 
 ## _minorder

src/evaluate.jl

@@ -102,9 +102,16 @@ function evaluate(a::Taylor1{T}, dx::Taylor1{TaylorN{T}}) where {T<:NumberNotSer
 end
 
 
-# Evaluate a Taylor1{TaylorN{T}} on Vector{TaylorN} is interpreted
+# Evaluate a Taylor1{TaylorN{T}} on Vector{T} (or Vector{TaylorN{T}}) is interpreted
 # as a substitution on the TaylorN vars
-function evaluate(a::Taylor1{TaylorN{T}}, dx::Vector{TaylorN{T}}) where {T<:NumberNotSeries}
+function evaluate(a::Taylor1{TaylorN{T}}, dx::AbstractVector{S}) where {T<:NumberNotSeries, S<:NumberNotSeries}
+    @assert length(dx) == get_numvars()
+    suma = Taylor1( zero(a[0][0][1])*one(dx[1]), a.order)
+    suma.coeffs .= evaluate.(a[:], Ref(dx))
+    return suma
+end
+
+function evaluate(a::Taylor1{TaylorN{T}}, dx::AbstractVector{TaylorN{T}}) where {T<:NumberNotSeries}
     @assert length(dx) == get_numvars()
     suma = Taylor1( zero(a[0]), a.order)
     suma.coeffs .= evaluate.(a[:], Ref(dx))

test/aqua.jl

@@ -18,9 +18,6 @@ using Aqua
     for method_ambiguity in ambs
         @show method_ambiguity
     end
-    if VERSION < v"1.10.0-DEV"
-        @test length(ambs) == 0
-    end
 end
 
 @testset "Aqua tests (additional)" begin