Improve type-inference in normalized space conversion

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunOrthogonalPolynomials"
 uuid = "b70543e2-c0d9-56b8-a290-0d4d6d4de211"
-version = "0.6.43"
+version = "0.6.44"
 
 [deps]
 ApproxFunBase = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"

src/Spaces/Jacobi/JacobiOperators.jl

@@ -145,7 +145,7 @@ function _conversion_shiftordersbyone(L::Jacobi, M::Jacobi)
     CLJ = [ConcreteConversion(Jacobi(b-1,L.a,dm), Jacobi(b, L.a, dm)) for b in M.b:-1:L.b+1]
     CJM = [ConcreteConversion(Jacobi(M.b,a-1,dm), Jacobi(M.b, a, dm)) for a in M.a:-1:L.a+1]
     C = [CJM; CLJ]
-    return ConversionWrapper(TimesOperator(C))
+    return ConversionWrapper(TimesOperator(C), L, M)
 end
 
 ## Conversion

src/Spaces/PolynomialSpace.jl

@@ -452,21 +452,27 @@ normalizedspace(S::NormalizedPolynomialSpace) = S
 
 supportsinplacetransform(N::NormalizedPolynomialSpace) = supportsinplacetransform(N.space)
 
-function Conversion(L::NormalizedPolynomialSpace{S}, M::S) where S<:PolynomialSpace
+function Conversion(L::NormalizedPolynomialSpace, M::PolynomialSpace)
     if L.space == M
         ConcreteConversion(L, M)
     else
         sp = L.space
-        ConversionWrapper(TimesOperator(Conversion(sp, M), ConcreteConversion(L, sp)))
+        ConversionWrapper(
+            TimesOperator(Conversion(sp, M), ConcreteConversion(L, sp)),
+            L, M,
+        )
     end
 end
 
-function Conversion(L::S, M::NormalizedPolynomialSpace{S}) where S<:PolynomialSpace
+function Conversion(L::PolynomialSpace, M::NormalizedPolynomialSpace)
     if M.space == L
         ConcreteConversion(L, M)
     else
         sp = M.space
-        ConversionWrapper(TimesOperator(ConcreteConversion(sp, M), Conversion(L, sp)))
+        ConversionWrapper(
+            TimesOperator(ConcreteConversion(sp, M), Conversion(L, sp)),
+            L, M,
+        )
     end
 end
 
@@ -490,11 +496,11 @@ function Fun(::typeof(identity), S::NormalizedPolynomialSpace)
     Fun(S, coeffs)
 end
 
-function conversion_rule(a::NormalizedPolynomialSpace{S}, b::S) where S<:PolynomialSpace
+function conversion_rule(a::NormalizedPolynomialSpace, b::PolynomialSpace)
     conversion_type(a.space, b)
 end
 
-function maxspace_rule(a::NormalizedPolynomialSpace{S}, b::S) where S<:PolynomialSpace
+function maxspace_rule(a::NormalizedPolynomialSpace, b::PolynomialSpace)
     maxspace(a.space, b)
 end
 

test/JacobiTest.jl

@@ -274,7 +274,16 @@ include("testutils.jl")
         end
         @testset "Normalized and Unnormalized" begin
             C = Conversion(NormalizedUltraspherical(0.5), Legendre())
-            @test C * Fun(x->x^4, NormalizedUltraspherical(0.5)) ≈ Fun(x->x^4, Legendre())
+            @test isdiag(C)
+            g = C * Fun(x->x^4, NormalizedUltraspherical(0.5))
+            @test space(g) == Legendre()
+            @test g ≈ Fun(x->x^4, Legendre())
+
+            C = Conversion(Ultraspherical(0.5), NormalizedLegendre())
+            @test isdiag(C)
+            g = C * Fun(x->x^4, Ultraspherical(0.5))
+            @test space(g) == NormalizedLegendre()
+            @test g ≈ Fun(x->x^4, NormalizedLegendre())
 
             C = Conversion(Legendre(), NormalizedChebyshev())
             @test C * Fun(x->x^4, Legendre()) ≈ Fun(x->x^4, NormalizedChebyshev())

test/UltrasphericalTest.jl

@@ -148,6 +148,29 @@ include("testutils.jl")
             end
         end
 
+        @testset "Normalized" begin
+            Tallowed = Union{
+                typeof(Conversion(Ultraspherical(1), NormalizedUltraspherical(1))),
+                typeof(Conversion(Ultraspherical(1), NormalizedUltraspherical(2)))
+            }
+            C = @inferred Tallowed Conversion(Ultraspherical(1), NormalizedUltraspherical(1))
+            @test C * Fun(Ultraspherical(1)) ≈ Fun(NormalizedUltraspherical(1))
+
+            Tallowed = Union{
+                typeof(Conversion(NormalizedUltraspherical(1), Ultraspherical(1))),
+                typeof(Conversion(NormalizedUltraspherical(1), Ultraspherical(2)))
+            }
+            C = @inferred Tallowed Conversion(NormalizedUltraspherical(1), Ultraspherical(1))
+            @test C * Fun(NormalizedUltraspherical(1)) ≈ Fun(Ultraspherical(1))
+
+            Tallowed = Union{
+                typeof(Conversion(NormalizedUltraspherical(1), NormalizedUltraspherical(1))),
+                typeof(Conversion(NormalizedUltraspherical(1), NormalizedUltraspherical(2)))
+            }
+            C = @inferred Tallowed Conversion(NormalizedUltraspherical(1), NormalizedUltraspherical(1))
+            @test C * Fun(NormalizedUltraspherical(1)) ≈ Fun(NormalizedUltraspherical(1))
+        end
+
         @testset "complex normalization" begin
             C = Conversion(NormalizedUltraspherical(NormalizedLegendre()), Ultraspherical(Legendre()))
             CC = convert(Operator{ComplexF64}, C)