Add inv for 1st kind Chebyshev transforms (#190)

* and inv for 1st kind Chebyshev transforms

* v0.14.9

* add tests

* add tests

* test on 1

Author: dlfivefifty

.github/workflows/ci.yml

@@ -10,6 +10,7 @@ jobs:
       matrix:
         version:
           - '1.7'
+          - '1'
         os:
           - ubuntu-latest
           - macOS-latest

Project.toml

@@ -1,6 +1,6 @@
 name = "FastTransforms"
 uuid = "057dd010-8810-581a-b7be-e3fc3b93f78c"
-version = "0.14.8"
+version = "0.14.9"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/FastTransforms.jl

@@ -17,7 +17,7 @@ import AbstractFFTs: Plan, ScaledPlan,
                      plan_fft, plan_ifft, plan_bfft, plan_fft!, plan_ifft!,
                      plan_bfft!, plan_rfft, plan_irfft, plan_brfft,
                      fftshift, ifftshift, rfft_output_size, brfft_output_size,
-                     plan_inv, normalization
+                     normalization
 
 import FFTW: dct, dct!, idct, idct!, plan_dct!, plan_idct!,
              plan_dct, plan_idct, fftwNumber

src/chebyshevtransform.jl

@@ -239,6 +239,10 @@ IChebyshevTransformPlan{T,kind,K}(F::FFTW.r2rFFTWPlan{T,K,inplace,N,R}) where {T
 inv(P::ChebyshevTransformPlan{T,2,K}) where {T,K} = IChebyshevTransformPlan{T,2,K}(P.plan)
 inv(P::IChebyshevTransformPlan{T,2,K}) where {T,K} = ChebyshevTransformPlan{T,2,K}(P.plan)
 
+inv(P::ChebyshevTransformPlan{T,1,K,inplace,N}) where {T,K,inplace,N} = IChebyshevTransformPlan{T,1,kindtuple(IFIRSTKIND,N,P.plan.region...)}(inv(P.plan).p)
+inv(P::IChebyshevTransformPlan{T,1,K,inplace,N}) where {T,K,inplace,N} = ChebyshevTransformPlan{T,1,kindtuple(FIRSTKIND,N,P.plan.region...)}(inv(P.plan).p)
+
+
 
 \(P::ChebyshevTransformPlan, x::AbstractArray) = inv(P) * x
 \(P::IChebyshevTransformPlan, x::AbstractArray) = inv(P) * x
@@ -526,13 +530,22 @@ function plan_ichebyshevutransform(x::AbstractArray{T,N}, ::Val{1}, dims...; kws
 end
 function plan_ichebyshevutransform(x::AbstractArray{T,N}, ::Val{2}, dims...; kws...) where {T<:fftwNumber,N}
     any(≤(1),size(x)) && throw(ArgumentError("Array must contain at least 2 entries"))
-    IChebyshevUTransformPlan{T,2,kindtuple(USECONDKIND,N,dims...)}(FFTW.plan_r2r(x, USECONDKIND))
+    IChebyshevUTransformPlan{T,2,kindtuple(USECONDKIND,N,dims...)}(FFTW.plan_r2r(x, USECONDKIND, dims...; kws...))
 end
 
 
 plan_ichebyshevutransform!(x::AbstractArray, dims...; kws...) = plan_ichebyshevutransform!(x, Val(1), dims...; kws...)
 plan_ichebyshevutransform(x::AbstractArray, dims...; kws...) = plan_ichebyshevutransform(x, Val(1), dims...; kws...)
 
+# second kind Chebyshev transforms share a plan with their inverse
+# so we support this via inv
+inv(P::ChebyshevUTransformPlan{T,2,K}) where {T,K} = IChebyshevUTransformPlan{T,2,K}(P.plan)
+inv(P::IChebyshevUTransformPlan{T,2,K}) where {T,K} = ChebyshevUTransformPlan{T,2,K}(P.plan)
+
+inv(P::ChebyshevUTransformPlan{T,1,K,inplace,N}) where {T,K,inplace,N} = IChebyshevUTransformPlan{T,1,kindtuple(IUFIRSTKIND,N,P.plan.region...)}(inv(P.plan).p)
+inv(P::IChebyshevUTransformPlan{T,1,K,inplace,N}) where {T,K,inplace,N} = ChebyshevUTransformPlan{T,1,kindtuple(UFIRSTKIND,N,P.plan.region...)}(inv(P.plan).p)
+
+
 function _ichebyu1_postscale!(_, x::AbstractVector{T}) where T
     n = length(x)
     @inbounds for k=1:n # sqrt(1-x_j^2) weight

test/chebyshevtests.jl

@@ -278,4 +278,29 @@ using FastTransforms, Test
         F = plan_chebyshevtransform([1.,2,3])
         @test chebyshevtransform(1.0:3) == F * (1:3)
     end
+
+    @testset "inv" begin
+        x = randn(5)
+        for F in (plan_chebyshevtransform(x), plan_chebyshevtransform(x, Val(2)),
+                  plan_chebyshevutransform(x), plan_chebyshevutransform(x, Val(2)),
+                  plan_ichebyshevtransform(x), plan_ichebyshevtransform(x, Val(2)),
+                  plan_ichebyshevutransform(x), plan_ichebyshevutransform(x, Val(2)))
+            @test F \ (F*x) ≈ F * (F\x) ≈ x
+        end
+
+        X = randn(5,4)
+        for F in (plan_chebyshevtransform(X,Val(1),1), plan_chebyshevtransform(X, Val(2),1),
+            plan_chebyshevtransform(X,Val(1),2), plan_chebyshevtransform(X, Val(2),2),
+            plan_ichebyshevtransform(X,Val(1),1), plan_ichebyshevtransform(X, Val(2),1),
+            plan_ichebyshevtransform(X,Val(1),2), plan_ichebyshevtransform(X, Val(2),2))
+            @test F \ (F*X) ≈ F * (F\X) ≈ X
+        end
+        # Matrix isn't implemented for chebyshevu
+        for F in (plan_chebyshevutransform(X,Val(1),1), plan_chebyshevutransform(X, Val(2),1),
+            plan_chebyshevutransform(X,Val(1),2), plan_chebyshevutransform(X, Val(2),2),
+            plan_ichebyshevutransform(X,Val(1),1), plan_ichebyshevutransform(X, Val(2),1),
+            plan_ichebyshevutransform(X,Val(1),2), plan_ichebyshevutransform(X, Val(2),2))
+            @test_broken F \ (F*X) ≈ F * (F\X) ≈ X
+        end
+    end
 end