Conversion_normalizedspace for a normalized space is a no-op (#502)

* Conversion_normalizedspace for a normalized space is a no-op

* Move Val flip to else branch

Author: jishnub

Project.toml

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

src/Operators/banded/Conversion.jl

@@ -90,8 +90,13 @@ Return `Conversion(S, normalizedspace(S))`. This may be concretely inferred for
 Return `Conversion(normalizedspace(S), S)`. This may be concretely inferred for orthogonal polynomial spaces.
 """
 function Conversion_normalizedspace(S::Space, v::Union{Val{:forward}, Val{:backward}} = Val(:forward))
-    vflip = v isa Val{:forward} ? Val(:backward) : Val(:forward)
-    Conversion_maybeconcrete(normalizedspace(S), S, vflip)
+    NS = normalizedspace(S)
+    if S isa typeof(NS) # in case S is already normalized, in which case the conversion is a no-op
+        Conversion(S)
+    else
+        vflip = v isa Val{:forward} ? Val(:backward) : Val(:forward)
+        Conversion_maybeconcrete(NS, S, vflip)
+    end
 end
 
 """

src/eigen.jl

@@ -160,16 +160,16 @@ end
 function basis_recombination(SE::EigenSystem)
     L, QS = SE.L, SE.QS
     S = domainspace(L)
+    C = Conversion(S, rangespace(L))
     D1 = Conversion_normalizedspace(S)
     D2 = Conversion_normalizedspace(S, Val(:backward))
     Q = Conversion(QS, S)
-    R = D1*Q;
-    C = Conversion(S, rangespace(L))
+    R = D1*Q
     P = cache(PartialInverseOperator(C, (0, bandwidth(L, 1) + bandwidth(R, 1) + bandwidth(C, 2))));
     A = R'D1*P*L*D2*R
-    BB = R'R;
+    B = R'R
 
-    return A, BB
+    return A, B
 end
 
 """

test/PolynomialSpacesTests.jl

@@ -147,7 +147,7 @@ Base.:(==)(a::UniqueInterval, b::UniqueInterval) = (@assert a.parentinterval ==
         end
     end
 
-    @testset "conversion" begin
+    @testset "Conversion" begin
         C12 = Conversion(Chebyshev(), NormalizedLegendre())
         C21 = Conversion(NormalizedLegendre(), Chebyshev())
         @test Matrix((C12 * C21)[1:10, 1:10]) ≈ I
@@ -157,6 +157,21 @@ Base.:(==)(a::UniqueInterval, b::UniqueInterval) = (@assert a.parentinterval ==
         C1C2 = Conversion(Ultraspherical(1), NormalizedPolynomialSpace(Ultraspherical(1))) *
                 Conversion(Chebyshev(), Ultraspherical(1))
         @test Matrix(C12[1:10, 1:10]) ≈ Matrix(C1C2[1:10, 1:10])
+
+        @testset "to normalized spaces" begin
+            for S in (Legendre(), NormalizedLegendre())
+                f = Fun(x->x^2, S)
+                C = @inferred Conversion_normalizedspace(S, Val(:forward))
+                g = C * f
+                @test space(g) == normalizedspace(space(f))
+                @test g ≈ f
+                f = Fun(x->x^2, normalizedspace(S))
+                C = @inferred Conversion_normalizedspace(S, Val(:backward))
+                g = C * f
+                @test normalizedspace(space(g)) == space(f)
+                @test g ≈ f
+            end
+        end
     end
 
     @testset "union" begin