Move Static to an extension (#275)

* Move Static to an extension

* Bump version to 0.6.37

* Add tests

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunOrthogonalPolynomials"
 uuid = "b70543e2-c0d9-56b8-a290-0d4d6d4de211"
-version = "0.6.36"
+version = "0.6.37"
 
 [deps]
 ApproxFunBase = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
@@ -21,6 +21,12 @@ Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
+[weakdeps]
+Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
+
+[extensions]
+ApproxFunOrthogonalPolynomialsStaticExt = "Static"
+
 [compat]
 ApproxFunBase = "0.8.30"
 ApproxFunBaseTest = "0.1"
@@ -46,8 +52,9 @@ julia = "1.6"
 ApproxFunBaseTest = "a931bfaf-0cfd-4a5c-b69c-bf2eed002b43"
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
+Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["ApproxFunBaseTest", "Aqua", "Test", "StaticArrays", "LazyArrays"]
+test = ["ApproxFunBaseTest", "Aqua", "Test", "Static", "StaticArrays", "LazyArrays"]

ext/ApproxFunOrthogonalPolynomialsStaticExt.jl

@@ -0,0 +1,103 @@
+module ApproxFunOrthogonalPolynomialsStaticExt
+
+using ApproxFunOrthogonalPolynomials
+import ApproxFunOrthogonalPolynomials as AFOP
+using Static
+
+AFOP._onehalf(::Union{StaticInt, StaticFloat64}) = static(0.5)
+AFOP._minonehalf(@nospecialize(_::Union{StaticInt, StaticFloat64})) = static(-0.5)
+AFOP.isapproxminhalf(@nospecialize(a::StaticInt)) = AFOP.isequalminhalf(a)
+AFOP.isequalminhalf(@nospecialize(a::StaticInt)) = false
+AFOP.isequalhalf(@nospecialize(a::StaticInt)) = false
+
+AFOP.isapproxhalfoddinteger(@nospecialize(a::StaticInt)) = false
+function AFOP.isapproxhalfoddinteger(a::StaticFloat64)
+    x = mod(a, static(1))
+    x == AFOP._onehalf(x) || dynamic(x) ≈ 0.5
+end
+
+AFOP._maybetoint(x::StaticInt) = Int(x)
+
+function AFOP.BandedMatrix(S::AFOP.SubOperator{T,AFOP.ConcreteConversion{Chebyshev{DD,RR},
+                Ultraspherical{LT,DD,RR},T},
+                NTuple{2,UnitRange{Int}}}) where {T,LT<:StaticInt,DD,RR}
+    AFOP._BandedMatrix(S)
+end
+
+
+AFOP.hasconversion(C::Chebyshev, U::Ultraspherical{<:StaticInt}) = AFOP.domainscompatible(C,U)
+AFOP.hasconversion(U::Ultraspherical{<:StaticInt}, C::Chebyshev) = false
+
+@inline function AFOP._Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:StaticInt})
+    if AFOP.order(sp) == 1
+        cfs = AFOP.coefficients(f)
+        AFOP.MultiplicationWrapper(f,
+            AFOP.SpaceOperator(
+                AFOP.SymToeplitzOperator(cfs/2) +
+                    AFOP.HankelOperator(view(cfs,3:length(cfs))/(-2)),
+                sp, sp)
+        )
+    else
+        AFOP.ConcreteMultiplication(f,sp)
+    end
+end
+@static if VERSION >= v"1.8"
+    Base.@constprop aggressive AFOP.Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:StaticInt}) =
+        AFOP._Multiplication(f, sp)
+else
+    AFOP.Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:StaticInt}) = AFOP._Multiplication(f, sp)
+end
+
+function Base.getindex(M::AFOP.ConcreteConversion{<:Chebyshev,U,T},
+        k::Integer,j::Integer) where {T, U<:Ultraspherical{<:StaticInt}}
+   # order must be 1
+    if k==j==1
+        one(T)
+    elseif k==j
+        one(T)/2
+    elseif j==k+2
+        -one(T)/2
+    else
+        zero(T)
+    end
+end
+
+
+function Base.getindex(M::AFOP.ConcreteConversion{U1,U2,T},
+        k::Integer,j::Integer) where {DD,RR,
+            U1<:Ultraspherical{<:Union{Integer, StaticInt},DD,RR},
+            U2<:Ultraspherical{<:Union{Integer, StaticInt},DD,RR},T}
+    #  we can assume that λ==m+1
+    λ=AFOP.order(AFOP.rangespace(M))
+    c=λ-one(T)  # this supports big types
+    if k==j
+        c/(k - 2 + λ)
+    elseif j==k+2
+        -c/(k + λ)
+    else
+        zero(T)
+    end
+end
+
+AFOP.bandwidths(C::AFOP.ConcreteConversion{<:Chebyshev,
+                    <:Ultraspherical{<:StaticInt}}) = 0,2  # order == 1
+
+AFOP.bandwidths(C::AFOP.ConcreteConversion{<:Ultraspherical{<:Union{Integer,StaticInt}},
+                    <:Ultraspherical{<:Union{Integer,StaticInt}}}) = 0,2
+
+Base.stride(C::AFOP.ConcreteConversion{<:Chebyshev,<:Ultraspherical{<:StaticInt}}) = 2
+
+function AFOP.conversion_rule(a::Chebyshev, b::Ultraspherical{<:StaticInt})
+    if AFOP.domainscompatible(a,b)
+        a
+    else
+        AFOP.NoSpace()
+    end
+end
+
+AFOP.conversion_rule(a::Ultraspherical{<:Union{Integer, StaticInt}},
+        b::Ultraspherical{<:Union{Integer, StaticInt}}) =
+    AFOP._conversion_rule(a, b)
+
+
+end

src/ApproxFunOrthogonalPolynomials.jl

@@ -1,8 +1,7 @@
 module ApproxFunOrthogonalPolynomials
 using Base, LinearAlgebra, Reexport, BandedMatrices, BlockBandedMatrices,
             BlockArrays, FillArrays, FastTransforms, IntervalSets,
-            DomainSets, Statistics, SpecialFunctions, FastGaussQuadrature,
-            Static
+            DomainSets, Statistics, SpecialFunctions, FastGaussQuadrature
 
 @reexport using ApproxFunBase
 
@@ -142,33 +141,23 @@ const HalfOddInteger{T<:Integer} = Half{Odd{T}}
 
 # return 1/2, possibly preserving types but not being too fussy
 _onehalf(x) = onehalf(x)
-_onehalf(::Union{StaticInt, StaticFloat64}) = static(0.5)
 _onehalf(::Integer) = half(Odd(1))
 
 # return -1/2, possibly preserving types but not being too fussy
 _minonehalf(x) = -onehalf(x)
-_minonehalf(@nospecialize(_::Union{StaticInt, StaticFloat64})) = static(-0.5)
 _minonehalf(::Integer) = half(Odd(-1))
 
 isapproxminhalf(a) = a ≈ _minonehalf(a)
-isapproxminhalf(@nospecialize(a::StaticInt)) = isequalminhalf(a)
 isapproxminhalf(::Integer) = false
 
 isequalminhalf(x) = x == _minonehalf(x)
-isequalminhalf(@nospecialize(a::StaticInt)) = false
 isequalminhalf(::Integer) = false
 
 isequalhalf(x) = x == _onehalf(x)
-isequalhalf(@nospecialize(a::StaticInt)) = false
 isequalhalf(x::Integer) = false
 
 isapproxhalfoddinteger(a) = !isapproxinteger(a) && isapproxinteger(a+_onehalf(a))
 isapproxhalfoddinteger(a::HalfOddInteger) = true
-isapproxhalfoddinteger(@nospecialize(a::StaticInt)) = false
-function isapproxhalfoddinteger(a::StaticFloat64)
-    x = mod(a, static(1))
-    x == _onehalf(x) || dynamic(x) ≈ 0.5
-end
 isapproxhalfoddinteger(::Integer) = false
 
 include("bary.jl")
@@ -182,4 +171,8 @@ include("specialfunctions.jl")
 include("fastops.jl")
 include("show.jl")
 
+if !isdefined(Base, :get_extension)
+    include("../ext/ApproxFunOrthogonalPolynomialsStaticExt.jl")
+end
+
 end

src/Spaces/Spaces.jl

@@ -65,7 +65,7 @@ function _changepolybasis(v::StridedVector{T},
         v = normcheb ? ApproxFunBase.mul_coefficients(ConcreteConversion(C, Cc), v) : v
         vc = ultraconversion(v)
         normultra ? ApproxFunBase.mul_coefficients!(ConcreteConversion(Uc, U), vc) : vc
-    elseif order(U) isa Union{Integer, StaticInt}
+    elseif isinteger(order(U))
         coefficients(v, C, Ultraspherical(1,domain(U)), U)
     else
         cheb2ultra(v, strictconvert(T, order(U)); normcheb, normultra)
@@ -83,7 +83,7 @@ function _changepolybasis(v::StridedVector{T},
         v = normultra ? ApproxFunBase.mul_coefficients(ConcreteConversion(U, Uc), v) : v
         vc = ultraiconversion(v)
         normcheb ? ApproxFunBase.mul_coefficients!(ConcreteConversion(Cc, C), vc) : vc
-    elseif order(U) isa Union{Integer, StaticInt}
+    elseif isinteger(order(U))
         coefficients(v, U, Ultraspherical(1,domain(U)), C)
     else
         ultra2cheb(v, strictconvert(T, order(U)); normultra, normcheb)

src/Spaces/Ultraspherical/Ultraspherical.jl

@@ -132,8 +132,8 @@ spacescompatible(a::Ultraspherical,b::Ultraspherical) =
 hasfasttransform(::Ultraspherical) = true
 
 # these methods help with type-inference
-hasconversion(C::Chebyshev, U::Ultraspherical{<:Union{Int,StaticInt}}) = domainscompatible(C,U)
-hasconversion(U::Ultraspherical{<:Union{Int,StaticInt}}, C::Chebyshev) = false
+hasconversion(C::Chebyshev, U::Ultraspherical{<:Integer}) = domainscompatible(C,U)
+hasconversion(U::Ultraspherical{<:Integer}, C::Chebyshev) = false
 
 include("UltrasphericalOperators.jl")
 include("DirichletSpace.jl")

src/Spaces/Ultraspherical/UltrasphericalOperators.jl

@@ -29,9 +29,9 @@ Base.stride(M::ConcreteMultiplication{<:Ultraspherical,<:Chebyshev}) =
 Base.stride(M::ConcreteMultiplication{<:Ultraspherical,<:Ultraspherical}) =
     stride(M.f)
 
-@inline function _Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:Union{Integer,StaticInt}})
+@inline function _Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:Integer})
     if order(sp) == 1
-        cfs = f.coefficients
+        cfs = coefficients(f)
         MultiplicationWrapper(f,
             SpaceOperator(
                 SymToeplitzOperator(cfs/2) +
@@ -43,10 +43,10 @@ Base.stride(M::ConcreteMultiplication{<:Ultraspherical,<:Ultraspherical}) =
     end
 end
 @static if VERSION >= v"1.8"
-    Base.@constprop aggressive Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:Union{Integer,StaticInt}}) =
+    Base.@constprop aggressive Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:Integer}) =
         _Multiplication(f, sp)
 else
-    Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:Union{Integer,StaticInt}}) = _Multiplication(f, sp)
+    Multiplication(f::Fun{<:Chebyshev}, sp::Ultraspherical{<:Integer}) = _Multiplication(f, sp)
 end
 
 
@@ -199,7 +199,7 @@ function maxspace_rule(A::Ultraspherical, B::Ultraspherical)
 end
 
 function getindex(M::ConcreteConversion{<:Chebyshev,U,T},
-        k::Integer,j::Integer) where {T, U<:Ultraspherical{<:Union{Integer, StaticInt}}}
+        k::Integer,j::Integer) where {T, U<:Ultraspherical{<:Integer}}
    # order must be 1
     if k==j==1
         one(T)
@@ -215,8 +215,8 @@ end
 
 function getindex(M::ConcreteConversion{U1,U2,T},
         k::Integer,j::Integer) where {DD,RR,
-            U1<:Ultraspherical{<:Union{Integer, StaticInt},DD,RR},
-            U2<:Ultraspherical{<:Union{Integer, StaticInt},DD,RR},T}
+            U1<:Ultraspherical{<:Integer,DD,RR},
+            U2<:Ultraspherical{<:Integer,DD,RR},T}
     #  we can assume that λ==m+1
     λ=order(rangespace(M))
     c=λ-one(T)  # this supports big types
@@ -249,8 +249,8 @@ function getindex(M::ConcreteConversion{U1,U2,T},
 end
 
 
-bandwidths(C::ConcreteConversion{<:Chebyshev,<:Ultraspherical{<:Union{Integer,StaticInt}}}) = 0,2  # order == 1
-bandwidths(C::ConcreteConversion{<:Ultraspherical{<:Union{Integer,StaticInt}},<:Ultraspherical{<:Union{Integer,StaticInt}}}) = 0,2
+bandwidths(C::ConcreteConversion{<:Chebyshev,<:Ultraspherical{<:Integer}}) = 0,2  # order == 1
+bandwidths(C::ConcreteConversion{<:Ultraspherical{<:Integer},<:Ultraspherical{<:Integer}}) = 0,2
 
 function bandwidths(C::ConcreteConversion{<:Chebyshev,<:Ultraspherical})
     orderone = order(rangespace(C)) == 1
@@ -266,7 +266,7 @@ function bandwidths(C::ConcreteConversion{<:Ultraspherical,<:Ultraspherical})
     offbyone ? (0,2) : (0,ℵ₀)
 end
 
-Base.stride(C::ConcreteConversion{<:Chebyshev,<:Ultraspherical{<:Union{Integer,StaticInt}}}) = 2
+Base.stride(C::ConcreteConversion{<:Chebyshev,<:Ultraspherical{<:Integer}}) = 2
 Base.stride(C::ConcreteConversion{<:Ultraspherical,<:Ultraspherical}) = 2
 
 isdiag(::ConcreteConversion{<:Chebyshev,<:Ultraspherical}) = false
@@ -276,16 +276,14 @@ isdiag(::ConcreteConversion{<:Ultraspherical,<:Ultraspherical}) = false
 ## coefficients
 
 # return the space that has banded Conversion to the other
-function conversion_rule(a::Chebyshev,b::Ultraspherical{<:Union{Integer,StaticInt}})
+function conversion_rule(a::Chebyshev, b::Ultraspherical{<:Integer})
     if domainscompatible(a,b)
         a
     else
         NoSpace()
     end
 end
 
-conversion_rule(a::Ultraspherical{<:StaticInt}, b::Ultraspherical{<:StaticInt}) =
-    _conversion_rule(a, b)
 function conversion_rule(a::Ultraspherical{LT},b::Ultraspherical{LT}) where {LT}
     _conversion_rule(a, b)
 end

src/fastops.jl

@@ -10,9 +10,9 @@
 # Conversions
 #####
 
-function BandedMatrix(S::SubOperator{T,ConcreteConversion{Chebyshev{DD,RR},
+function _BandedMatrix(S::SubOperator{T,ConcreteConversion{Chebyshev{DD,RR},
                 Ultraspherical{LT,DD,RR},T},
-            NTuple{2,UnitRange{Int}}}) where {T,LT<:Union{Integer, StaticInt},DD,RR}
+                NTuple{2,UnitRange{Int}}}) where {T,LT,DD,RR}
     # we can assume order is 1
     ret = BandedMatrix{eltype(S)}(undef, size(S), bandwidths(S))
     kr,jr = parentindices(S)
@@ -32,6 +32,12 @@ function BandedMatrix(S::SubOperator{T,ConcreteConversion{Chebyshev{DD,RR},
     ret
 end
 
+function BandedMatrix(S::SubOperator{T,ConcreteConversion{Chebyshev{DD,RR},
+                Ultraspherical{LT,DD,RR},T},
+                NTuple{2,UnitRange{Int}}}) where {T,LT<:Integer,DD,RR}
+    _BandedMatrix(S)
+end
+
 function BandedMatrix(V::SubOperator{T,ConcreteConversion{Ultraspherical{LT1,DD,RR},Ultraspherical{LT2,DD,RR},T},
                                                                   NTuple{2,UnitRange{Int}}}) where {T,LT1,LT2,DD,RR}
 

src/show.jl

@@ -25,7 +25,7 @@ function show(io::IO,d::Ray)
 end
 
 ## Spaces
-_maybetoint(x::Union{Integer, StaticInt}) = Int(x)
+_maybetoint(x::Integer) = Int(x)
 _maybetoint(x) = x
 
 _spacename(io, ::Chebyshev) = print(io, "Chebyshev(")

test/UltrasphericalTest.jl

@@ -32,6 +32,15 @@ include("testutils.jl")
         @test_throws ArgumentError Conversion(Ultraspherical(2), Ultraspherical(1))
         @test_throws ArgumentError Conversion(Ultraspherical(3), Ultraspherical(1.9))
 
+        @test conversion_type(Chebyshev(), Ultraspherical(1)) ==
+            conversion_type(Chebyshev(), Ultraspherical(static(1))) == Chebyshev()
+
+        @test conversion_type(Ultraspherical(1), Ultraspherical(2)) ==
+            conversion_type(Ultraspherical(1), Ultraspherical(static(2))) ==
+            conversion_type(Ultraspherical(static(1)), Ultraspherical(2)) ==
+            conversion_type(Ultraspherical(static(1)), Ultraspherical(static(2))) ==
+            Ultraspherical(1)
+
         # Conversions from Chebyshev to Ultraspherical should lead to a small union of types
         Tallowed = Union{
             typeof(Conversion(Chebyshev(), Ultraspherical(1))),
@@ -74,7 +83,7 @@ include("testutils.jl")
             @inferred (() -> Conversion(Ultraspherical(1.0), Ultraspherical(3.5)))();
         end
 
-        for n in (2,5)
+        for n in (1,2,5)
             C1 = Conversion(Chebyshev(), Ultraspherical(n))
             C2 = Conversion(Chebyshev(), Ultraspherical(static(n)))
             @test C1[1:4, 1:4] == C2[1:4, 1:4]
@@ -87,6 +96,24 @@ include("testutils.jl")
         C2 = Conversion(Chebyshev(), Ultraspherical(half(Odd(3))))
         @test C1[1:4, 1:4] == C2[1:4, 1:4]
 
+        @test ApproxFunBase.hasconversion(Chebyshev(), Ultraspherical(1))
+        @test ApproxFunBase.hasconversion(Chebyshev(), Ultraspherical(static(1)))
+        @test !ApproxFunBase.hasconversion(Ultraspherical(2), Chebyshev())
+        @test !ApproxFunBase.hasconversion(Ultraspherical(static(2)), Chebyshev())
+        C1 = Conversion(Chebyshev(), Ultraspherical(1))
+        C2 = Conversion(Chebyshev(), Ultraspherical(static(1)))
+        @test bandwidths(C1) == bandwidths(C2) == (0,2)
+        for j in 1:4, i in 1:4
+            @test C1[i,j] == C2[i,j]
+        end
+
+        C1 = Conversion(Ultraspherical(1), Ultraspherical(2))
+        C2 = Conversion(Ultraspherical(1), Ultraspherical(static(2)))
+        @test bandwidths(C1) == bandwidths(C2) == (0,2)
+        for j in 1:4, i in 1:4
+            @test C1[i,j] == C2[i,j]
+        end
+
         f = Fun(x->x^2, Ultraspherical(0.5)) # Legendre
         CLC = Conversion(Ultraspherical(0.5), Chebyshev())
         @test !isdiag(CLC)
@@ -146,6 +173,14 @@ include("testutils.jl")
             C = (C2 * M) * C1
             @test space(C * f) == Ultraspherical(2)
             @test C * f ≈ Fun() * f
+
+            @testset "static" begin
+                for n in (1,2)
+                    M1 = Multiplication(Fun(), Ultraspherical(n))
+                    M2 = Multiplication(Fun(), Ultraspherical(static(n)))
+                    @test M1[1:4, 1:4] ≈ M2[1:4, 1:4]
+                end
+            end
         end
     end