Numbers as derivative orders (#63)

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunFourier"
 uuid = "59844689-9c9d-51bf-9583-5b794ec66d30"
-version = "0.3.5"
+version = "0.3.6"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -17,7 +17,7 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
 AbstractFFTs = "0.5, 1"
-ApproxFunBase = "0.7.34"
+ApproxFunBase = "0.7.43"
 ApproxFunBaseTest = "0.1"
 Aqua = "0.5"
 BandedMatrices = "0.16, 0.17"

src/ApproxFunFourier.jl

@@ -58,6 +58,9 @@ export Fourier, Taylor, Hardy, CosSpace, SinSpace, Laurent, PeriodicDomain
 include("utils.jl")
 include("Domains/Domains.jl")
 
+convert_vector_or_svector(v::AbstractVector) = convert(Vector, v)
+convert_vector_or_svector(t::Tuple) = SVector(t)
+
 for T in (:CosSpace,:SinSpace)
     @eval begin
         struct $T{D<:PeriodicDomain,R} <: Space{D,R}

src/FourierOperators.jl

@@ -100,7 +100,7 @@ rangespace(D::ConcreteDerivative{S}) where {S<:SinSpace} = iseven(D.order) ? D.s
 
 function getindex(D::ConcreteDerivative{CS,OT,T},k::Integer,j::Integer) where {CS<:CosSpace,OT,T}
     d=domain(D)
-    m=D.order
+    m=Int(D.order)
     C=convert(T,2/complexlength(d)*π)
 
     if k==j && mod(m,4)==0
@@ -118,7 +118,7 @@ end
 
 function getindex(D::ConcreteDerivative{CS,OT,T},k::Integer,j::Integer) where {CS<:SinSpace,OT,T}
     d=domain(D)
-    m=D.order
+    m=Int(D.order)
     C=convert(T,2/complexlength(d)*π)
 
     if k==j && mod(m,4)==0
@@ -136,13 +136,18 @@ end
 
 
 # Use Laurent derivative
-Derivative(S::Fourier{DD,RR},k::Integer) where {DD<:Circle,RR} =
+function Derivative(S::Fourier{<:Circle}, k::Number)
+    @assert Integer(k) == k "order must be an integer"
     DerivativeWrapper(Derivative(Laurent(S),k)*Conversion(S,Laurent(S)),k)
+end
 
-Integral(::CosSpace,m::Integer) =
-    error("Integral not defined for CosSpace.  Use Integral(CosSpace()|(2:∞)) if first coefficient vanishes.")
+Integral(::CosSpace, m::Number) =
+    error("Integral not defined for CosSpace.  Use Integral(CosSpace()|(2:Infinities.∞)) if first coefficient vanishes.")
 
-Integral(sp::SinSpace{<:PeriodicSegment}, m::Integer) = ConcreteIntegral(sp,m)
+function Integral(sp::SinSpace{<:PeriodicSegment}, m::Number)
+    @assert Integer(m) == m "order must be an integer"
+    ConcreteIntegral(sp,m)
+end
 
 bandwidths(D::ConcreteIntegral{<:SinSpace}) = iseven(D.order) ? (0,0) : (1,0)
 rangespace(D::ConcreteIntegral{<:CosSpace}) = iseven(D.order) ? D.space : SinSpace(domain(D))
@@ -151,7 +156,7 @@ rangespace(D::ConcreteIntegral{<:SinSpace}) = iseven(D.order) ? D.space : CosSpa
 function getindex(D::ConcreteIntegral{CS,OT,T},k::Integer,j::Integer) where {CS<:SinSpace,OT,T}
     d=domain(D)
     @assert isa(d,PeriodicSegment)
-    m=D.order
+    m=Int(D.order)
     C=convert(T,2/complexlength(d)*π)
 
 
@@ -168,7 +173,8 @@ function getindex(D::ConcreteIntegral{CS,OT,T},k::Integer,j::Integer) where {CS<
     end
 end
 
-function Integral(S::SubSpace{<:CosSpace,<:AbstractInfUnitRange{Int},<:PeriodicSegment},k::Integer)
+function Integral(S::SubSpace{<:CosSpace,<:AbstractInfUnitRange{Int},<:PeriodicSegment},k::Number)
+    @assert Integer(k) == k "order must be an integer"
     @assert first(S.indexes)==2
     ConcreteIntegral(S,k)
 end
@@ -181,7 +187,7 @@ rangespace(D::ConcreteIntegral{<:SubSpace{<:CosSpace,<:AbstractInfUnitRange{Int}
 function getindex(D::ConcreteIntegral{<:SubSpace{<:CosSpace,<:AbstractInfUnitRange{Int},<:PeriodicSegment}},
                   k::Integer,j::Integer)
     d=domain(D)
-    m=D.order
+    m=Int(D.order)
     T=eltype(D)
     C=convert(T,2/complexlength(d)*π)
 
@@ -192,7 +198,7 @@ function getindex(D::ConcreteIntegral{<:SubSpace{<:CosSpace,<:AbstractInfUnitRan
         elseif mod(m,4)==2
             -(C*k)^(-m)
         elseif mod(m,4)==1
-        (C*k)^(-m)
+            (C*k)^(-m)
         else   # mod(m,4)==3
             -(C*k)^(-m)
         end

src/LaurentOperators.jl

@@ -67,13 +67,25 @@ coefficienttimes(f::Fun{Laurent{DD,RR}},g::Fun{Laurent{DD,RR}}) where {DD,RR} =
 ## Derivative
 
 # override map definition
-Derivative(S::Hardy{s,DD},k::Integer) where {s,DD<:Circle} = ConcreteDerivative(S,k)
-Derivative(S::Hardy{s,DD},k::Integer) where {s,DD<:PeriodicSegment} = ConcreteDerivative(S,k)
-Derivative(S::Laurent{DD,RR},k::Integer) where {DD<:Circle,RR} =
-    DerivativeWrapper(InterlaceOperator(Diagonal([map(s->Derivative(s,k),S.spaces)...]),SumSpace),k)
+function Derivative(S::Hardy{<:Any,<:Circle}, k::Number)
+    @assert Integer(k) == k "order must be an integer"
+    ConcreteDerivative(S,k)
+end
+function Derivative(S::Hardy{<:Any,<:PeriodicSegment}, k::Number)
+    @assert Integer(k) == k "order must be an integer"
+    ConcreteDerivative(S,k)
+end
+function Derivative(S::Laurent{<:Circle}, k::Number)
+    @assert Integer(k) == k "order must be an integer"
+    t = map(s->Derivative(s,k), S.spaces)
+    v = convert_vector_or_svector(t)
+    D = Diagonal(v)
+    O = InterlaceOperator(D, SumSpace)
+    DerivativeWrapper(O,k)
+end
 
 bandwidths(D::ConcreteDerivative{Hardy{s,DD,RR}}) where {s,DD<:PeriodicSegment,RR}=(0,0)
-bandwidths(D::ConcreteDerivative{Hardy{s,DD,RR}}) where {s,DD<:Circle,RR}=s ? (0,D.order) : (D.order,0)
+bandwidths(D::ConcreteDerivative{Hardy{s,DD,RR}}) where {s,DD<:Circle,RR}=s ? (-D.order,D.order) : (D.order,-D.order)
 
 rangespace(D::ConcreteDerivative{S}) where {S<:Hardy}=D.space