derivative for normalized spaces (#171)

* derivative for normalized spaces

* version bump to v0.6.14

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.6.13"
+version = "0.6.14"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -29,7 +29,7 @@ ToeplitzMatrices = "c751599d-da0a-543b-9d20-d0a503d91d24"
 
 [compat]
 AbstractFFTs = "0.5, 1"
-ApproxFunOrthogonalPolynomials = "0.4"
+ApproxFunOrthogonalPolynomials = "0.4, 0.5"
 BandedMatrices = "0.16, 0.17"
 BlockArrays = "0.14, 0.15, 0.16"
 BlockBandedMatrices = "0.10, 0.11"

src/Operators/banded/CalculusOperator.jl

@@ -59,8 +59,9 @@ macro calculus_operator(Op)
             end
         end
 
-        $WrappOp(op::Operator,order) =
-            $WrappOp{typeof(op),typeof(domainspace(op)),typeof(order),eltype(op)}(op,order)
+        $WrappOp(op::Operator,d,order) =
+            $WrappOp{typeof(op),typeof(d),typeof(order),eltype(op)}(op,order)
+        $WrappOp(op::Operator,order) = $WrappOp(op, domainspace(op), order)
         $WrappOp(op::Operator) = $WrappOp(op,1)
 
         function Base.convert(::Type{Operator{T}},D::$WrappOp) where T
@@ -181,16 +182,25 @@ function DefaultDerivative(sp::Space,k::Integer)
         # this is the normal default constructor
         csp=canonicalspace(sp)
         if conversion_type(csp,sp)==csp   # Conversion(sp,csp) is not banded, or sp==csp
-           error("Implement Derivative($(string(sp)),$k)")
+           error("Implement Derivative(", sp, ",", k,")")
         end
-        DerivativeWrapper(TimesOperator([Derivative(csp,k),Conversion(sp,csp)]),k)
+        DerivativeWrapper(TimesOperator(Derivative(csp,k),Conversion(sp,csp)), sp, k)
     else
-        D1=invfromcanonicalD(sp)*Derivative(setdomain(sp,canonicaldomain(sp)))
-        D=DerivativeWrapper(SpaceOperator(D1,sp,setdomain(rangespace(D1),domain(sp))),1)
+        csp = canonicalspace(sp)
+        D1 = if csp == sp
+            _Dsp = invfromcanonicalD(sp)*Derivative(setdomain(sp,canonicaldomain(sp)))
+            rsp = rangespace(_Dsp)
+            _Dsp
+        else
+            Dcsp = Derivative(csp)
+            rsp = rangespace(Dcsp)
+            Dcsp * Conversion(sp, csp)
+        end
+        D=DerivativeWrapper(SpaceOperator(D1,sp,setdomain(rsp,domain(sp))),1)
         if k==1
             D
         else
-            DerivativeWrapper(TimesOperator(Derivative(rangespace(D),k-1),D),k)
+            DerivativeWrapper(TimesOperator(Derivative(rangespace(D),k-1),D), sp, k)
         end
     end
 end

test/SpacesTest.jl

@@ -325,10 +325,16 @@ using StaticArrays
         @testset "Derivative" begin
             @test Derivative() == Derivative()
             for d in Any[(), (0..1,)]
-                for ST in Any[Chebyshev, Legendre]
+                for ST in Any[Chebyshev, Legendre,
+                        (x...) -> Jacobi(2,2,x...), (x...) -> Jacobi(1.5,2.5,x...)]
                     S = ST(d...)
-                    @test Derivative(S) == Derivative(S)
-                    @test Derivative(S,2) == Derivative(S,2)
+                    @test Derivative(S) == Derivative(S,1)
+                    @test Derivative(S)^2 == Derivative(S,2)
+                    f = Fun(x->x^3, S)
+                    @test Derivative(S) * f ≈ Fun(x->3x^2, S)
+                    @test Derivative(S,2) * f ≈ Fun(x->6x, S)
+                    @test Derivative(S,3) * f ≈ Fun(x->6, S)
+                    @test Derivative(S,4) * f ≈ zeros(S)
                 end
             end
             @test Derivative(Chebyshev()) != Derivative(Chebyshev(), 2)