From d53f57de8fb567cc8fdc4c279dca641a24f2b28e Mon Sep 17 00:00:00 2001
From: Vedant Puri <vedantpuri@gmail.com>
Date: Sat, 8 Jul 2023 22:00:52 -0400
Subject: [PATCH 1/9] make ProjectionStyle abstract type so we can subtype in
 downstream packages. add a few lines of docs

---
 src/definitions.jl | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/definitions.jl b/src/definitions.jl
index 4ec176e..604329f 100644
--- a/src/definitions.jl
+++ b/src/definitions.jl
@@ -583,12 +583,30 @@ plan_brfft
 
 ##############################################################################
 
-struct NoProjectionStyle end
-struct RealProjectionStyle end 
-struct RealInverseProjectionStyle 
+abstract type ProjectionStyle end
+
+"""
+    NoProjectionStyle()
+
+Projection style for complex to complex discrete Fourier transform
+"""
+struct NoProjectionStyle <: ProjectionStyle end
+
+"""
+    RealProjectionStyle()
+
+Projection style for complex to real discrete Fourier transform
+"""
+struct RealProjectionStyle <: ProjectionStyle end 
+
+"""
+    RealInverseProjectionStyle()
+
+Projection style for inverse of complex to real discrete Fourier transform
+"""
+struct RealInverseProjectionStyle <: ProjectionStyle
     dim::Int
 end
-const ProjectionStyle = Union{NoProjectionStyle, RealProjectionStyle, RealInverseProjectionStyle}
 
 output_size(p::Plan) = _output_size(p, ProjectionStyle(p))
 _output_size(p::Plan, ::NoProjectionStyle) = size(p)

From f3575aa3b402faac5abcff32a7b21424f78274bb Mon Sep 17 00:00:00 2001
From: Gaurav Arya <gauravarya272@gmail.com>
Date: Tue, 18 Jul 2023 12:44:04 -0400
Subject: [PATCH 2/9] Rename ProjectionStyle -> AdjointStyle, _mul ->
 AdjointMul, improve docs

---
 docs/src/api.md             |  4 ++
 docs/src/implementations.md |  9 ++--
 src/definitions.jl          | 86 ++++++++++++++++++++++++-------------
 test/testplans.jl           | 10 ++---
 4 files changed, 69 insertions(+), 40 deletions(-)

diff --git a/docs/src/api.md b/docs/src/api.md
index bb3b849..ef998f8 100644
--- a/docs/src/api.md
+++ b/docs/src/api.md
@@ -21,6 +21,10 @@ AbstractFFTs.plan_brfft
 AbstractFFTs.plan_irfft
 AbstractFFTs.fftdims
 Base.adjoint
+AbstractFFTs.FFTAdjointStyle
+AbstractFFTs.RFFTAdjointStyle
+AbstractFFTs.IRFFTAdjointStyle
+AbstractFFTs.UnitaryAdjointStyle
 AbstractFFTs.fftshift
 AbstractFFTs.fftshift!
 AbstractFFTs.ifftshift
diff --git a/docs/src/implementations.md b/docs/src/implementations.md
index 7367fd4..364d21b 100644
--- a/docs/src/implementations.md
+++ b/docs/src/implementations.md
@@ -32,10 +32,11 @@ To define a new FFT implementation in your own module, you should
 
 * You can also define similar methods of `plan_rfft` and `plan_brfft` for real-input FFTs.
 
-* To enable automatic computation of adjoint plans via [`Base.adjoint`](@ref) (used in rules for reverse-mode differentiation), define the trait `AbstractFFTs.ProjectionStyle(::MyPlan)`, which can return:
-    * `AbstractFFTs.NoProjectionStyle()`,
-    * `AbstractFFTs.RealProjectionStyle()`, for plans that halve one of the output's dimensions analogously to [`rfft`](@ref),
-    * `AbstractFFTs.RealInverseProjectionStyle(d::Int)`, for plans that expect an input with a halved dimension analogously to [`irfft`](@ref), where `d` is the original length of the dimension.
+* We offer an experimental `AdjointStyle` trait to enable automatic computation of adjoint plans via [`Base.adjoint`](@ref). 
+  To support adjoints in a new plan, define the trait `AbstractFFTs.AdjointStyle(::MyPlan)`. This should return a subtype of `AS <: AbstractFFTs.AdjointStyle` supporting `AbstractFFTs.adjoint_mul(::Plan, ::AbstractArray, ::AS)` and 
+  `AbstractFFTs._output_size(::Plan, ::AS)`. 
+
+  `AbstractFFTs` pre-implements the following adjoint styles: [`AbstractFFTs.FFTAdjointStyle`](@ref), [`AbstractFFTs.RFFTAdjointStyle`](@ref), [`AbstractFFTs.IRFFTAdjointStyle`](@ref), and [`AbstractFFTs.UnitaryAdjointStyle`](@ref).
 
 The normalization convention for your FFT should be that it computes ``y_k = \sum_j x_j \exp(-2\pi i j k/n)`` for a transform of
 length ``n``, and the "backwards" (unnormalized inverse) transform computes the same thing but with ``\exp(+2\pi i jk/n)``.
diff --git a/src/definitions.jl b/src/definitions.jl
index 604329f..e495104 100644
--- a/src/definitions.jl
+++ b/src/definitions.jl
@@ -583,35 +583,57 @@ plan_brfft
 
 ##############################################################################
 
-abstract type ProjectionStyle end
+abstract type AdjointStyle end
 
 """
-    NoProjectionStyle()
+    FFTAdjointStyle()
 
-Projection style for complex to complex discrete Fourier transform
+Projection style for complex to complex discrete Fourier transforms. 
+    
+Since the Fourier transform is unitary up to a scaling, the adjoint simply applies 
+the transform's inverse with an appropriate scaling.
 """
-struct NoProjectionStyle <: ProjectionStyle end
+struct FFTAdjointStyle <: AdjointStyle end
 
 """
-    RealProjectionStyle()
+    RFFTAdjointStyle()
 
-Projection style for complex to real discrete Fourier transform
+Projection style for real to complex discrete Fourier transforms, for plans that 
+halve one of the output's dimensions analogously to [`rfft`](@ref).
+    
+Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
+inverse, but with additional logic to handle the fact that the output is projected 
+to exploit its conjugate symmetry (see [`rfft`](@ref)). 
 """
-struct RealProjectionStyle <: ProjectionStyle end 
+struct RFFTAdjointStyle <: AdjointStyle end 
 
 """
-    RealInverseProjectionStyle()
+    IRFFTAdjointStyle(d::Dim)
 
-Projection style for inverse of complex to real discrete Fourier transform
+Projection style for complex to real discrete Fourier transforms, for plans that 
+expect an input with a halved dimension analogously to [`irfft`](@ref), where `d` 
+is the original length of the dimension.
+    
+Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
+inverse, but with additional logic to handle the fact that the input is projected 
+to exploit its conjugate symmetry (see [`irfft`](@ref)). 
 """
-struct RealInverseProjectionStyle <: ProjectionStyle
+struct IRFFTAdjointStyle <: AdjointStyle
     dim::Int
 end
 
-output_size(p::Plan) = _output_size(p, ProjectionStyle(p))
-_output_size(p::Plan, ::NoProjectionStyle) = size(p)
-_output_size(p::Plan, ::RealProjectionStyle) = rfft_output_size(size(p), fftdims(p))
-_output_size(p::Plan, s::RealInverseProjectionStyle) = brfft_output_size(size(p), s.dim, fftdims(p))
+"""
+    UnitaryAdjointStyle()
+
+Projection style for unitary transforms, whose adjoint equals their inverse.
+"""
+struct UnitaryAdjointStyle <: AdjointStyle end
+
+output_size(p::Plan) = _output_size(p, AdjointStyle(p))
+_output_size(p::Plan, ::FFTAdjointStyle) = size(p)
+_output_size(p::Plan, ::RFFTAdjointStyle) = rfft_output_size(size(p), fftdims(p))
+_output_size(p::Plan, s::IRFFTAdjointStyle) = brfft_output_size(size(p), s.dim, fftdims(p))
+_output_size(p::Plan, ::UnitaryAdjointStyle) = size(p)
 
 struct AdjointPlan{T,P<:Plan} <: Plan{T}
     p::P
@@ -638,40 +660,42 @@ Base.adjoint(p::ScaledPlan) = ScaledPlan(p.p', p.scale)
 size(p::AdjointPlan) = output_size(p.p)
 output_size(p::AdjointPlan) = size(p.p)
 
-Base.:*(p::AdjointPlan, x::AbstractArray) = _mul(p, x, ProjectionStyle(p.p))
+Base.:*(p::AdjointPlan, x::AbstractArray) = adjoint_mul(p.p, x, AdjointStyle(p.p))
 
-function _mul(p::AdjointPlan{T}, x::AbstractArray, ::NoProjectionStyle) where {T}
-    dims = fftdims(p.p)
-    N = normalization(T, size(p.p), dims)
-    return (p.p \ x) / N
+function adjoint_mul(p::Plan{T}, x::AbstractArray, ::FFTAdjointStyle) where {T}
+    dims = fftdims(p)
+    N = normalization(T, size(p), dims)
+    return (p \ x) / N
 end
 
-function _mul(p::AdjointPlan{T}, x::AbstractArray, ::RealProjectionStyle) where {T<:Real}
-    dims = fftdims(p.p)
-    N = normalization(T, size(p.p), dims)
+function adjoint_mul(p::Plan{T}, x::AbstractArray, ::RFFTAdjointStyle) where {T<:Real}
+    dims = fftdims(p)
+    N = normalization(T, size(p), dims)
     halfdim = first(dims)
-    d = size(p.p, halfdim)
-    n = output_size(p.p, halfdim)
+    d = size(p, halfdim)
+    n = output_size(p, halfdim)
     scale = reshape(
         [(i == 1 || (i == n && 2 * (i - 1)) == d) ? N : 2 * N for i in 1:n],
         ntuple(i -> i == halfdim ? n : 1, Val(ndims(x)))
     )
-    return p.p \ (x ./ convert(typeof(x), scale))
+    return p \ (x ./ convert(typeof(x), scale))
 end
 
-function _mul(p::AdjointPlan{T}, x::AbstractArray, ::RealInverseProjectionStyle) where {T}
-    dims = fftdims(p.p)
-    N = normalization(real(T), output_size(p.p), dims)
+function adjoint_mul(p::Plan{T}, x::AbstractArray, ::IRFFTAdjointStyle) where {T}
+    dims = fftdims(p)
+    N = normalization(real(T), output_size(p), dims)
     halfdim = first(dims)
-    n = size(p.p, halfdim)
-    d = output_size(p.p, halfdim)
+    n = size(p, halfdim)
+    d = output_size(p, halfdim)
     scale = reshape(
         [(i == 1 || (i == n && 2 * (i - 1)) == d) ? 1 : 2 for i in 1:n],
         ntuple(i -> i == halfdim ? n : 1, Val(ndims(x)))
     )
-    return (convert(typeof(x), scale) ./ N) .* (p.p \ x)
+    return (convert(typeof(x), scale) ./ N) .* (p \ x)
 end
 
+adjoint_mul(p::Plan, x::AbstractArray, ::UnitaryAdjointStyle) = p \ x
+
 # Analogously to ScaledPlan, define both plan_inv (for no caching) and inv (caches inner plan only).
 plan_inv(p::AdjointPlan) = adjoint(plan_inv(p.p)) 
 inv(p::AdjointPlan) = adjoint(inv(p.p))
diff --git a/test/testplans.jl b/test/testplans.jl
index 09b3f67..c6a76f9 100644
--- a/test/testplans.jl
+++ b/test/testplans.jl
@@ -21,8 +21,8 @@ Base.ndims(::TestPlan{T,N}) where {T,N} = N
 Base.size(p::InverseTestPlan) = p.sz
 Base.ndims(::InverseTestPlan{T,N}) where {T,N} = N
 
-AbstractFFTs.ProjectionStyle(::TestPlan) = AbstractFFTs.NoProjectionStyle()
-AbstractFFTs.ProjectionStyle(::InverseTestPlan) = AbstractFFTs.NoProjectionStyle()
+AbstractFFTs.AdjointStyle(::TestPlan) = AbstractFFTs.FFTAdjointStyle()
+AbstractFFTs.AdjointStyle(::InverseTestPlan) = AbstractFFTs.FFTAdjointStyle()
 
 function AbstractFFTs.plan_fft(x::AbstractArray{T}, region; kwargs...) where {T}
     return TestPlan{T}(region, size(x))
@@ -110,8 +110,8 @@ mutable struct InverseTestRPlan{T,N,G} <: Plan{Complex{T}}
     end
 end
 
-AbstractFFTs.ProjectionStyle(::TestRPlan) = AbstractFFTs.RealProjectionStyle()
-AbstractFFTs.ProjectionStyle(p::InverseTestRPlan) = AbstractFFTs.RealInverseProjectionStyle(p.d)
+AbstractFFTs.AdjointStyle(::TestRPlan) = AbstractFFTs.RFFTAdjointStyle()
+AbstractFFTs.AdjointStyle(p::InverseTestRPlan) = AbstractFFTs.IRFFTAdjointStyle(p.d)
 
 function AbstractFFTs.plan_rfft(x::AbstractArray{T}, region; kwargs...) where {T<:Real}
     return TestRPlan{T}(region, size(x))
@@ -241,7 +241,7 @@ end
 
 Base.size(p::InplaceTestPlan) = size(p.plan)
 Base.ndims(p::InplaceTestPlan) = ndims(p.plan)
-AbstractFFTs.ProjectionStyle(p::InplaceTestPlan) = AbstractFFTs.ProjectionStyle(p.plan)
+AbstractFFTs.AdjointStyle(p::InplaceTestPlan) = AbstractFFTs.AdjointStyle(p.plan)
 
 function AbstractFFTs.plan_fft!(x::AbstractArray, region; kwargs...)
     return InplaceTestPlan(plan_fft(x, region; kwargs...))

From 00eef4f5e54ba3275a5907a6a21fa336e694790d Mon Sep 17 00:00:00 2001
From: Gaurav Arya <gauravarya272@gmail.com>
Date: Wed, 19 Jul 2023 15:05:14 -0400
Subject: [PATCH 3/9] Clarify normalization

---
 src/definitions.jl | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/definitions.jl b/src/definitions.jl
index e495104..4c59b00 100644
--- a/src/definitions.jl
+++ b/src/definitions.jl
@@ -588,8 +588,9 @@ abstract type AdjointStyle end
 """
     FFTAdjointStyle()
 
-Projection style for complex to complex discrete Fourier transforms. 
-    
+Projection style for complex to complex discrete Fourier transforms that normalize 
+the output analogously to [`fft`](@ref).
+
 Since the Fourier transform is unitary up to a scaling, the adjoint simply applies 
 the transform's inverse with an appropriate scaling.
 """
@@ -598,8 +599,8 @@ struct FFTAdjointStyle <: AdjointStyle end
 """
     RFFTAdjointStyle()
 
-Projection style for real to complex discrete Fourier transforms, for plans that 
-halve one of the output's dimensions analogously to [`rfft`](@ref).
+Projection style for real to complex discrete Fourier transforms that halve
+one of the output's dimensions and normalize the output analogously to [`rfft`](@ref).
     
 Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
 inverse, but with additional logic to handle the fact that the output is projected 
@@ -610,9 +611,9 @@ struct RFFTAdjointStyle <: AdjointStyle end
 """
     IRFFTAdjointStyle(d::Dim)
 
-Projection style for complex to real discrete Fourier transforms, for plans that 
-expect an input with a halved dimension analogously to [`irfft`](@ref), where `d` 
-is the original length of the dimension.
+Projection style for complex to real discrete Fourier transforms that expect
+an input with a halved dimension and normalize the output analogously to [`irfft`](@ref), 
+where `d` is the original length of the dimension.
     
 Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
 inverse, but with additional logic to handle the fact that the input is projected 

From 17adac8b812346040417adf2066224c722d6a89e Mon Sep 17 00:00:00 2001
From: Gaurav Arya <gauravarya272@gmail.com>
Date: Wed, 19 Jul 2023 18:34:06 -0400
Subject: [PATCH 4/9] Clarify documentation, rename _output_size -> output_size

---
 docs/src/api.md             | 23 +++++++++++----
 docs/src/implementations.md |  9 +++---
 src/definitions.jl          | 57 +++++++++++++++++++++++++++----------
 3 files changed, 64 insertions(+), 25 deletions(-)

diff --git a/docs/src/api.md b/docs/src/api.md
index ef998f8..713e62d 100644
--- a/docs/src/api.md
+++ b/docs/src/api.md
@@ -1,5 +1,7 @@
 # Public Interface
 
+## FFT and FFT planning functions
+
 ```@docs
 AbstractFFTs.fft
 AbstractFFTs.fft!
@@ -20,15 +22,26 @@ AbstractFFTs.plan_rfft
 AbstractFFTs.plan_brfft
 AbstractFFTs.plan_irfft
 AbstractFFTs.fftdims
-Base.adjoint
-AbstractFFTs.FFTAdjointStyle
-AbstractFFTs.RFFTAdjointStyle
-AbstractFFTs.IRFFTAdjointStyle
-AbstractFFTs.UnitaryAdjointStyle
 AbstractFFTs.fftshift
 AbstractFFTs.fftshift!
 AbstractFFTs.ifftshift
 AbstractFFTs.ifftshift!
 AbstractFFTs.fftfreq
 AbstractFFTs.rfftfreq
+Base.size
+```
+
+## Adjoint functionality
+
+The following API is supported by plans that support adjoint functionality.
+It is also relevant to implementers of FFT plans that wish to support adjoints.
+```@docs
+Base.adjoint
+AbstractFFTs.AdjointStyle
+AbstractFFTs.output_size
+AbstractFFTs.adjoint_mul
+AbstractFFTs.FFTAdjointStyle
+AbstractFFTs.RFFTAdjointStyle
+AbstractFFTs.IRFFTAdjointStyle
+AbstractFFTs.UnitaryAdjointStyle
 ```
diff --git a/docs/src/implementations.md b/docs/src/implementations.md
index 364d21b..efa3be4 100644
--- a/docs/src/implementations.md
+++ b/docs/src/implementations.md
@@ -32,11 +32,10 @@ To define a new FFT implementation in your own module, you should
 
 * You can also define similar methods of `plan_rfft` and `plan_brfft` for real-input FFTs.
 
-* We offer an experimental `AdjointStyle` trait to enable automatic computation of adjoint plans via [`Base.adjoint`](@ref). 
-  To support adjoints in a new plan, define the trait `AbstractFFTs.AdjointStyle(::MyPlan)`. This should return a subtype of `AS <: AbstractFFTs.AdjointStyle` supporting `AbstractFFTs.adjoint_mul(::Plan, ::AbstractArray, ::AS)` and 
-  `AbstractFFTs._output_size(::Plan, ::AS)`. 
-
-  `AbstractFFTs` pre-implements the following adjoint styles: [`AbstractFFTs.FFTAdjointStyle`](@ref), [`AbstractFFTs.RFFTAdjointStyle`](@ref), [`AbstractFFTs.IRFFTAdjointStyle`](@ref), and [`AbstractFFTs.UnitaryAdjointStyle`](@ref).
+* To support adjoints in a new plan, define the trait [`AbstractFFTs.AdjointStyle`](@ref).
+  `AbstractFFTs` implements the following adjoint styles: [`AbstractFFTs.FFTAdjointStyle`](@ref), [`AbstractFFTs.RFFTAdjointStyle`](@ref), [`AbstractFFTs.IRFFTAdjointStyle`](@ref), and [`AbstractFFTs.UnitaryAdjointStyle`](@ref).
+  To define a new adjoint style of type `AS <: AbstractFFTs.AdjointStyle`, define the methods
+  [`AbstractFFTs.adjoint_mul`](@ref) and [`AbstractFFTs.output_size`](@ref).
 
 The normalization convention for your FFT should be that it computes ``y_k = \sum_j x_j \exp(-2\pi i j k/n)`` for a transform of
 length ``n``, and the "backwards" (unnormalized inverse) transform computes the same thing but with ``\exp(+2\pi i jk/n)``.
diff --git a/src/definitions.jl b/src/definitions.jl
index 4c59b00..b642ac5 100644
--- a/src/definitions.jl
+++ b/src/definitions.jl
@@ -583,12 +583,19 @@ plan_brfft
 
 ##############################################################################
 
+"""
+    AbstractFFTs.AdjointStyle(::Plan)
+
+Return the adjoint style of a plan, enabling automatic computation of adjoint plans via
+[`Base.adjoint`](@ref). Instructions for supporting adjoint styles are provided in the
+[implementation instructions](implementations.md#Defining-a-new-implementation).
+"""
 abstract type AdjointStyle end
 
 """
     FFTAdjointStyle()
 
-Projection style for complex to complex discrete Fourier transforms that normalize 
+Adjoint style for complex to complex discrete Fourier transforms that normalize
 the output analogously to [`fft`](@ref).
 
 Since the Fourier transform is unitary up to a scaling, the adjoint simply applies 
@@ -599,8 +606,8 @@ struct FFTAdjointStyle <: AdjointStyle end
 """
     RFFTAdjointStyle()
 
-Projection style for real to complex discrete Fourier transforms that halve
-one of the output's dimensions and normalize the output analogously to [`rfft`](@ref).
+Adjoint style for real to complex discrete Fourier transforms that halve one of
+the output's dimensions and normalize the output, analogously to [`rfft`](@ref).
     
 Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
 inverse, but with additional logic to handle the fact that the output is projected 
@@ -611,8 +618,8 @@ struct RFFTAdjointStyle <: AdjointStyle end
 """
     IRFFTAdjointStyle(d::Dim)
 
-Projection style for complex to real discrete Fourier transforms that expect
-an input with a halved dimension and normalize the output analogously to [`irfft`](@ref), 
+Adjoint style for complex to real discrete Fourier transforms that expect an input
+with a halved dimension and normalize the output, analogously to [`irfft`](@ref),
 where `d` is the original length of the dimension.
     
 Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
@@ -626,15 +633,22 @@ end
 """
     UnitaryAdjointStyle()
 
-Projection style for unitary transforms, whose adjoint equals their inverse.
+Adjoint style for unitary transforms, whose adjoint equals their inverse.
 """
 struct UnitaryAdjointStyle <: AdjointStyle end
 
-output_size(p::Plan) = _output_size(p, AdjointStyle(p))
-_output_size(p::Plan, ::FFTAdjointStyle) = size(p)
-_output_size(p::Plan, ::RFFTAdjointStyle) = rfft_output_size(size(p), fftdims(p))
-_output_size(p::Plan, s::IRFFTAdjointStyle) = brfft_output_size(size(p), s.dim, fftdims(p))
-_output_size(p::Plan, ::UnitaryAdjointStyle) = size(p)
+"""
+    output_size(p::Plan)
+
+Return the size of the output of a plan `p`.
+
+Implementations of a new adjoint style `AS <: AbstractFFTs.AdjointStyle` should define `output_size(::Plan, ::AS)`.
+"""
+output_size(p::Plan) = output_size(p, AdjointStyle(p))
+output_size(p::Plan, ::FFTAdjointStyle) = size(p)
+output_size(p::Plan, ::RFFTAdjointStyle) = rfft_output_size(size(p), fftdims(p))
+output_size(p::Plan, s::IRFFTAdjointStyle) = brfft_output_size(size(p), s.dim, fftdims(p))
+output_size(p::Plan, ::UnitaryAdjointStyle) = size(p)
 
 struct AdjointPlan{T,P<:Plan} <: Plan{T}
     p::P
@@ -645,9 +659,7 @@ end
     (p::Plan)'
     adjoint(p::Plan)
 
-Form the adjoint operator of an FFT plan. Returns a plan that performs the adjoint operation of
-the original plan. Note that this differs from the corresponding backwards plan in the case of real
-FFTs due to the halving of one of the dimensions of the FFT output, as described in [`rfft`](@ref).
+Return a plan that performs the adjoint operation of the original plan.
 
 !!! note
     Adjoint plans do not currently support `LinearAlgebra.mul!`. Further, as a new addition to `AbstractFFTs`, 
@@ -658,10 +670,25 @@ Base.adjoint(p::AdjointPlan) = p.p
 # always have AdjointPlan inside ScaledPlan.
 Base.adjoint(p::ScaledPlan) = ScaledPlan(p.p', p.scale)
 
+"""
+    size(p::Plan)
+
+Return the size of the input of a plan `p`.
+"""
 size(p::AdjointPlan) = output_size(p.p)
 output_size(p::AdjointPlan) = size(p.p)
 
-Base.:*(p::AdjointPlan, x::AbstractArray) = adjoint_mul(p.p, x, AdjointStyle(p.p))
+Base.:*(p::AdjointPlan, x::AbstractArray) = adjoint_mul(p.p, x)
+
+"""
+    adjoint_mul(p::Plan, x::AbstractArray)
+
+Multiply an array `x` by the adjoint of a plan `p`. This is equivalent to `p' * x`.
+
+Implementations of a new adjoint style `AS <: AbstractFFTs.AdjointStyle` should define
+`adjoint_mul(::Plan, ::AbstractArray, ::AS)`.
+"""
+adjoint_mul(p::Plan, x::AbstractArray) = adjoint_mul(p, x, AdjointStyle(p))
 
 function adjoint_mul(p::Plan{T}, x::AbstractArray, ::FFTAdjointStyle) where {T}
     dims = fftdims(p)

From bbd9f41b0ce9c04d6a5b0e1b388033169dbf63cb Mon Sep 17 00:00:00 2001
From: Gaurav Arya <gauravarya272@gmail.com>
Date: Wed, 19 Jul 2023 22:31:30 -0400
Subject: [PATCH 5/9] Remove unnecessary def

---
 docs/src/implementations.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs/src/implementations.md b/docs/src/implementations.md
index efa3be4..5d82e00 100644
--- a/docs/src/implementations.md
+++ b/docs/src/implementations.md
@@ -34,8 +34,7 @@ To define a new FFT implementation in your own module, you should
 
 * To support adjoints in a new plan, define the trait [`AbstractFFTs.AdjointStyle`](@ref).
   `AbstractFFTs` implements the following adjoint styles: [`AbstractFFTs.FFTAdjointStyle`](@ref), [`AbstractFFTs.RFFTAdjointStyle`](@ref), [`AbstractFFTs.IRFFTAdjointStyle`](@ref), and [`AbstractFFTs.UnitaryAdjointStyle`](@ref).
-  To define a new adjoint style of type `AS <: AbstractFFTs.AdjointStyle`, define the methods
-  [`AbstractFFTs.adjoint_mul`](@ref) and [`AbstractFFTs.output_size`](@ref).
+  To define a new adjoint style, define the methods [`AbstractFFTs.adjoint_mul`](@ref) and [`AbstractFFTs.output_size`](@ref).
 
 The normalization convention for your FFT should be that it computes ``y_k = \sum_j x_j \exp(-2\pi i j k/n)`` for a transform of
 length ``n``, and the "backwards" (unnormalized inverse) transform computes the same thing but with ``\exp(+2\pi i jk/n)``.

From 9b724ed3050d920554ff3836e304c25cfc821c90 Mon Sep 17 00:00:00 2001
From: Gaurav Arya <gauravarya272@gmail.com>
Date: Thu, 20 Jul 2023 12:57:22 -0400
Subject: [PATCH 6/9] Remove confusing commas

---
 src/definitions.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/definitions.jl b/src/definitions.jl
index b642ac5..7dfb184 100644
--- a/src/definitions.jl
+++ b/src/definitions.jl
@@ -607,7 +607,7 @@ struct FFTAdjointStyle <: AdjointStyle end
     RFFTAdjointStyle()
 
 Adjoint style for real to complex discrete Fourier transforms that halve one of
-the output's dimensions and normalize the output, analogously to [`rfft`](@ref).
+the output's dimensions and normalize the output analogously to [`rfft`](@ref).
     
 Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
 inverse, but with additional logic to handle the fact that the output is projected 
@@ -619,7 +619,7 @@ struct RFFTAdjointStyle <: AdjointStyle end
     IRFFTAdjointStyle(d::Dim)
 
 Adjoint style for complex to real discrete Fourier transforms that expect an input
-with a halved dimension and normalize the output, analogously to [`irfft`](@ref),
+with a halved dimension and normalize the output analogously to [`irfft`](@ref),
 where `d` is the original length of the dimension.
     
 Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 

From d5d7ce2a4140448dfc9818b29a14f4f9e9a5e5f7 Mon Sep 17 00:00:00 2001
From: Gaurav Arya <gauravarya272@gmail.com>
Date: Thu, 20 Jul 2023 13:00:01 -0400
Subject: [PATCH 7/9] Tweak docstring wording

---
 src/definitions.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/definitions.jl b/src/definitions.jl
index 7dfb184..b90eff0 100644
--- a/src/definitions.jl
+++ b/src/definitions.jl
@@ -610,8 +610,8 @@ Adjoint style for real to complex discrete Fourier transforms that halve one of
 the output's dimensions and normalize the output analogously to [`rfft`](@ref).
     
 Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
-inverse, but with additional logic to handle the fact that the output is projected 
-to exploit its conjugate symmetry (see [`rfft`](@ref)). 
+inverse, but with appropriate scaling and additional logic to handle the fact that the
+output is projected to exploit its conjugate symmetry (see [`rfft`](@ref)).
 """
 struct RFFTAdjointStyle <: AdjointStyle end 
 
@@ -623,8 +623,8 @@ with a halved dimension and normalize the output analogously to [`irfft`](@ref),
 where `d` is the original length of the dimension.
     
 Since the Fourier transform is unitary up to a scaling, the adjoint applies the transform's 
-inverse, but with additional logic to handle the fact that the input is projected 
-to exploit its conjugate symmetry (see [`irfft`](@ref)). 
+inverse, but with appropriate scaling and additional logic to handle the fact that the
+input is projected to exploit its conjugate symmetry (see [`irfft`](@ref)). 
 """
 struct IRFFTAdjointStyle <: AdjointStyle
     dim::Int

From eddf7e3a428ab95efa5cee47b1974481eea7a4e2 Mon Sep 17 00:00:00 2001
From: Gaurav Arya <gauravarya272@gmail.com>
Date: Thu, 20 Jul 2023 22:03:54 -0400
Subject: [PATCH 8/9] Reposition and improve size/output_size docstrings

---
 src/definitions.jl | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/definitions.jl b/src/definitions.jl
index b90eff0..2ac28b7 100644
--- a/src/definitions.jl
+++ b/src/definitions.jl
@@ -10,9 +10,12 @@ abstract type Plan{T} end
 
 eltype(::Type{<:Plan{T}}) where {T} = T
 
-# size(p) should return the size of the input array for p
-size(p::Plan, d) = size(p)[d]
-output_size(p::Plan, d) = output_size(p)[d]
+"""
+    size(p::Plan, [dim])
+
+Return the size of the input of a plan `p`, optionally at a specified dimenion `dim`.
+"""
+size(p::Plan, dim) = size(p)[dim]
 ndims(p::Plan) = length(size(p))
 length(p::Plan) = prod(size(p))::Int
 
@@ -638,13 +641,14 @@ Adjoint style for unitary transforms, whose adjoint equals their inverse.
 struct UnitaryAdjointStyle <: AdjointStyle end
 
 """
-    output_size(p::Plan)
+    output_size(p::Plan, [dim])
 
-Return the size of the output of a plan `p`.
+Return the size of the output of a plan `p`, optionally at a specified dimension `dim`.
 
 Implementations of a new adjoint style `AS <: AbstractFFTs.AdjointStyle` should define `output_size(::Plan, ::AS)`.
 """
 output_size(p::Plan) = output_size(p, AdjointStyle(p))
+output_size(p::Plan, dim) = output_size(p)[dim]
 output_size(p::Plan, ::FFTAdjointStyle) = size(p)
 output_size(p::Plan, ::RFFTAdjointStyle) = rfft_output_size(size(p), fftdims(p))
 output_size(p::Plan, s::IRFFTAdjointStyle) = brfft_output_size(size(p), s.dim, fftdims(p))
@@ -670,11 +674,6 @@ Base.adjoint(p::AdjointPlan) = p.p
 # always have AdjointPlan inside ScaledPlan.
 Base.adjoint(p::ScaledPlan) = ScaledPlan(p.p', p.scale)
 
-"""
-    size(p::Plan)
-
-Return the size of the input of a plan `p`.
-"""
 size(p::AdjointPlan) = output_size(p.p)
 output_size(p::AdjointPlan) = size(p.p)
 

From bc6bee80f1b4c19d65ad0cbaa1b045761a70eb05 Mon Sep 17 00:00:00 2001
From: Gaurav Arya <gauravarya272@gmail.com>
Date: Thu, 20 Jul 2023 22:06:11 -0400
Subject: [PATCH 9/9] Note that size needs to be implemented in docs

---
 docs/src/implementations.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/src/implementations.md b/docs/src/implementations.md
index 5d82e00..b7e6751 100644
--- a/docs/src/implementations.md
+++ b/docs/src/implementations.md
@@ -18,7 +18,8 @@ To define a new FFT implementation in your own module, you should
   inverse plan.
 
 * Define a new method `AbstractFFTs.plan_fft(x, region; kws...)` that returns a `MyPlan` for at least some types of
-  `x` and some set of dimensions `region`.   The `region` (or a copy thereof) should be accessible via `fftdims(p::MyPlan)` (which defaults to `p.region`).
+  `x` and some set of dimensions `region`.   The `region` (or a copy thereof) should be accessible via `fftdims(p::MyPlan)`
+   (which defaults to `p.region`), and the input size `size(x)` should be accessible via `size(p::MyPlan)`.
 
 * Define a method of `LinearAlgebra.mul!(y, p::MyPlan, x)` that computes the transform `p` of `x` and stores the result in `y`.