Concrete derivatives may preserve OneElement coefficients (#333)

* Concrete derivatives mat preserve OneElement coefficients

* Test for OneElement coeffs conditionally

* Concrete derivatie for NormalizedJacobi and test fixes

* Revert concrete derivative for NormalizedJacobi

* Test for OneElement if it's defined

Author: jishnub

src/Spaces/PolynomialSpace.jl

@@ -545,10 +545,13 @@ function getindex(C::ConcreteConversion{S,NormalizedPolynomialSpace{S,D,R},T},k:
     end
 end
 
+const MaybeNormalized{S<:PolynomialSpace} = Union{S, NormalizedPolynomialSpace{S}}
+const MaybeNormalizedTensorSpace{P1,P2} = TensorSpace{<:Tuple{MaybeNormalized{P1},MaybeNormalized{P2}}}
+
 # this is only evaluated if FillArrays >= v1 is used
 @static if isdefined(FillArrays, :OneElement)
     ## Special OneElement conversion
-    function _mul_coefficients_concreteconv(C, v)
+    function _mul_coefficients_concreteconv(C, v::OneElement)
         Base.require_one_based_indexing(v)
         nzind = v.ind[1]
         Cnzind = C[nzind, nzind]
@@ -562,6 +565,17 @@ end
                                 v::OneElement{<:Any,1}) where {S<:PolynomialSpace}
         _mul_coefficients_concreteconv(C, v)
     end
+    function _mul_coefficients_deriv(D::ConcreteDerivative, v::OneElement)
+        Base.require_one_based_indexing(v)
+        nzind = v.ind[1]
+        order = D.order
+        rowind = nzind-D.order
+        Dnzind = D[rowind, nzind]
+        OneElement(Dnzind * v.val, rowind, rowind)
+    end
+    function mul_coefficients(C::ConcreteDerivative{<:MaybeNormalized}, v::OneElement{<:Any,1})
+        _mul_coefficients_deriv(C, v)
+    end
 end
 
 # Evaluation
@@ -600,8 +614,6 @@ function _hasconversion_tensor(A, B)
 
     _stripnorm(A1) == _stripnorm(B1) && _stripnorm(A2) == _stripnorm(B2)
 end
-const MaybeNormalized{S<:PolynomialSpace} = Union{S, NormalizedPolynomialSpace{S}}
-const MaybeNormalizedTensorSpace{P1,P2} = TensorSpace{<:Tuple{MaybeNormalized{P1},MaybeNormalized{P2}}}
 
 function hasconversion(A::MaybeNormalizedTensorSpace{<:P1, <:P2},
         B::MaybeNormalizedTensorSpace{<:P1, <:P2}) where {P1<:PolynomialSpace,P2<:PolynomialSpace}

test/ChebyshevTest.jl

@@ -3,6 +3,7 @@ module ChebyshevTest
 using ApproxFunOrthogonalPolynomials
 using ApproxFunBase
 using DualNumbers
+using FillArrays
 using LinearAlgebra
 using Test
 using ApproxFunBase: transform!, itransform!
@@ -351,6 +352,40 @@ include("testutils.jl")
             g = Chebyshev()(3)
             f = Conversion(Chebyshev(), NormalizedChebyshev()) * g
             @test f ≈ Fun(x->-3x+4x^3, NormalizedChebyshev())
+            @test space(f) == NormalizedChebyshev()
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(f) isa OneElement
+                end
+            end
+
+            g = NormalizedChebyshev()(3)
+            f = Conversion(NormalizedChebyshev(), Chebyshev()) * g
+            @test f ≈ g
+            @test space(f) == Chebyshev()
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(f) isa OneElement
+                end
+            end
+        end
+
+        @testset "Derivative * OneElement" begin
+            g = Chebyshev()(3)
+            @test Derivative() * g == Derivative() * Fun(space(g), collect(coefficients(g)))
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(Derivative() * g) isa OneElement
+                end
+            end
+
+            g = NormalizedChebyshev()(3)
+            @test Derivative() * g == Derivative() * Fun(space(g), collect(coefficients(g)))
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(Derivative() * g) isa OneElement
+                end
+            end
         end
     end
 

test/JacobiTest.jl

@@ -2,9 +2,6 @@ module JacobiTest
 
 using ApproxFunOrthogonalPolynomials
 using ApproxFunBase
-using Test
-using SpecialFunctions
-using LinearAlgebra
 using ApproxFunBase: maxspace, NoSpace, hasconversion,
                     reverseorientation, ReverseOrientation, transform!, itransform!
 using ApproxFunBaseTest: testbandedbelowoperator, testbandedoperator, testspace, testtransforms,
@@ -14,10 +11,14 @@ using BandedMatrices
 using BandedMatrices: isbanded
 using BlockArrays
 using BlockBandedMatrices
-using StaticArrays: SVector
-using Static
+using FillArrays
 using HalfIntegers
+using LinearAlgebra
 using OddEvenIntegers
+using SpecialFunctions
+using StaticArrays: SVector
+using Static
+using Test
 
 include("testutils.jl")
 
@@ -757,6 +758,52 @@ include("testutils.jl")
             S = @inferred maxspace(NormalizedChebyshev(), NormalizedJacobi(Ultraspherical(2)))
             @test S == NormalizedJacobi(Ultraspherical(2))
         end
+
+        @testset "Conversion * OneElement" begin
+            g = Legendre()(3)
+            f = Conversion(Legendre(), NormalizedLegendre()) * g
+            @test f ≈ g
+            @test space(f) == NormalizedLegendre()
+
+            g = NormalizedLegendre()(3)
+            f = Conversion(NormalizedLegendre(), Legendre()) * g
+            @test f ≈ g
+            @test space(f) == Legendre()
+        end
+
+        @testset "Derivative * OneElement" begin
+            g = Legendre()(3)
+            @test Derivative() * g == Derivative() * Fun(space(g), collect(coefficients(g)))
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(Derivative() * g) isa OneElement
+                end
+            end
+
+            g = Jacobi(1.5,2)(3)
+            @test Derivative() * g == Derivative() * Fun(space(g), collect(coefficients(g)))
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(Derivative() * g) isa OneElement
+                end
+            end
+
+            g = NormalizedLegendre()(3)
+            @test Derivative() * g == Derivative() * Fun(space(g), collect(coefficients(g)))
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test_broken coefficients(Derivative() * g) isa OneElement
+                end
+            end
+
+            g = NormalizedJacobi(1,2.5)(3)
+            @test Derivative() * g == Derivative() * Fun(space(g), collect(coefficients(g)))
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test_broken coefficients(Derivative() * g) isa OneElement
+                end
+            end
+        end
     end
 
     @testset "casting bug ApproxFun.jl#770" begin

test/MiscAFBTest.jl

@@ -257,7 +257,7 @@ Base.:(==)(a::UniqueInterval, b::UniqueInterval) = (@assert a.parentinterval ==
                 for ST in Any[Chebyshev, Legendre,
                         (x...) -> Jacobi(2,2,x...), (x...) -> Jacobi(1.5,2.5,x...)]
                     S1 = ST(d...)
-                    for S in [S1, NormalizedPolynomialSpace(S1)]
+                    @testset for S in [S1, NormalizedPolynomialSpace(S1)]
                         @test Derivative(S) == Derivative(S,1)
                         @test Derivative(S)^2 == Derivative(S,2)
                         f = Fun(x->x^3, S)

test/UltrasphericalTest.jl

@@ -4,6 +4,7 @@ using ApproxFunOrthogonalPolynomials
 using ApproxFunBase
 using BandedMatrices
 using BandedMatrices: isbanded
+using FillArrays
 using HalfIntegers
 using LinearAlgebra
 using OddEvenIntegers
@@ -298,6 +299,46 @@ include("testutils.jl")
             E = Evaluation(S, 0.5, 2)
             @test Number(E * f) ≈ 6 * (0.5)
         end
+
+        @testset "Conversion * OneElement" begin
+            g = Ultraspherical(3)(3)
+            f = Conversion(Ultraspherical(3), NormalizedUltraspherical(3)) * g
+            @test f ≈ g
+            @test space(f) == NormalizedUltraspherical(3)
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(f) isa OneElement
+                end
+            end
+
+            g = NormalizedUltraspherical(3)(3)
+            f = Conversion(NormalizedUltraspherical(3), Ultraspherical(3)) * g
+            @test f ≈ g
+            @test space(f) == Ultraspherical(3)
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(f) isa OneElement
+                end
+            end
+        end
+
+        @testset "Derivative * OneElement" begin
+            g = Ultraspherical(3)(3)
+            @test Derivative() * g == Derivative() * Fun(space(g), collect(coefficients(g)))
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(Derivative() * g) isa OneElement
+                end
+            end
+
+            g = NormalizedUltraspherical(3)(3)
+            @test Derivative() * g == Derivative() * Fun(space(g), collect(coefficients(g)))
+            @static if isdefined(FillArrays, :OneElement)
+                if coefficients(g) isa OneElement
+                    @test coefficients(Derivative() * g) isa OneElement
+                end
+            end
+        end
     end
 
     @testset "inplace transform" begin