From a8776025ec0315422e5325d3b8175ecc39afafe2 Mon Sep 17 00:00:00 2001
From: Sheehan Olver <solver@mac.com>
Date: Mon, 5 Dec 2022 20:40:19 +0000
Subject: [PATCH 1/7] Support r2r

---
 Project.toml                     |  2 +-
 src/FastTransformsForwardDiff.jl |  5 +++--
 src/fft.jl                       | 33 +++++++++++++++++++++++---------
 test/runtests.jl                 |  5 +++++
 4 files changed, 33 insertions(+), 12 deletions(-)

diff --git a/Project.toml b/Project.toml
index 8ae6220..d894ca5 100644
--- a/Project.toml
+++ b/Project.toml
@@ -6,6 +6,7 @@ version = "0.0.1"
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
+FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
 
 [compat]
 AbstractFFTs = "1"
@@ -15,7 +16,6 @@ julia = "1.6"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
 
 [targets]
 test = ["Test", "FFTW"]
\ No newline at end of file
diff --git a/src/FastTransformsForwardDiff.jl b/src/FastTransformsForwardDiff.jl
index 3a47e42..a966c9c 100644
--- a/src/FastTransformsForwardDiff.jl
+++ b/src/FastTransformsForwardDiff.jl
@@ -1,7 +1,8 @@
 module FastTransformsForwardDiff
-using ForwardDiff
-import AbstractFFTs
+using ForwardDiff, FFTW
+using AbstractFFTs
 import ForwardDiff: value, partials, npartials, Dual, tagtype, derivative, jacobian, gradient
+import FFTW: r2r, r2r!, plan_r2r, plan_r2r!
 
 @inline tagtype(::Complex{T}) where T = tagtype(T)
 @inline tagtype(::Type{Complex{T}}) where T = tagtype(T)
diff --git a/src/fft.jl b/src/fft.jl
index 813d17e..3eceb38 100644
--- a/src/fft.jl
+++ b/src/fft.jl
@@ -53,13 +53,8 @@ end
 
 for P in [:Plan, :ScaledPlan]  # need ScaledPlan to avoid ambiguities
     @eval begin
-
-        Base.:*(p::AbstractFFTs.$P, x::AbstractArray{<:Dual}) =
-            _apply_plan(p, x)
-
-        Base.:*(p::AbstractFFTs.$P, x::AbstractArray{<:Complex{<:Dual}}) =
-            _apply_plan(p, x)
-
+        Base.:*(p::AbstractFFTs.$P, x::AbstractArray{<:Dual}) = _apply_plan(p, x)
+        Base.:*(p::AbstractFFTs.$P, x::AbstractArray{<:Complex{<:Dual}}) = _apply_plan(p, x)
     end
 end
 
@@ -68,14 +63,34 @@ function _apply_plan(p::AbstractFFTs.Plan, x::AbstractArray)
     dxtils = ntuple(npartials(eltype(x))) do n
         p * partials.(x, n)
     end
-    __apply_plan(tagtype(eltype(x)), xtil, dxtils)
+    __apply_plan(eltype(x), xtil, dxtils)
 end
 
-function __apply_plan(T, xtil, dxtils)
+function __apply_plan(Ti::Type{<:Complex}, xtil, dxtils)
+    T = tagtype(Ti)
     map(xtil, dxtils...) do val, parts...
         Complex(
             Dual{T}(real(val), map(real, parts)),
             Dual{T}(imag(val), map(imag, parts)),
         )
     end
+end
+
+function __apply_plan(Ti::Type{<:Real}, xtil, dxtils)
+    T = tagtype(Ti)
+    map(xtil, dxtils...) do val, parts...
+        Dual{T}(val, parts)
+    end
+end
+
+
+for f in (:r2r, :r2r!)
+    pf = Symbol("plan_", f)
+    @eval begin
+        $f(x::AbstractArray{<:Dual}, kinds) = $pf(x, kinds) * x
+        $f(x::AbstractArray{<:Dual}, kinds, region) = $pf(x, kinds, region) * x
+        $pf(x::AbstractArray{<:Dual}, kinds, region; kws...) = $pf(value.(x), kinds, region; kws...)
+        $f(x::AbstractArray{<:Complex{<:Dual}}, kinds, region=1:ndims(x)) = $pf(x, kinds) * x
+        $pf(x::AbstractArray{<:Complex{<:Dual}}, kinds, region; kws...) = $pf(value.(x), kinds, region; kws...)
+    end
 end
\ No newline at end of file
diff --git a/test/runtests.jl b/test/runtests.jl
index 537852d..bff973c 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -33,4 +33,9 @@ using AbstractFFTs: complexfloat, realfloat
 
     # c = x -> dct([x; 0; 0])[1]
     # @test derivative(c,0.1) ≈ 1
+end
+
+@testset "r2r" begin
+    f = ω -> FFTW.r2r([ω; zeros(9)], FFTW.R2HC)[1]
+    @test derivative(f, 0.1) ≡ 1.0
 end
\ No newline at end of file

From c0c5959cffab2d9a1df6041c287068f5b3169381 Mon Sep 17 00:00:00 2001
From: Sheehan Olver <solver@mac.com>
Date: Mon, 5 Dec 2022 21:36:17 +0000
Subject: [PATCH 2/7] overload mul!

---
 src/FastTransformsForwardDiff.jl |  2 +-
 src/fft.jl                       | 15 +++++++++------
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/FastTransformsForwardDiff.jl b/src/FastTransformsForwardDiff.jl
index a966c9c..4d0d87b 100644
--- a/src/FastTransformsForwardDiff.jl
+++ b/src/FastTransformsForwardDiff.jl
@@ -2,7 +2,7 @@ module FastTransformsForwardDiff
 using ForwardDiff, FFTW
 using AbstractFFTs
 import ForwardDiff: value, partials, npartials, Dual, tagtype, derivative, jacobian, gradient
-import FFTW: r2r, r2r!, plan_r2r, plan_r2r!
+import FFTW: r2r, r2r!, plan_r2r, plan_r2r!, mul!, Plan
 
 @inline tagtype(::Complex{T}) where T = tagtype(T)
 @inline tagtype(::Type{Complex{T}}) where T = tagtype(T)
diff --git a/src/fft.jl b/src/fft.jl
index 3eceb38..b0e7438 100644
--- a/src/fft.jl
+++ b/src/fft.jl
@@ -87,10 +87,13 @@ end
 for f in (:r2r, :r2r!)
     pf = Symbol("plan_", f)
     @eval begin
-        $f(x::AbstractArray{<:Dual}, kinds) = $pf(x, kinds) * x
-        $f(x::AbstractArray{<:Dual}, kinds, region) = $pf(x, kinds, region) * x
-        $pf(x::AbstractArray{<:Dual}, kinds, region; kws...) = $pf(value.(x), kinds, region; kws...)
-        $f(x::AbstractArray{<:Complex{<:Dual}}, kinds, region=1:ndims(x)) = $pf(x, kinds) * x
-        $pf(x::AbstractArray{<:Complex{<:Dual}}, kinds, region; kws...) = $pf(value.(x), kinds, region; kws...)
+        $f(x::AbstractArray{<:Dual}, kinds, region...) = $pf(x, kinds, region...) * x
+        $pf(x::AbstractArray{<:Dual}, kinds, region...; kws...) = $pf(value.(x), kinds, region...; kws...)
+        $f(x::AbstractArray{<:Complex{<:Dual}}, kinds, region...) = $pf(x, kinds, region...) * x
+        $pf(x::AbstractArray{<:Complex{<:Dual}}, kinds, region...; kws...) = $pf(value.(x), kinds, region...; kws...)
     end
-end
\ No newline at end of file
+end
+
+
+
+mul!(y::AbstractArray{<:Dual}, p::Plan, x::AbstractArray{<:Dual}) = copyto!(y, p*x)
\ No newline at end of file

From 5dba6249d5a1ca04931948da97af862e8385f58a Mon Sep 17 00:00:00 2001
From: Sheehan Olver <solver@mac.com>
Date: Tue, 6 Dec 2022 15:56:17 +0000
Subject: [PATCH 3/7] Use matrix transforms

---
 Project.toml                     |  2 +-
 src/FastTransformsForwardDiff.jl |  3 +-
 src/fft.jl                       | 86 +++++++-------------------------
 test/runtests.jl                 |  8 +++
 4 files changed, 28 insertions(+), 71 deletions(-)

diff --git a/Project.toml b/Project.toml
index d894ca5..37e05d2 100644
--- a/Project.toml
+++ b/Project.toml
@@ -18,4 +18,4 @@ julia = "1.6"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "FFTW"]
\ No newline at end of file
+test = ["Test"]
\ No newline at end of file
diff --git a/src/FastTransformsForwardDiff.jl b/src/FastTransformsForwardDiff.jl
index 4d0d87b..19cb2b9 100644
--- a/src/FastTransformsForwardDiff.jl
+++ b/src/FastTransformsForwardDiff.jl
@@ -2,7 +2,8 @@ module FastTransformsForwardDiff
 using ForwardDiff, FFTW
 using AbstractFFTs
 import ForwardDiff: value, partials, npartials, Dual, tagtype, derivative, jacobian, gradient
-import FFTW: r2r, r2r!, plan_r2r, plan_r2r!, mul!, Plan
+import AbstractFFTs: plan_fft, plan_ifft, plan_bfft, plan_rfft
+import FFTW: r2r, r2r!, plan_r2r, mul!, Plan
 
 @inline tagtype(::Complex{T}) where T = tagtype(T)
 @inline tagtype(::Type{Complex{T}}) where T = tagtype(T)
diff --git a/src/fft.jl b/src/fft.jl
index b0e7438..2396664 100644
--- a/src/fft.jl
+++ b/src/fft.jl
@@ -1,3 +1,8 @@
+dual2array(x::Array{<:Dual{Tag,T}}) where {Tag,T} = reinterpret(reshape, T, x)
+dual2array(x::Array{<:Complex{<:Dual{Tag, T}}}) where {Tag,T} = complex.(dual2array(real(x)), dual2array(imag(x)))
+array2dual(DT::Type{<:Dual}, x::Array{T}) where T = reinterpret(reshape, DT, real(x))
+array2dual(DT::Type{<:Dual}, x::Array{<:Complex{T}}) where T = complex.(array2dual(DT, real(x)), array2dual(DT, imag(x)))
+
 value(x::Complex{<:Dual}) = Complex(x.re.value, x.im.value)
 
 partials(x::Complex{<:Dual}, n::Int) = Complex(partials(x.re, n), partials(x.im, n))
@@ -12,88 +17,31 @@ AbstractFFTs.complexfloat(d::Dual{T,V,N}) where {T,V,N} = convert(Dual{T,float(V
 AbstractFFTs.realfloat(x::AbstractArray{<:Dual}) = AbstractFFTs.realfloat.(x)
 AbstractFFTs.realfloat(d::Dual{T,V,N}) where {T,V,N} = convert(Dual{T,float(V),N}, d)
 
-for plan in [:plan_fft, :plan_ifft, :plan_bfft]
+for plan in (:plan_fft, :plan_ifft, :plan_bfft, :plan_rfft)
     @eval begin
-
-        AbstractFFTs.$plan(x::AbstractArray{<:Dual}, region=1:ndims(x)) =
-            AbstractFFTs.$plan(value.(x), region)
-
-        AbstractFFTs.$plan(x::AbstractArray{<:Complex{<:Dual}}, region=1:ndims(x)) =
-            AbstractFFTs.$plan(value.(x), region)
-
+        $plan(x::AbstractArray{<:Dual}, dims=1:ndims(x)) = $plan(dual2array(x), 1 .+ dims)
+        $plan(x::AbstractArray{<:Complex{<:Dual}}, dims=1:ndims(x)) = $plan(dual2array(x), 1 .+ dims)
     end
 end
 
-# rfft only accepts real arrays
-AbstractFFTs.plan_rfft(x::AbstractArray{<:Dual}, region=1:ndims(x)) =
-    AbstractFFTs.plan_rfft(value.(x), region)
+plan_r2r(x::AbstractArray{<:Dual}, FLAG, dims=1:ndims(x)) = plan_r2r(dual2array(x), FLAG, 1 .+ dims)
+plan_r2r(x::AbstractArray{<:Complex{<:Dual}}, FLAG, dims=1:ndims(x)) = plan_r2r(dual2array(x), FLAG, 1 .+ dims)
 
-for plan in [:plan_irfft, :plan_brfft]  # these take an extra argument, only when complex?
+for plan in (:plan_irfft, :plan_brfft)  # these take an extra argument, only when complex?
     @eval begin
-
-        AbstractFFTs.$plan(x::AbstractArray{<:Dual}, region=1:ndims(x)) =
-            AbstractFFTs.$plan(value.(x), region)
-
-        AbstractFFTs.$plan(x::AbstractArray{<:Complex{<:Dual}}, d::Integer, region=1:ndims(x)) =
-            AbstractFFTs.$plan(value.(x), d, region)
-
+        $plan(x::AbstractArray{<:Dual}, region=1:ndims(x)) = $plan(dual2array(x), 1 .+ dims)
+        $plan(x::AbstractArray{<:Complex{<:Dual}}, d::Integer, region=1:ndims(x)) = $plan(dual2array(x), d, region)
     end
 end
 
-# for f in (:dct, :idct)
-#     pf = Symbol("plan_", f)
-#     @eval begin
-#         AbstractFFTs.$f(x::AbstractArray{<:Dual}) = $pf(x) * x
-#         AbstractFFTs.$f(x::AbstractArray{<:Dual}, region) = $pf(x, region) * x
-#         AbstractFFTs.$pf(x::AbstractArray{<:Dual}, region; kws...) = $pf(value.(x), region; kws...)
-#         AbstractFFTs.$pf(x::AbstractArray{<:Complex}, region; kws...) = $pf(value.(x), region; kws...)
-#     end
-# end
+r2r(x::AbstractArray{<:Dual}, kinds, region...) = plan_r2r(x, kinds, region...) * x
 
 
-for P in [:Plan, :ScaledPlan]  # need ScaledPlan to avoid ambiguities
+for P in (:Plan, :ScaledPlan)  # need ScaledPlan to avoid ambiguities
     @eval begin
-        Base.:*(p::AbstractFFTs.$P, x::AbstractArray{<:Dual}) = _apply_plan(p, x)
-        Base.:*(p::AbstractFFTs.$P, x::AbstractArray{<:Complex{<:Dual}}) = _apply_plan(p, x)
-    end
-end
-
-function _apply_plan(p::AbstractFFTs.Plan, x::AbstractArray)
-    xtil = p * value.(x)
-    dxtils = ntuple(npartials(eltype(x))) do n
-        p * partials.(x, n)
+        Base.:*(p::AbstractFFTs.$P, x::AbstractArray{DT}) where DT<:Dual = array2dual(DT, p * dual2array(x))
+        Base.:*(p::AbstractFFTs.$P, x::AbstractArray{<:Complex{DT}}) where DT<:Dual = array2dual(DT, p * dual2array(x))
     end
-    __apply_plan(eltype(x), xtil, dxtils)
 end
 
-function __apply_plan(Ti::Type{<:Complex}, xtil, dxtils)
-    T = tagtype(Ti)
-    map(xtil, dxtils...) do val, parts...
-        Complex(
-            Dual{T}(real(val), map(real, parts)),
-            Dual{T}(imag(val), map(imag, parts)),
-        )
-    end
-end
-
-function __apply_plan(Ti::Type{<:Real}, xtil, dxtils)
-    T = tagtype(Ti)
-    map(xtil, dxtils...) do val, parts...
-        Dual{T}(val, parts)
-    end
-end
-
-
-for f in (:r2r, :r2r!)
-    pf = Symbol("plan_", f)
-    @eval begin
-        $f(x::AbstractArray{<:Dual}, kinds, region...) = $pf(x, kinds, region...) * x
-        $pf(x::AbstractArray{<:Dual}, kinds, region...; kws...) = $pf(value.(x), kinds, region...; kws...)
-        $f(x::AbstractArray{<:Complex{<:Dual}}, kinds, region...) = $pf(x, kinds, region...) * x
-        $pf(x::AbstractArray{<:Complex{<:Dual}}, kinds, region...; kws...) = $pf(value.(x), kinds, region...; kws...)
-    end
-end
-
-
-
 mul!(y::AbstractArray{<:Dual}, p::Plan, x::AbstractArray{<:Dual}) = copyto!(y, p*x)
\ No newline at end of file
diff --git a/test/runtests.jl b/test/runtests.jl
index bff973c..b18c151 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -8,6 +8,7 @@ using AbstractFFTs: complexfloat, realfloat
 
     @test value.(x1) == 1:4
     @test partials.(x1, 1) == 2:5
+    @test partials.(x1, 2) == 3:6
 
     @test complexfloat(x1)[1] === complexfloat(x1[1]) === Dual(1.0, 2.0, 3.0) + 0im
     @test realfloat(x1)[1] === realfloat(x1[1]) === Dual(1.0, 2.0, 3.0)
@@ -17,6 +18,7 @@ using AbstractFFTs: complexfloat, realfloat
     @testset "$f" for f in [fft, ifft, rfft, bfft]
         @test value.(f(x1)) == f(value.(x1))
         @test partials.(f(x1), 1) == f(partials.(x1, 1))
+        @test partials.(f(x1), 2) == f(partials.(x1, 2))
     end
 
     f = x -> real(fft([x; 0; 0])[1])
@@ -36,6 +38,12 @@ using AbstractFFTs: complexfloat, realfloat
 end
 
 @testset "r2r" begin
+    x1 = Dual.(1:4.0, 2:5, 3:6)
+
+    @test value.(FFTW.r2r(x1, FFTW.R2HC)) == FFTW.r2r(value.(x1), FFTW.R2HC)
+    @test partials.(FFTW.r2r(x1, FFTW.R2HC), 1) == FFTW.r2r(partials.(x1, 1), FFTW.R2HC)
+    @test partials.(FFTW.r2r(x1, FFTW.R2HC), 2) == FFTW.r2r(partials.(x1, 2), FFTW.R2HC)
+
     f = ω -> FFTW.r2r([ω; zeros(9)], FFTW.R2HC)[1]
     @test derivative(f, 0.1) ≡ 1.0
 end
\ No newline at end of file

From 45d7d521178c290d04ff358f662c042617a630d1 Mon Sep 17 00:00:00 2001
From: Sheehan Olver <solver@mac.com>
Date: Tue, 6 Dec 2022 16:02:09 +0000
Subject: [PATCH 4/7] add matrix tests

---
 test/runtests.jl | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/test/runtests.jl b/test/runtests.jl
index b18c151..2e6c595 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -35,6 +35,21 @@ using AbstractFFTs: complexfloat, realfloat
 
     # c = x -> dct([x; 0; 0])[1]
     # @test derivative(c,0.1) ≈ 1
+
+    @testset "matrix" begin
+        A = x1 * (1:10)'
+        @test value.(fft(A)) == fft(value.(A))
+        @test partials.(fft(A), 1) == fft(partials.(A, 1))
+        @test partials.(fft(A), 2) == fft(partials.(A, 2))
+
+        @test value.(fft(A, 1)) == fft(value.(A), 1)
+        @test partials.(fft(A, 1), 1) == fft(partials.(A, 1), 1)
+        @test partials.(fft(A, 1), 2) == fft(partials.(A, 2), 1)
+
+        @test value.(fft(A, 2)) == fft(value.(A), 2)
+        @test partials.(fft(A, 2), 1) == fft(partials.(A, 1), 2)
+        @test partials.(fft(A, 2), 2) == fft(partials.(A, 2), 2)
+    end
 end
 
 @testset "r2r" begin

From cb407ac877058b2acc7f4d67d739b1d966588d4a Mon Sep 17 00:00:00 2001
From: Sheehan Olver <solver@mac.com>
Date: Tue, 6 Dec 2022 16:20:46 +0000
Subject: [PATCH 5/7] add tests

---
 src/FastTransformsForwardDiff.jl |  2 +-
 src/fft.jl                       |  5 +++--
 test/runtests.jl                 | 26 ++++++++++++++++++++++----
 3 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/src/FastTransformsForwardDiff.jl b/src/FastTransformsForwardDiff.jl
index 19cb2b9..25b9472 100644
--- a/src/FastTransformsForwardDiff.jl
+++ b/src/FastTransformsForwardDiff.jl
@@ -2,7 +2,7 @@ module FastTransformsForwardDiff
 using ForwardDiff, FFTW
 using AbstractFFTs
 import ForwardDiff: value, partials, npartials, Dual, tagtype, derivative, jacobian, gradient
-import AbstractFFTs: plan_fft, plan_ifft, plan_bfft, plan_rfft
+import AbstractFFTs: plan_fft, plan_ifft, plan_bfft, plan_rfft, plan_brfft, plan_irfft
 import FFTW: r2r, r2r!, plan_r2r, mul!, Plan
 
 @inline tagtype(::Complex{T}) where T = tagtype(T)
diff --git a/src/fft.jl b/src/fft.jl
index 2396664..262f762 100644
--- a/src/fft.jl
+++ b/src/fft.jl
@@ -29,12 +29,13 @@ plan_r2r(x::AbstractArray{<:Complex{<:Dual}}, FLAG, dims=1:ndims(x)) = plan_r2r(
 
 for plan in (:plan_irfft, :plan_brfft)  # these take an extra argument, only when complex?
     @eval begin
-        $plan(x::AbstractArray{<:Dual}, region=1:ndims(x)) = $plan(dual2array(x), 1 .+ dims)
-        $plan(x::AbstractArray{<:Complex{<:Dual}}, d::Integer, region=1:ndims(x)) = $plan(dual2array(x), d, region)
+        $plan(x::AbstractArray{<:Dual}, dims=1:ndims(x)) = $plan(dual2array(x), 1 .+ dims)
+        $plan(x::AbstractArray{<:Complex{<:Dual}}, d::Integer, dims=1:ndims(x)) = $plan(dual2array(x), d, 1 .+ dims)
     end
 end
 
 r2r(x::AbstractArray{<:Dual}, kinds, region...) = plan_r2r(x, kinds, region...) * x
+r2r(x::AbstractArray{<:Complex{<:Dual}}, kinds, region...) = plan_r2r(x, kinds, region...) * x
 
 
 for P in (:Plan, :ScaledPlan)  # need ScaledPlan to avoid ambiguities
diff --git a/test/runtests.jl b/test/runtests.jl
index 2e6c595..09ae933 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -2,6 +2,12 @@ using FastTransformsForwardDiff, FFTW, Test
 using ForwardDiff: Dual, valtype, value, partials, derivative
 using AbstractFFTs: complexfloat, realfloat
 
+@testset "complex dual" begin
+    x = Dual(1., 2., 3.) + im*Dual(4.,5.,6.)
+    @test value(x) == 1 + 4im
+    @test partials(x,1) == 2 + 5im
+    @test partials(x,2) == 3 + 6im
+end
 
 @testset "fft and rfft" begin
     x1 = Dual.(1:4.0, 2:5, 3:6)
@@ -15,12 +21,16 @@ using AbstractFFTs: complexfloat, realfloat
 
     @test fft(x1, 1)[1] isa Complex{<:Dual}
 
-    @testset "$f" for f in [fft, ifft, rfft, bfft]
+    @testset "$f" for f in (fft, ifft, rfft, bfft)
         @test value.(f(x1)) == f(value.(x1))
         @test partials.(f(x1), 1) == f(partials.(x1, 1))
         @test partials.(f(x1), 2) == f(partials.(x1, 2))
     end
 
+    @test ifft(fft(x1)) == x1
+    @test irfft(rfft(x1), length(x1)) ≈ x1
+    @test brfft(rfft(x1), length(x1)) ≈ 4x1
+
     f = x -> real(fft([x; 0; 0])[1])
     @test derivative(f,0.1) ≈ 1
 
@@ -54,11 +64,19 @@ end
 
 @testset "r2r" begin
     x1 = Dual.(1:4.0, 2:5, 3:6)
+    t = FFTW.r2r(x1, FFTW.R2HC)
 
-    @test value.(FFTW.r2r(x1, FFTW.R2HC)) == FFTW.r2r(value.(x1), FFTW.R2HC)
-    @test partials.(FFTW.r2r(x1, FFTW.R2HC), 1) == FFTW.r2r(partials.(x1, 1), FFTW.R2HC)
-    @test partials.(FFTW.r2r(x1, FFTW.R2HC), 2) == FFTW.r2r(partials.(x1, 2), FFTW.R2HC)
+    @test value.(t) == FFTW.r2r(value.(x1), FFTW.R2HC)
+    @test partials.(t, 1) == FFTW.r2r(partials.(x1, 1), FFTW.R2HC)
+    @test partials.(t, 2) == FFTW.r2r(partials.(x1, 2), FFTW.R2HC)
+
+    t = FFTW.r2r(x1 + 2im*x1, FFTW.R2HC)
+    @test value.(t) == FFTW.r2r(value.(x1 + 2im*x1), FFTW.R2HC)
+    @test partials.(t, 1) == FFTW.r2r(partials.(x1 + 2im*x1, 1), FFTW.R2HC)
+    @test partials.(t, 2) == FFTW.r2r(partials.(x1 + 2im*x1, 2), FFTW.R2HC)
 
     f = ω -> FFTW.r2r([ω; zeros(9)], FFTW.R2HC)[1]
     @test derivative(f, 0.1) ≡ 1.0
+
+    @test mul!(similar(x1), FFTW.plan_r2r(x1, FFTW.R2HC), x1) == FFTW.r2r(x1, FFTW.R2HC)
 end
\ No newline at end of file

From 3c0de6f1e063c67e10842919784d28d92ee4d598 Mon Sep 17 00:00:00 2001
From: Sheehan Olver <solver@mac.com>
Date: Tue, 6 Dec 2022 16:55:21 +0000
Subject: [PATCH 6/7] Update runtests.jl

---
 test/runtests.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/runtests.jl b/test/runtests.jl
index 09ae933..9d1dce2 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -1,4 +1,4 @@
-using FastTransformsForwardDiff, FFTW, Test
+using FastTransformsForwardDiff, FFTW, LinearAlgebra, Test
 using ForwardDiff: Dual, valtype, value, partials, derivative
 using AbstractFFTs: complexfloat, realfloat
 

From b684295f76f2d68760645060a787a41815c97541 Mon Sep 17 00:00:00 2001
From: Sheehan Olver <solver@mac.com>
Date: Tue, 6 Dec 2022 18:06:41 +0000
Subject: [PATCH 7/7] Update Project.toml

---
 Project.toml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Project.toml b/Project.toml
index 37e05d2..734ab0a 100644
--- a/Project.toml
+++ b/Project.toml
@@ -15,7 +15,8 @@ ForwardDiff = "0.10"
 julia = "1.6"
 
 [extras]
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test"]
\ No newline at end of file
+test = ["Test", "LinearAlgebra"]
\ No newline at end of file