Numbers as derivative orders (#297)

* Numbers as derivative orders

* restore unsetspace method

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.7.42"
+version = "0.7.43"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/ApproxFunBase.jl

@@ -112,13 +112,22 @@ uniontypedvec(A, B) = Union{typeof(A), typeof(B)}[A, B]
 convert_vector(v::AbstractVector) = convert(Vector, v)
 convert_vector(t::Tuple) = [t...]
 
+convert_vector_or_svector(v::AbstractVector) = convert(Vector, v)
+convert_vector_or_svector(t::Tuple) = SVector(t)
+
 promote_eltypeof(As...) = promote_eltypeof(As)
 # Avoid mapreduce for common cases, as it often suffers from poor type inference
 promote_eltypeof(As::Tuple{Any}) = eltype(As[1])
 promote_eltypeof(As::Tuple{Any,Any}) = promote_type(eltype(As[1]), eltype(As[2]))
 promote_eltypeof(As::Tuple{Any,Any,Any}) = promote_type(eltype(As[1]), eltype(As[2]), eltype(As[3]))
 promote_eltypeof(As::Union{AbstractArray, Tuple}) = mapfoldl(eltype, promote_type, As)
 
+assert_integer(::Integer) = nothing
+function assert_integer(k::Number)
+    @assert Integer(k) == k "order must be an integer"
+    return nothing
+end
+
 include("LinearAlgebra/LinearAlgebra.jl")
 include("Fun.jl")
 include("onehotvector.jl")

src/Operators/banded/CalculusOperator.jl

@@ -30,6 +30,7 @@ macro calculus_operator(Op)
         $ConcOp(sp::Space,k) = $ConcOp{typeof(sp),typeof(k),ApproxFunBase.prectype(sp)}(sp,k)
 
         $Op(sp::ApproxFunBase.UnsetSpace,k) = $ConcOp(sp,k)
+        $Op(sp::ApproxFunBase.UnsetSpace,k::Number) = $ConcOp(sp,k)
         $Op(sp::ApproxFunBase.UnsetSpace,k::Real) = $ConcOp(sp,k)
         $Op(sp::ApproxFunBase.UnsetSpace,k::Integer) = $ConcOp(sp,k)
 
@@ -183,7 +184,8 @@ end
 
 
 ## Map to canonical
-function DefaultDerivative(sp::Space,k::Integer)
+function DefaultDerivative(sp::Space, k::Number)
+    assert_integer(k)
     if typeof(canonicaldomain(sp)).name==typeof(domain(sp)).name
         # this is the normal default constructor
         csp=canonicalspace(sp)
@@ -212,7 +214,8 @@ function DefaultDerivative(sp::Space,k::Integer)
 end
 
 
-function DefaultIntegral(sp::Space,k::Integer)
+function DefaultIntegral(sp::Space, k::Number)
+    assert_integer(k)
     if typeof(canonicaldomain(sp)).name==typeof(domain(sp)).name
         # this is the normal default constructor
         csp=canonicalspace(sp)

src/Operators/general/InterlaceOperator.jl

@@ -47,7 +47,7 @@ function rangespace(A::VectorOrTupleOfOp)
         error("Cannot construct rangespace for $A as domain spaces are not compatible")
     end
     spl=map(rangespace, A)
-    ArraySpace(_convert_vector_or_svector(spl), first(spl))
+    ArraySpace(_convert_vector_promotetypes(spl), first(spl))
 end
 
 promotespaces(A::AbstractMatrix{<:Operator}) = promotespaces(Matrix(A))
@@ -178,12 +178,12 @@ InterlaceOperator(opsin::AbstractMatrix{<:Operator},::Type{DS}) where {DS<:Space
 InterlaceOperator(opsin::AbstractMatrix,S...) =
     InterlaceOperator(Matrix{Operator{promote_eltypeof(opsin)}}(promotespaces(opsin)),S...)
 
-_convert_vector_or_svector(v::AbstractVector) = convert_vector(v)
+_convert_vector_promotetypes(v::AbstractVector) = convert_vector(v)
 _uniontypes_svector(t) = SVector{length(t), mapfoldl(typeof, (x,y)->Union{x,y}, t)}(t)
-_convert_vector_or_svector(t::NTuple{2,Any}) = _uniontypes_svector(t)
-_convert_vector_or_svector(t::NTuple{3,Any}) = _uniontypes_svector(t)
-_convert_vector_or_svector(t::NTuple{4,Any}) = _uniontypes_svector(t)
-_convert_vector_or_svector(t::Tuple) = SVector{length(t), mapreduce(typeof, typejoin, t)}(t)
+_convert_vector_promotetypes(t::NTuple{2,Any}) = _uniontypes_svector(t)
+_convert_vector_promotetypes(t::NTuple{3,Any}) = _uniontypes_svector(t)
+_convert_vector_promotetypes(t::NTuple{4,Any}) = _uniontypes_svector(t)
+_convert_vector_promotetypes(t::Tuple) = SVector{length(t), mapreduce(typeof, typejoin, t)}(t)
 
 function InterlaceOperator(opsin::AbstractVector{<:Operator})
     ops = convert_vector(promotedomainspace(opsin))

src/Spaces/ProductSpaceOperators.jl

@@ -154,14 +154,7 @@ for TYP in (:SumSpace,:PiecewiseSpace)
     end
 end
 
-function hasconversion(a::SumSpace, b::Space)
-    for n=1:length(a.spaces)
-        if hasconversion(a.spaces[n],b) ≠ true
-            return false
-        end
-    end
-    return true
-end
+hasconversion(a::SumSpace, b::Space) = all(s -> hasconversion(s, b), a.spaces)
 
 function Conversion(a::SumSpace, b::Space)
     if !hasconversion(a, b)
@@ -230,20 +223,32 @@ end
 
 for (Op,OpWrap) in ((:Derivative,:DerivativeWrapper),(:Integral,:IntegralWrapper))
     @eval begin
-        $Op(S::PiecewiseSpace,k::Integer) =
-            $OpWrap(InterlaceOperator(Diagonal([map(s->$Op(s,k),components(S))...]),PiecewiseSpace),k)
-        function $Op(S::ArraySpace,k::Integer)
+        function $Op(S::PiecewiseSpace, k::Number)
+            assert_integer(k)
+            t = map(s->$Op(s,k),components(S))
+            D = Diagonal(convert_vector_or_svector(t))
+            O = InterlaceOperator(D, PiecewiseSpace)
+            $OpWrap(O,k)
+        end
+        function $Op(S::ArraySpace, k::Number)
+            assert_integer(k)
             ops = map(s->$Op(s,k),S)
-            $OpWrap(InterlaceOperator(Diagonal(ops),S,ArraySpace(reshape(rangespace.(ops),size(S)))),k)
+            RS = ArraySpace(reshape(map(rangespace, ops), size(S)))
+            O = InterlaceOperator(Diagonal(ops), S, RS)
+            $OpWrap(O,k)
         end
     end
 end
 
-function Derivative(S::SumSpace,k::Integer)
+function Derivative(S::SumSpace, k::Number)
+    assert_integer(k)
     # we want to map before we decompose, as the map may introduce
     # mixed bases.
     if typeof(canonicaldomain(S))==typeof(domain(S))
-        DerivativeWrapper(InterlaceOperator(Diagonal([map(s->Derivative(s,k),components(S))...]),SumSpace),k)
+        t = map(s->Derivative(s,k),components(S))
+        D = Diagonal(convert_vector_or_svector(t))
+        O = InterlaceOperator(D, SumSpace)
+        DerivativeWrapper(O,k)
     else
         DefaultDerivative(S,k)
     end
@@ -268,17 +273,24 @@ end
 
 ## Multiply components
 
-function Multiplication(f::Fun{PW},sp::PiecewiseSpace) where PW<:PiecewiseSpace
+function Multiplication(f::Fun{<:PiecewiseSpace}, sp::PiecewiseSpace)
     p=perm(domain(f).domains,domain(sp).domains)  # sort f
     vf=components(f)[p]
-
-    MultiplicationWrapper(f,InterlaceOperator(Diagonal([map(Multiplication,vf,sp.spaces)...]),PiecewiseSpace))
+    t = map(Multiplication,vf,sp.spaces)
+    D = Diagonal(convert_vector_or_svector(t))
+    O = InterlaceOperator(D, PiecewiseSpace)
+    MultiplicationWrapper(f, O)
 end
 
 Multiplication(f::Fun{SumSpace{SV1,D,R1}},sp::SumSpace{SV2,D,R2}) where {SV1,SV2,D,R1,R2} =
     MultiplicationWrapper(f,mapreduce(g->Multiplication(g,sp),+,components(f)))
-Multiplication(f::Fun,sp::SumSpace) =
-    MultiplicationWrapper(f,InterlaceOperator(Diagonal([map(s->Multiplication(f,s),components(sp))...]),SumSpace))
+
+function Multiplication(f::Fun, sp::SumSpace)
+    t = map(s->Multiplication(f,s),components(sp))
+    D = Diagonal(convert_vector_or_svector(t))
+    O = InterlaceOperator(D, SumSpace)
+    MultiplicationWrapper(f, O)
+end
 
 Multiplication(f::Fun, sp::PiecewiseSpace) = MultiplicationWrapper(f, Multiplication(Fun(f,sp),sp))