Release 0.9 (#518)

* Drop support for Julia versions below v1.9 (#513)

* Remove Test as a dependency (#514)

* Remove InfiniteLinearAlgebra dependency (#510)

* Remove explicit dependency on InfiniteLinearAlgebra

* bump version to v0.8.46

* Make constant propagation unconditional (#515)

* Remove Vec (#517)

Author: jishnub

.github/workflows/ci.yml

@@ -39,7 +39,6 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.6'
           - '1'
           - '~1.10.0-0'
         os:

.github/workflows/downstream.yml

@@ -31,7 +31,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        julia-version: ['1', '1.6']
+        julia-version: ['1']
         os: [ubuntu-latest]
         package:
           - {repo: ApproxFun.jl, group: JuliaApproximation}

ApproxFunBaseTest/Project.toml

@@ -14,7 +14,7 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
-ApproxFunBase = "0.5, 0.6, 0.7, 0.8"
+ApproxFunBase = "0.5, 0.6, 0.7, 0.8, 0.9"
 BandedMatrices = "0.16, 0.17"
 BlockArrays = "0.14, 0.15, 0.16"
 BlockBandedMatrices = "0.10, 0.11, 0.12"

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.8.46"
+version = "0.9.0"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -15,7 +15,6 @@ DualNumbers = "fa6b7ba4-c1ee-5f82-b5fc-ecf0adba8f74"
 FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 InfiniteArrays = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
-InfiniteLinearAlgebra = "cde9dba0-b1de-11e9-2c62-0bab9446c55c"
 IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"
 LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -24,7 +23,6 @@ SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
-Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [compat]
 AbstractFFTs = "0.5, 1"
@@ -39,20 +37,20 @@ DomainSets = "0.5, 0.6"
 DualNumbers = "0.6.2"
 FFTW = "0.3, 1"
 FillArrays = "0.11, 0.12, 0.13, 1"
-InfiniteArrays = "0.11, 0.12, 0.13"
-InfiniteLinearAlgebra = "0.5, 0.6"
+InfiniteArrays = "0.13"
 Infinities = "0.1"
 IntervalSets = "0.5, 0.6, 0.7"
 LazyArrays = "0.20, 0.21, 0.22, 1"
 LowRankMatrices = "1"
 SpecialFunctions = "0.10, 1.0, 2"
 StaticArrays = "0.12, 1.0"
-julia = "1.6"
+julia = "1.9"
 
 [extras]
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 Infinities = "e1ba4f0e-776d-440f-acd9-e1d2e9742647"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Aqua", "Random", "Infinities"]
+test = ["Aqua", "Random", "Infinities", "Test"]

src/ApproxFunBase.jl

@@ -4,21 +4,21 @@ using AbstractFFTs
 using BandedMatrices
 using BlockArrays
 using BlockBandedMatrices
+import Calculus
+import Combinatorics: multiexponents
 using DSP
 using DomainSets
 using DualNumbers
 using FFTW
 using FillArrays
 using InfiniteArrays
-using InfiniteLinearAlgebra
 using IntervalSets
 using LinearAlgebra
 using LowRankMatrices
 using SparseArrays
 using SpecialFunctions
-
-import Calculus
 using StaticArrays: SVector, @SArray, SArray
+import Statistics: mean
 
 import DomainSets: Domain, indomain, UnionDomain, ProductDomain, Point, ∂,
               SetdiffDomain, Interval, ChebyshevInterval, boundary,
@@ -52,10 +52,6 @@ import Base: values, convert, getindex, setindex!, *, +, -, ==, <, <=, >, |, !,
 import Base.Broadcast: BroadcastStyle, Broadcasted, AbstractArrayStyle,
               broadcastable, DefaultArrayStyle, broadcasted
 
-import Statistics: mean
-
-import Combinatorics: multiexponents
-
 import LinearAlgebra: BlasInt, BlasFloat, norm, ldiv!, mul!, det, cross,
               qr, qr!, rank, isdiag, istril, istriu, issymmetric,
               Tridiagonal, diagm, diagm_container, factorize,
@@ -105,8 +101,6 @@ import DomainSets: dimension
 
 import IntervalSets: (..), endpoints
 
-const Vec{d,T} = SVector{d,T}
-
 export pad!, pad, chop!, sample,
        complexroots, roots,
        reverseorientation
@@ -164,7 +158,6 @@ include("PDE/PDE.jl")
 include("Spaces/Spaces.jl")
 include("eigen.jl")
 include("hacks.jl")
-include("testing.jl")
 include("specialfunctions.jl")
 include("show.jl")
 

src/Fun.jl

@@ -594,12 +594,7 @@ end
 
 \(c::Number, f::Fun) = Fun(f.space, c \ f.coefficients)
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive intpow(f::Fun, k::Integer) = _intpow(f, k)
-else
-    intpow(f::Fun, k::Integer) = _intpow(f, k)
-end
-@inline function _intpow(f, k)
+Base.@constprop :aggressive function intpow(f, k)
     if k == 0
         ones(cfstype(f), space(f))
     elseif k==1

src/Multivariate/TensorSpace.jl

@@ -358,21 +358,14 @@ Space(sp::ProductDomain) = TensorSpace(sp)
 setdomain(sp::TensorSpace, d::ProductDomain) = TensorSpace(setdomain.(factors(sp), factors(d)))
 
 *(A::Space, B::Space) = A ⊗ B
-@inline function _powspace(A, p)
+Base.@constprop :aggressive function ^(A::Space, p::Integer)
     p >= 1 || throw(ArgumentError("exponent must be >= 1, received $p"))
     # Enumerate common cases to help with constant propagation
     p == 1 ? A :
     p == 2 ? A * A :
     p == 3 ? A * A * A :
     foldl(*, ntuple(_ -> A, p))
 end
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive function ^(A::Space, p::Integer)
-        _powspace(A, p)
-    end
-else
-    ^(A::Space, p::Integer) = _powspace(A, p)
-end
 
 
 ## TODO: generalize

src/Operators/banded/CalculusOperator.jl

@@ -191,7 +191,7 @@ end
 
 
 ## Map to canonical
-@inline function _DefaultDerivative(sp::Space, k::Number)
+Base.@constprop :aggressive function DefaultDerivative(sp::Space, k::Number)
     assert_integer(k)
     if nameof(typeof(canonicaldomain(sp))) == nameof(typeof(domain(sp)))
         # this is the normal default constructor
@@ -222,19 +222,7 @@ end
     end
 end
 
-@static if VERSION >= v"1.8"
-    for f in (:DefaultDerivative, :DefaultIntegral)
-        _f = Symbol(:_, f)
-        @eval Base.@constprop :aggressive $f(sp::Space, k::Number) = $_f(sp, k)
-    end
-else
-    for f in (:DefaultDerivative, :DefaultIntegral)
-        _f = Symbol(:_, f)
-        @eval $f(sp::Space, k::Number) = $_f(sp, k)
-    end
-end
-
-@inline function _DefaultIntegral(sp::Space, k::Number)
+Base.@constprop :aggressive function DefaultIntegral(sp::Space, k::Number)
     assert_integer(k)
     if nameof(typeof(canonicaldomain(sp))) == nameof(typeof(domain(sp)))
         # this is the normal default constructor

src/Operators/general/CachedOperator.jl

@@ -24,16 +24,7 @@ CachedOperator(op::Operator,data::AbstractMatrix,sz::Tuple{Int,Int},pd=false) =
 CachedOperator(op::Operator,data::AbstractMatrix,padding=false) = CachedOperator(op,data,size(data),padding)
 
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive function default_CachedOperator(op::Operator;padding::Bool=false)
-        _default_CachedOperator(op, padding)
-    end
-else
-    function default_CachedOperator(op::Operator;padding::Bool=false)
-        _default_CachedOperator(op, padding)
-    end
-end
-@inline function _default_CachedOperator(op::Operator, padding)
+Base.@constprop :aggressive function default_CachedOperator(op::Operator; padding::Bool=false)
     if isbanded(op)
         CachedOperator(BandedMatrix, op; padding=padding)
     elseif isbandedblockbanded(op) && !padding

src/Operators/general/InterlaceOperator.jl

@@ -90,12 +90,6 @@ end
 const VectorInterlaceOperator = InterlaceOperator{T,1,DS,RS} where {T,DS,RS<:Space{D,R}} where {D,R<:AbstractVector}
 const MatrixInterlaceOperator = InterlaceOperator{T,2,DS,RS} where {T,DS,RS<:Space{D,R}} where {D,R<:AbstractVector}
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive interlace_bandwidths(args...) = _interlace_bandwidths(args...)
-else
-    interlace_bandwidths(args...) = _interlace_bandwidths(args...)
-end
-
 __interlace_ops_bandwidths(ops::AbstractMatrix) = bandwidths.(ops)
 __interlace_ops_bandwidths(ops::Diagonal) = bandwidths.(parent(ops))
 function __interlace_bandwidths_square(ops::AbstractMatrix, bw = __interlace_ops_bandwidths(ops))
@@ -119,8 +113,11 @@ function __interlace_bandwidths_square(ops::Diagonal, bw = __interlace_ops_bandw
     l,u
 end
 
-@inline function _interlace_bandwidths(ops::AbstractMatrix{<:Operator}, ds, rs,
-        allbanded = all(isbanded,ops), bw = allbanded ? __interlace_ops_bandwidths(ops) : nothing)
+Base.@constprop :aggressive function interlace_bandwidths(ops::AbstractMatrix{<:Operator},
+        ds, rs,
+        allbanded = all(isbanded, ops),
+        bw = allbanded ? __interlace_ops_bandwidths(ops) : nothing)
+
     p=size(ops,1)
     dsi = interlacer(ds)
     rsi = interlacer(rs)
@@ -159,7 +156,7 @@ function InterlaceOperator(ops::AbstractMatrix{<:Operator},ds::Space,rs::Space;
                         israggedbelow)
 end
 
-@inline function _interlace_bandwidths(ops::VectorOrTupleOfOp, ds, rs, allbanded = all(isbanded, ops))
+Base.@constprop :aggressive function interlace_bandwidths(ops::VectorOrTupleOfOp, ds, rs, allbanded = all(isbanded, ops))
     p=size(ops,1)
     ax1 = first(axes(ops))
     if allbanded
@@ -210,19 +207,10 @@ function InterlaceOperator(opsin::AbstractVector{<:Operator})
     ops = convert_vector(promotedomainspace(opsin))
     InterlaceOperator(ops, domainspace(first(ops)), rangespace(ops))
 end
-@inline function _InterlaceOperator(opsin, promotedomain)
+Base.@constprop :aggressive function InterlaceOperator(opsin, promotedomain = true)
     ops = promotedomain ? promotedomainspace(opsin) : opsin
     InterlaceOperator(ops, domainspace(first(ops)), rangespace(ops))
 end
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive function InterlaceOperator(opsin::Tuple{Operator, Vararg{Operator}}, promotedomain = true)
-        _InterlaceOperator(opsin, promotedomain)
-    end
-else
-    function InterlaceOperator(opsin::Tuple{Operator, Vararg{Operator}}, promotedomain = true)
-        _InterlaceOperator(opsin, promotedomain)
-    end
-end
 
 InterlaceOperator(ops::AbstractArray, ds=NoSpace, rs=ds) =
     InterlaceOperator(Array{Operator{promote_eltypeof(ops)}, ndims(ops)}(ops), ds, rs)

src/Operators/general/algebra.jl

@@ -250,34 +250,18 @@ struct TimesOperator{T,BW,SZ,O<:Operator{T},BBW,SBBW} <: Operator{T}
     israggedbelow::Bool
     isafunctional::Bool
 
-    @static if VERSION >= v"1.8"
-        Base.@constprop :aggressive function TimesOperator{T,BW,SZ,O,BBW,SBBW}(ops::Vector{O}, bw::BW,
-                sz::SZ, bbw::BBW, sbbw::SBBW,
-                ibbb::Bool, irb::Bool, isaf::Bool;
-                anytimesop = any(x -> x isa TimesOperator, ops)) where {T,O<:Operator{T},BW,SZ,BBW,SBBW}
-
-            # check compatible
-            check_times(ops)
-
-            # remove TimesOperators buried inside ops
-            newops = anytimesop ? splice_times(ops) : ops
-
-            new{T,BW,SZ,O,BBW,SBBW}(newops, bw, sz, bbw, sbbw, ibbb, irb, isaf)
-        end
-    else
-        function TimesOperator{T,BW,SZ,O,BBW,SBBW}(ops::Vector{O}, bw::BW,
-                sz::SZ, bbw::BBW, sbbw::SBBW,
-                ibbb::Bool, irb::Bool, isaf::Bool;
-                anytimesop = any(x -> x isa TimesOperator, ops)) where {T,O<:Operator{T},BW,SZ,BBW,SBBW}
+    Base.@constprop :aggressive function TimesOperator{T,BW,SZ,O,BBW,SBBW}(ops::Vector{O}, bw::BW,
+            sz::SZ, bbw::BBW, sbbw::SBBW,
+            ibbb::Bool, irb::Bool, isaf::Bool;
+            anytimesop = any(x -> x isa TimesOperator, ops)) where {T,O<:Operator{T},BW,SZ,BBW,SBBW}
 
-            # check compatible
-            check_times(ops)
+        # check compatible
+        check_times(ops)
 
-            # remove TimesOperators buried inside ops
-            newops = anytimesop ? splice_times(ops) : ops
+        # remove TimesOperators buried inside ops
+        newops = anytimesop ? splice_times(ops) : ops
 
-            new{T,BW,SZ,O,BBW,SBBW}(newops, bw, sz, bbw, sbbw, ibbb, irb, isaf)
-        end
+        new{T,BW,SZ,O,BBW,SBBW}(newops, bw, sz, bbw, sbbw, ibbb, irb, isaf)
     end
 end
 
@@ -334,13 +318,7 @@ function convert(::Type{Operator{T}}, P::TimesOperator) where {T}
     end
 end
 
-
-@static if VERSION > v"1.8"
-    Base.@constprop :aggressive promotetimes(args...) = _promotetimes(args...)
-else
-    promotetimes(args...) = _promotetimes(args...)
-end
-@inline function _promotetimes(opsin,
+Base.@constprop :aggressive function promotetimes(opsin,
         dsp=domainspace(last(opsin)),
         anytimesop=true)
 
@@ -666,22 +644,14 @@ end
 -(A::Operator) = ConstantTimesOperator(-1, A)
 -(A::Operator, B::Operator) = A + (-B)
 
-@inline function _mulop(f::Fun, A::Operator)
+Base.@constprop :aggressive function *(f::Fun, A::Operator)
     if isafunctional(A) && (isinf(bandwidth(A, 1)) || isinf(bandwidth(A, 2)))
         LowRankOperator(f, A)
     else
         TimesOperator(Multiplication(f, rangespace(A)), A)
     end
 end
 
-@static if VERSION >= v"1.8"
-    Base.@constprop :aggressive function *(f::Fun, A::Operator)
-        _mulop(f, A)
-    end
-else
-    *(f::Fun, A::Operator) = _mulop(f, A)
-end
-
 *(c::Number, A::Operator) = ConstantTimesOperator(c, A)
 *(A::Operator, c::Number) = c * A