Provide `rfft!` and `irfft!` through a submodule

[favba]

Is it desirable to have a submodule living in FFTW.jl to provide the inplace real-to-complex and complex-to-real transformations?

The functionality is already coded in InpalceRealFFT.jl and could remain living as a separate package. Some people expressed the desire to have it in FFTW.jl
Basically, a PaddedArray type is created to deal with proper padding of the real data, and methods rfft!,irff!,brfft!,plan_rfft!,plan_irfft! and plan_brfft! are created to work with AbstractPaddedArrays, an interface to provide custom PaddedArray types.

I could make a PR if this is desirable.

[stevengj]

A PR would be good, but don't bother with a submodule. Just put it directly into the FFTW module (in a separate file via include) and export rfft! etcetera.

Maybe call the type PaddedRFFTArray to make it clear that the padding is specific to the semantics of FFTW's in-place r2c transforms.

[Marc-3d]

Hi,

I too ended up implementing my own in-place r2c/c2r (although more naively than favba's implementation). However, I realize now the importance of the thread-safety mechanism of the @exclusive macro in FFTW, and I started thinking about how to add rfft! capabilities to FFTW. I had a look at the PR and the discussion around this topic, and I have a suggestion.

IMO the simplest way to add r2c! and c2r! capabilities would be add two new signatures for rFFTWPlan with a single input array + an extra parameter about the intended size of the FFT. One could add an @assert or @warning statement to make the functions more user-friendly-ish.

@eval @exclusive function rFFTWPlan{$Tr,$FORWARD,true,N}( X::StridedArray{$Tr,N}, fftsize::Dims{N}, region, flags::Integer, timelimit::Real) where {N} 
    @assert size(X,1) == fftsize[1] + 2*iseven( fftsize[1] ) "Informative message about padding requirements for inplace rFFTs"
    @warn "make sure you know what you are doing"
    #= function body =# 
end

@eval @exclusive function rFFTWPlan{$Tr,$BACKWARD,true,N}( X::StridedArray{$Tr,N}, fftsize::Dims{N}, region, flags::Integer, timelimit::Real) where {N} 
    #= same considerations as for the $FORWARD version =# 
end

To exemplify why the "intended FFT size" parameter is needed, consider that the r2c! FFT of an 18x20 array requires a padded array of size 20x20. But so does the r2c! FFT of an array of size 19x20. With the above signatures, these two cases could be expressed as: X = rand( 20, 20 ); p1 = rFFTWPlan{eltype(X),FFTW.FORWARD( X, (18,20), ... ); p2 = rFFTWPlan{eltype(X),FFTW.FORWARD}( X, (19,20), ... )... for c2r!, simply replace FORWARD with BACKWARD.

While this isn't directly anrfft! implementation, it is enough for what I need. Namely, in-place r2c/c2r plan with built-in thread-safety. It might be necessary to add specialized "execute" implementations (unsafe_execute, assert_applicable, etc ) for in-place rFFTWPlans, I can't tell at the moment 🤔.

Let me know if you want me to give it a shot.