Spaces in Conversion, Multiplication and Evaluation wrapper (#384)

* spaces in Conversion, Multiplication and Evaluation wrapper

* version bump to v0.7.75

* fix MultiplicationWrapper dispatch

* bump version to v0.8.0

* rangespace in DerivativeWrapper

Author: jishnub

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"
+ApproxFunBase = "0.5, 0.6, 0.7, 0.8"
 BandedMatrices = "0.16, 0.17"
 BlockArrays = "0.14, 0.15, 0.16"
 BlockBandedMatrices = "0.10, 0.11"

Project.toml

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

src/Operators/Operator.jl

@@ -611,16 +611,20 @@ end
 # use this for wrapper operators that have the same spaces but
 # not necessarily the same entries or structure
 #
-macro wrapperspaces(Wrap, forwarddomain = true)
-    fns = [:(ApproxFunBase.rangespace),:(ApproxFunBase.domain), :(ApproxFunBase.isconstop)]
+macro wrapperspaces(Wrap, forwarddomain = true, forwardrange = true)
+    fns = [:(ApproxFunBase.isconstop)]
     if forwarddomain
         fns = [fns; :(ApproxFunBase.domainspace)]
     end
+    if forwardrange
+        fns = [fns; :(ApproxFunBase.rangespace)]
+    end
     v = map(fns) do func
         :($func(D::$Wrap) = $func(D.op))
     end
     ret = quote
         $(v...)
+        ApproxFunBase.domain(D::$Wrap) = domain(domainspace(D))
     end
 
     esc(ret)
@@ -629,10 +633,10 @@ end
 
 # use this for wrapper operators that have the same entries and same spaces
 #
-macro wrapper(Wrap, forwarddomain = true)
+macro wrapper(Wrap, forwarddomain = true, forwardrange = true)
     ret = quote
         ApproxFunBase.@wrappergetindex($Wrap)
-        ApproxFunBase.@wrapperspaces($Wrap, $forwarddomain)
+        ApproxFunBase.@wrapperspaces($Wrap, $forwarddomain, $forwardrange)
 
         ApproxFunBase.iswrapper(::$Wrap) = true
     end
@@ -641,6 +645,8 @@ macro wrapper(Wrap, forwarddomain = true)
     esc(ret)
 end
 
+unwrap(A::Operator) = iswrapper(A) ? A.op : A
+
 ## Standard Operators and linear algebra
 
 

src/Operators/banded/CalculusOperator.jl

@@ -10,22 +10,24 @@ macro calculus_operator(Op)
     ConcOp = Symbol(:Concrete, Op)
     WrappOp = Symbol(Op, :Wrapper)
     DefaultOp = Symbol(:Default, Op)
-    return esc(quote
+    q = quote
         # The SSS, TTT are to work around #9312
         abstract type $Op{SSS,OT,TTT} <: ApproxFunBase.CalculusOperator{SSS,OT,TTT} end
 
         struct $ConcOp{S<:Space,OT,T} <: $Op{S,OT,T}
             space::S        # the domain space
             order::OT
         end
-        struct $WrappOp{BT<:Operator,S<:Space,OT,T} <: $Op{S,OT,T}
+        struct $WrappOp{BT<:Operator,S<:Space,R<:Space,OT,T} <: $Op{S,OT,T}
             op::BT
             order::OT
-            space::S
+            domainspace::S
+            rangespace::R
         end
 
-        ApproxFunBase.@wrapper $WrappOp false # the false doesn't forward the domain space
-        ApproxFunBase.domainspace(A::$WrappOp) = A.space
+        ApproxFunBase.@wrapper $WrappOp false false
+        ApproxFunBase.domainspace(A::$WrappOp) = A.domainspace
+        ApproxFunBase.rangespace(A::$WrappOp) = A.rangespace
 
         ## Constructors
         $ConcOp(sp::Space,k) = $ConcOp{typeof(sp),typeof(k),ApproxFunBase.prectype(sp)}(sp,k)
@@ -35,12 +37,15 @@ macro calculus_operator(Op)
         $Op(sp::ApproxFunBase.UnsetSpace,k::Real) = $ConcOp(sp,k)
         $Op(sp::ApproxFunBase.UnsetSpace,k::Integer) = $ConcOp(sp,k)
 
-        function $DefaultOp(sp::Space,k)
+        function $DefaultOp(sp::Space, k)
             csp=ApproxFunBase.canonicalspace(sp)
             if ApproxFunBase.conversion_type(csp,sp)==csp   # Conversion(sp,csp) is not banded, or sp==csp
                error("Implement $(string($Op))($(string(sp)),$k)")
             end
-            $WrappOp(ApproxFunBase.TimesOperator([$Op(csp,k),Conversion(sp,csp)]),k)
+            O = $Op(csp,k)
+            C = Conversion_maybeconcrete(sp, csp, Val(:forward))
+            Top = ApproxFunBase.TimesOperator([O,C])
+            $WrappOp(Top, sp, k, rangespace(O))
         end
 
         $DefaultOp(d,k) = $Op(Space(d),k)
@@ -57,33 +62,31 @@ macro calculus_operator(Op)
             if T==eltype(D)
                 D
             else
-                $ConcOp{typeof(D.space),typeof(D.order),T}(D.space,D.order)
+                $ConcOp{typeof(D.space),typeof(D.order),T}(D.space, D.order)
             end
         end
 
-        $WrappOp(op::Operator,d,order) =
-            $WrappOp{typeof(op),typeof(d),typeof(order),eltype(op)}(op,order,d)
-        $WrappOp(op::Operator,order) = $WrappOp(op, domainspace(op), order)
-        $WrappOp(op::Operator) = $WrappOp(op,1)
+        $WrappOp(op::Operator, order = 1, d = domainspace(op), r = rangespace(op)) =
+            $WrappOp{typeof(op),typeof(d),typeof(r),typeof(order),eltype(op)}(op,order,d,r)
 
         function Base.convert(::Type{Operator{T}},D::$WrappOp) where T
             if T==eltype(D)
                 D
             else
-                # work around typeinfernece bug
                 op=ApproxFunBase.strictconvert(Operator{T},D.op)
-                S = domainspace(op)
-                $WrappOp{typeof(op),typeof(S),typeof(D.order),T}(op,D.order,S)::Operator{T}
+                S = domainspace(D)
+                R = rangespace(D)
+                $WrappOp(op,D.order,S,R)::Operator{T}
             end
         end
 
         ## Routines
-        ApproxFunBase.domain(D::$ConcOp) = domain(D.space)
         ApproxFunBase.domainspace(D::$ConcOp) = D.space
 
         Base.getindex(::$ConcOp{UnsetSpace,OT,T},k::Integer,j::Integer) where {OT,T} =
             error("Spaces cannot be inferred for operator")
-            ApproxFunBase.rangespace(D::$ConcOp{UnsetSpace,T}) where {T} = UnsetSpace()
+
+        ApproxFunBase.rangespace(D::$ConcOp{UnsetSpace,T}) where {T} = UnsetSpace()
 
         #promoting domain space is allowed to change range space
         # for integration, we fall back on existing conversion for now
@@ -97,11 +100,9 @@ macro calculus_operator(Op)
                 $Op(sp,D.order)
             end
         end
-    end)
-#     for func in (:rangespace,:domainspace,:bandwidths)
-#         # We assume the operator wrapped has the correct spaces
-#         @eval $func(D::$WrappOp)=$func(D.op)
-#     end
+    end
+
+    return esc(q)
 end
 
 choosedomainspace(M::CalculusOperator{UnsetSpace},sp::Space) =
@@ -194,7 +195,9 @@ end
         if conversion_type(csp,sp)==csp   # Conversion(sp,csp) is not banded, or sp==csp
            error("Implement Derivative(", sp, ",", k,")")
         end
-        DerivativeWrapper(TimesOperator(Derivative(csp,k),Conversion(sp,csp)), sp, k)
+        D = Derivative(csp,k)
+        C = Conversion_maybeconcrete(sp, csp, Val(:forward))
+        DerivativeWrapper(TimesOperator(D, C), k, sp, rangespace(D))
     else
         csp = canonicalspace(sp)
         D1 = if csp == sp
@@ -204,13 +207,13 @@ end
         else
             Dcsp = Derivative(csp)
             rsp = rangespace(Dcsp)
-            Dcsp * Conversion(sp, csp)
+            Dcsp * Conversion_maybeconcrete(sp, csp, Val(:forward))
         end
         D=DerivativeWrapper(SpaceOperator(D1,sp,setdomain(rsp,domain(sp))),1)
         if k==1
             D
         else
-            DerivativeWrapper(TimesOperator(Derivative(rangespace(D),k-1),D), sp, k)
+            DerivativeWrapper(TimesOperator(Derivative(rangespace(D),k-1),D), k, sp)
         end
     end
 end

src/Operators/banded/Conversion.jl

@@ -2,21 +2,25 @@ export Conversion
 
 abstract type Conversion{T}<:Operator{T} end
 
-struct ConcreteConversion{S<:Space,V<:Space,T} <: Conversion{T}
-    domainspace::S
-    rangespace::V
+struct ConcreteConversion{D<:Space,R<:Space,T} <: Conversion{T}
+    domainspace::D
+    rangespace::R
 end
 
 
-ConcreteConversion(a::Space,b::Space)=ConcreteConversion{typeof(a),typeof(b),
-        promote_type(rangetype(a),rangetype(b))}(a,b)
-
+function ConcreteConversion(::Type{T}, a::Space,b::Space) where {T}
+    ConcreteConversion{typeof(a),typeof(b),T}(a,b)
+end
+function ConcreteConversion(a::Space,b::Space)
+    T = promote_type(rangetype(a),rangetype(b))
+    ConcreteConversion(T, a, b)
+end
 
-function convert(::Type{Operator{T}},C::ConcreteConversion{S,V}) where {T,S,V}
+function convert(::Type{Operator{T}}, C::ConcreteConversion) where {T}
     if T==eltype(C)
         C
     else
-        ConcreteConversion{S,V,T}(C.domainspace,C.rangespace)
+        ConcreteConversion(T, C.domainspace,C.rangespace)::Operator{T}
     end
 end
 
@@ -54,6 +58,34 @@ function defaultConversion(a::Space,b::Space)
     end
 end
 
+"""
+    hasconcreteconversion_canonical(sp::Space, ::Val{:forward})
+
+Return `Conversion(sp, canonicalspace(sp))` is known statically to be a `ConcreteConversion`.
+Assumed to be false by default.
+
+    hasconcreteconversion_canonical(sp::Space, ::Val{:backward})
+
+Return `Conversion(canonicalspace(sp), sp)` is known statically to be a `ConcreteConversion`.
+Assumed to be false by default.
+"""
+hasconcreteconversion_canonical(@nospecialize(sp), @nospecialize(Valfwdback)) = false
+
+function Conversion_maybeconcrete(sp, csp, v::Val{:forward})
+    if hasconcreteconversion_canonical(sp, v)
+        ConcreteConversion(sp,csp)
+    else
+        Conversion(sp,csp)
+    end
+end
+function Conversion_maybeconcrete(sp, csp, v::Val{:backward})
+    if hasconcreteconversion_canonical(sp, v)
+        ConcreteConversion(csp,sp)
+    else
+        Conversion(csp,sp)
+    end
+end
+
 """
     Conversion(fromspace::Space, tospace::Space)
 
@@ -72,21 +104,25 @@ Conversion() = ConversionWrapper(Operator(I,UnsetSpace()))
 # the domain and range space
 # but continue to know its a derivative
 
-struct ConversionWrapper{S<:Operator,T} <: Conversion{T}
-    op::S
+struct ConversionWrapper{D<:Space,R<:Space,T,O<:Operator{T}} <: Conversion{T}
+    domainspace::D
+    rangespace::R
+    op::O
 end
 
-@wrapper ConversionWrapper
+@wrapper ConversionWrapper false false
 
+domainspace(C::ConversionWrapper) = C.domainspace
+rangespace(C::ConversionWrapper) = C.rangespace
 
-ConversionWrapper(::Type{T},op) where {T} = ConversionWrapper{typeof(op),T}(op)
-ConversionWrapper(B::Operator) =
-    ConversionWrapper{typeof(B),eltype(B)}(B)
-ConversionWrapper(C::ConversionWrapper) = C
+function ConversionWrapper(B::Operator,
+        d::Space=domainspace(B), r::Space=rangespace(B))
+    ConversionWrapper(d, r, unwrap(B))
+end
 Conversion(A::Space,B::Space,C::Space) =
-    ConversionWrapper(Conversion(B,C)*Conversion(A,B))
+    ConversionWrapper(Conversion(B,C)*Conversion(A,B), A, C)
 Conversion(A::Space,B::Space,C::Space,D::Space...) =
-    ConversionWrapper(Conversion(C,D...)*Conversion(B,C)*Conversion(A,B))
+    ConversionWrapper(Conversion(C,D...)*Conversion(B,C)*Conversion(A,B), A, last(D))
 
 ==(A::ConversionWrapper,B::ConversionWrapper) = A.op==B.op
 
@@ -96,7 +132,8 @@ function convert(::Type{Operator{T}},D::ConversionWrapper) where T
         D
     else
         BO=strictconvert(Operator{T},D.op)
-        ConversionWrapper{typeof(BO),T}(BO)
+        d, r = domainspace(D), rangespace(D)
+        ConversionWrapper(d, r, BO)::Operator{T}
     end
 end
 

src/Operators/banded/Multiplication.jl

@@ -35,7 +35,7 @@ function defaultMultiplication(f::Fun,sp::Space)
     if csp==sp || !hasconversion(sp,csp)
         error("Implement Multiplication(::Fun{$(typeof(space(f)))},::$(typeof(sp)))")
     end
-    MultiplicationWrapper(f,Multiplication(f,csp)*Conversion(sp,csp))
+    MultiplicationWrapper(f, Multiplication(f,csp)*Conversion(sp,csp), sp)
 end
 
 Multiplication(f::Fun,sp::Space) = defaultMultiplication(f,sp)
@@ -90,26 +90,34 @@ choosedomainspace(M::ConcreteMultiplication{D,UnsetSpace},sp::Space) where {D} =
 
 diagm(a::Fun) = Multiplication(a)
 
-struct MultiplicationWrapper{D<:Space,S<:Space,O<:Operator,T} <: Multiplication{D,S,T}
+struct MultiplicationWrapper{D<:Space,S<:Space,T,O<:Operator{T}} <: Multiplication{D,S,T}
     f::VFun{D,T}
     op::O
+    space::S
+
+    function MultiplicationWrapper{D,S,T,O}(f::Fun{D,T},op::O,space::S) where {D,S,T,O<:Operator{T}}
+        new{D,S,T,O}(f,op,space)
+    end
 end
 
 function MultiplicationWrapper(::Type{T}, f::Fun{D}, op::Operator,
-        dspop::S = domainspace(op)) where {D,T,S<:Space}
-    MultiplicationWrapper{D,S,typeof(op),T}(f,op)
+        space::S = domainspace(op)) where {D,T,S<:Space}
+    g = convert(VFun{D,T}, f)
+    MultiplicationWrapper{D,S,T,typeof(op)}(g,op,space)
 end
-function MultiplicationWrapper(f::Fun, op::Operator, dspop::Space = domainspace(op))
-    MultiplicationWrapper(eltype(op), f, op, dspop)
+function MultiplicationWrapper(f::Fun, op::Operator, space::Space = domainspace(op))
+    MultiplicationWrapper(eltype(op), f, op, space)
 end
 
-@wrapper MultiplicationWrapper
+domainspace(M::MultiplicationWrapper) = M.space
+
+@wrapper MultiplicationWrapper false
 
 function convert(::Type{Operator{TT}},C::MultiplicationWrapper{S,V,O,T}) where {TT,S,V,O,T}
     if TT==T
         C
     else
-        MultiplicationWrapper(Fun{S,TT}(C.f),Operator{TT}(C.op))::Operator{TT}
+        MultiplicationWrapper(Fun{S,TT}(C.f),Operator{TT}(C.op), C.space)::Operator{TT}
     end
 end
 

src/Operators/functionals/Evaluation.jl

@@ -97,13 +97,12 @@ struct EvaluationWrapper{S<:Space,M,FS<:Operator,OT,T<:Number} <: Evaluation{T}
 end
 
 
-@wrapper EvaluationWrapper
+@wrapper EvaluationWrapper false
 EvaluationWrapper(sp::Space,x,order,func::Operator) =
     EvaluationWrapper{typeof(sp),typeof(x),typeof(func),typeof(order),eltype(func)}(sp,x,order,func)
 
 
 domainspace(E::Evaluation) = E.space
-domain(E::Evaluation) = domain(E.space)
 promotedomainspace(E::Evaluation,sp::Space) = Evaluation(sp,E.x,E.order)
 
 

src/Operators/general/algebra.jl

@@ -608,11 +608,10 @@ end
 
 
 # Conversions we always assume are intentional: no need to promote
-
-_unwrap_conversion(c) = c
-_unwrap_conversion(c::ConversionWrapper{<:TimesOperator}) = c.op
-
-*(A::Conversion, B::Conversion) = ConversionWrapper(TimesOperator(_unwrap_conversion(A), _unwrap_conversion(B)))
+function *(A::Conversion, B::Conversion)
+    T = TimesOperator(unwrap(A), unwrap(B))
+    ConversionWrapper(T, domainspace(B), rangespace(A))
+end
 *(A::Conversion, B::TimesOperator) = TimesOperator(A, B)
 *(A::TimesOperator, B::Conversion) = TimesOperator(A, B)
 *(A::Operator, B::Conversion) =