Type inference in LeftIntegral/RightIntegral (#877)

* Type inference in LeftIntegral/RightIntegral

* interlace diagonal in fractional derivative

* test for inference only on v1.8+

* Fix test

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFun"
 uuid = "28f2ccd6-bb30-5033-b560-165f7b14dc2f"
-version = "0.13.17"
+version = "0.13.18"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -22,7 +22,7 @@ StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [compat]
 AbstractFFTs = "1.0"
-ApproxFunBase = "0.8.4"
+ApproxFunBase = "0.8.6"
 ApproxFunBaseTest = "0.1"
 ApproxFunFourier = "0.3"
 ApproxFunOrthogonalPolynomials = "0.5, 0.6"

src/ApproxFun.jl

@@ -22,7 +22,8 @@ import ApproxFunBase: Fun, UnsetSpace, VFun, UnivariateSpace, SumSpace, Space,
                     SpaceOperator, InterlaceOperator, cfstype, pad!,
                     isapproxinteger, components, promotedomainspace, choosedomainspace,
                     AbstractProductSpace, MultivariateFun, BivariateSpace,
-                    @calculus_operator, slnorm, sample, chop!, 𝒟, ∫, ⨜, ⨍
+                    @calculus_operator, slnorm, sample, chop!, 𝒟, ∫, ⨜, ⨍,
+                    InterlaceOperator_Diagonal
 
 export ∫, ⨜, ⨍, 𝒟
 

src/Extras/fractional.jl

@@ -21,18 +21,23 @@ function LeftIntegral(S::Jacobi,k)
         ConcreteLeftIntegral(S,k)
     else
         J=Jacobi(zero(S.a),S.a,domain(S))
-        LeftIntegralWrapper(LeftIntegral(J,k)*Conversion(S,J),k)
+        CLI = ConcreteLeftIntegral(J,k)
+        LeftIntegralWrapper(CLI*Conversion(S,J),k,S,rangespace(CLI))
     end
 end
 
 function LeftIntegral(S::Ultraspherical,k)
     J = Jacobi(S)
-    LeftIntegralWrapper(LeftIntegral(J,k)*Conversion(S,J),0.5)
+    LI = LeftIntegral(J,k)
+    LeftIntegralWrapper(LI*Conversion(S,J),0.5,S,rangespace(LI))
 end
 
-LeftIntegral(S::Chebyshev,k) = LeftIntegralWrapper(
-    LeftIntegral(Ultraspherical(1//2,domain(S)),k)*Conversion(S,Ultraspherical(1//2,domain(S))),
-    0.5)
+function LeftIntegral(S::Chebyshev,k)
+    LI = LeftIntegral(Ultraspherical(1//2,domain(S)),k)
+    LeftIntegralWrapper(
+        LI*Conversion(S,Ultraspherical(1//2,domain(S))),
+            0.5,S,rangespace(LI))
+end
 
 
 function rangespace(Q::ConcreteLeftIntegral{<:Jacobi{<:IntervalOrSegment}})
@@ -47,7 +52,8 @@ function RightIntegral(S::Jacobi,k)
         ConcreteRightIntegral(S,k)
     else
         J=Jacobi(S.b,zero(S.b),domain(S))
-        RightIntegralWrapper(RightIntegral(J,k)*Conversion(S,J),k)
+        CRI = ConcreteRightIntegral(J,k)
+        RightIntegralWrapper(CRI*Conversion(S,J),k,S,rangespace(CRI))
     end
 end
 
@@ -111,21 +117,22 @@ end
 function LeftIntegral(S::JacobiWeight{<:Chebyshev},k)
     # convert to Jacobi
     Q=LeftIntegral(JacobiWeight(S.β,S.α,Jacobi(S.space)),k)
-    LeftIntegralWrapper(Q*Conversion(S,domainspace(Q)),k)
+    LeftIntegralWrapper(Q*Conversion(S,domainspace(Q)),k,S,rangespace(Q))
 end
 
 function RightIntegral(S::JacobiWeight{<:Chebyshev},k)
     # convert to Jacobi
     Q=RightIntegral(JacobiWeight(S.β,S.α,Jacobi(S.space)),k)
-    RightIntegralWrapper(Q*Conversion(S,domainspace(Q)),k)
+    RightIntegralWrapper(Q*Conversion(S,domainspace(Q)),k,S,rangespace(Q))
 end
 
 for (TYP,WRAP) in ((:LeftIntegral,:LeftIntegralWrapper),
                     (:RightIntegral,:RightIntegralWrapper))
 
     @eval function $TYP(S::JacobiWeight{<:PolynomialSpace}, k)
         JS = JacobiWeight(S.β,S.α,Jacobi(S.space))
-        $WRAP($TYP(JS,k)*Conversion(S,JS),k)
+        IOP = $TYP(JS,k)
+        $WRAP(IOP*Conversion(S,JS),k,S,rangespace(IOP))
     end
 end
 
@@ -202,8 +209,12 @@ for (DTYP,QTYP,DWRAP,QWRAP) in ((:LeftDerivative,:LeftIntegral,:LeftDerivativeWr
         function $DTYP(S::Space,k::Real)
             i=ceil(Int,k)
             r=i-k
-            $DWRAP(i<0 ? $QTYP(S,-k) : Derivative(i)*$QTYP(S,r),k)
+            $DWRAP(i<0 ? $QTYP(S,-k) : Derivative(i)*$QTYP(S,r),k,S)
+        end
+        function $QTYP(S::SumSpace,k)
+            t = map(s->$QTYP(s,k),components(S))
+            IOP = InterlaceOperator_Diagonal(t,S)
+            $QWRAP(IOP,k)
         end
-        $QTYP(S::SumSpace,k) = $QWRAP(InterlaceOperator(Diagonal([map(s->$QTYP(s,k),S.spaces)...]),SumSpace),k)
     end
 end

test/FractionalTest.jl

@@ -136,6 +136,22 @@ include(joinpath(@__DIR__, "testutils.jl"))
 
         @test norm(y-exp((1+x)/2)*erfc(sqrt(1+x))) < 100eps()
     end
+
+    @testset "type inference" begin
+        if VERSION >= v"1.8"
+            @inferred (() -> LeftIntegral(Jacobi(-1,0)))()
+            @inferred (() -> LeftIntegral(Legendre()))()
+            @inferred (() -> LeftIntegral(Chebyshev()))()
+            @inferred (() -> LeftIntegral(Ultraspherical(0.5)))()
+            @inferred (() -> LeftIntegral(JacobiWeight(0,0,Legendre())))()
+            @inferred (() -> LeftIntegral(JacobiWeight(-0.5,0,Chebyshev())))()
+            @inferred (() -> RightIntegral(Jacobi(-1,0)))()
+            @inferred (() -> RightIntegral(Legendre()))()
+            @inferred (() -> RightIntegral(JacobiWeight(0,0,Legendre())))()
+            @inferred (() -> RightIntegral(JacobiWeight(0,-0.5,Chebyshev())))()
+            @inferred (() -> LeftIntegral(Legendre() ⊕ JacobiWeight(0.5,0.,Ultraspherical(1)),0.5))()
+        end
+    end
 end
 
 end # module