beautification and added tests

Author: RainerHeintzmann

src/convolutions.jl

@@ -3,7 +3,7 @@ export plan_conv_buffer, plan_conv_psf_buffer
 
 
 """
-    conv(u, v[, dims])
+conv(u, v[, dims])
 
 Convolve `u` with `v` over `dims` dimensions with an FFT based method.
 Note, that this method introduces wrap-around artifacts without
@@ -66,7 +66,7 @@ function conv(u::AbstractArray{<:Real, N}, v::AbstractArray{<:Real, M}, dims=ntu
 end
 
 """
-    conv_psf(u, psf[, dims])
+conv_psf(u, psf[, dims])
 
 `conv_psf` is a shorthand for `conv(u,ifftshift(psf))`. For examples see `conv`.
 """
@@ -89,7 +89,7 @@ end
 
 
 """
-    plan_conv(u, v [, dims]; kwargs...)
+plan_conv(u, v [, dims]; kwargs...)
 
 Pre-plan an optimized convolution for arrays shaped like `u` and `v` (based on pre-plan FFT)
 along the given dimenions `dims`.
@@ -157,7 +157,7 @@ function plan_conv(u::AbstractArray{T1, N}, v::AbstractArray{T2, M}, dims=ntuple
 end
 
 """
-    plan_conv_buffer(u, v [, dims]; kwargs...)
+plan_conv_buffer(u, v [, dims]; kwargs...)
 
 Similar to [`plan_conv`](@ref) but instead uses buffers to prevent memory allocations.
 Not AD friendly!
@@ -194,7 +194,7 @@ function plan_conv_buffer(u::AbstractArray{T1, N}, v::AbstractArray{T2, M}, dims
 end
 
 """
-    plan_conv_psf_buffer(u, psf [, dims]; kwargs...) where {T, N}
+plan_conv_psf_buffer(u, psf [, dims]; kwargs...) where {T, N}
 
 `plan_conv_psf_buffer` is a shorthand for `plan_conv_buffer(u, ifftshift(psf))`. For examples see `plan_conv`.
 """
@@ -230,7 +230,7 @@ function ChainRulesCore.rrule(::typeof(p_conv_aux), P, P_inv, u, v)
 end
 
 """
-    fft_or_rfft(T)
+fft_or_rfft(T)
 
 Small helper function to decide whether a real
 or a complex valued FFT is appropriate.

src/correlations.jl

@@ -1,8 +1,7 @@
 export ccorr
 
-
 """
-    ccorr(u, v[, dims]; centered=false)
+ccorr(u, v[, dims]; centered=false)
 
 Calculates the cross-correlation between `u` and `v` along `dims`.
 `centered=true` moves the output of the cross-correlation to the Fourier center.
@@ -13,7 +12,6 @@ If either `u` or `v` is complex we use `fft` and output is hence complex.
 
 Per default the correlation is performed along `min(ndims(u), ndims(v))`.
 
-
 ```jldoctest
 julia> ccorr([1,1,0,0], [1,1,0,0], centered=true)
 4-element Vector{Float64}:

src/custom_fourier_types.jl

@@ -1,15 +1,24 @@
-##  This View checks for the index to be L1 or the mirrored version (L2)
-# and then replaces the value by half of the parent at L1
-# do_split is a Bool that indicates whether this mechanism is active. It is needed for type stability reasons of functions returnting this type
+"""
+FourierSplit{T,N, AA<:AbstractArray{T, N}} <: AbstractArray{T,N}
+
+This View checks for the index to be L1 or the mirrored version (L2)
+and then replaces the value by half of the parent at L1
+`do_split` is a Bool that indicates whether this mechanism is active. 
+It is needed for type stability reasons of functions returnting this type.
+"""
 struct FourierSplit{T,N, AA<:AbstractArray{T, N}} <: AbstractArray{T,N}
     parent::AA # holds the data (or is another view)
     D::Int # dimension along which to apply to copy
     L1::Int # low index position to copy from (and half)
     L2::Int # high index positon to copy to (and half)
     do_split::Bool
 
-    # This version below is needed to avoid a split for the firs rft dimension but still return half the value
-    # FFTs and other RFT dimension should use the version without L2
+"""
+    FourierSplit(parent::AA, D::Int,L1::Int,L2::Int, do_split::Bool) where {T,N, AA<:AbstractArray{T, N}}
+
+This version below is needed to avoid a split for the first rft dimension,
+but still return half the value FFTs and other RFT dimension should use the version without L2.
+"""
     function FourierSplit(parent::AA, D::Int,L1::Int,L2::Int, do_split::Bool) where {T,N, AA<:AbstractArray{T, N}}
         return new{T,N, AA}(parent, D, L1, L2, do_split)
     end
@@ -36,18 +45,26 @@ Base.size(A::FourierSplit) = size(parent(A))
     end
 end
 
-## This View checks for the index to be L1 
-# and then replaces the value by add the value at the mirrored position L2
-# do_join is a Bool that indicates whether this mechanism is active. It is needed for type stability reasons of functions returnting this type
+"""
+FourierJoin{T,N, AA<:AbstractArray{T, N}} <: AbstractArray{T, N}
+
+This View checks for the index to be L1 
+and then replaces the value by add the value at the mirrored position L2
+`do_join` is a Bool that indicates whether this mechanism is active. 
+It is needed for type stability reasons of functions returnting this type
+"""
 struct FourierJoin{T,N, AA<:AbstractArray{T, N}} <: AbstractArray{T, N}
     parent::AA
     D::Int # dimension along which to apply to copy
     L1::Int # low index position to copy from (and half)
     L2::Int # high index positon to copy to (and half)
     do_join::Bool
 
-    # This version below is needed to avoid a split for the firs rft dimension but still return half the value
-    # FFTs and other RFT dimension should use the version without L2
+"""
+This version below is needed to avoid a split for the 
+first rft dimension but still return half the value
+FFTs and other RFT dimension should use the version without L2
+"""
     function FourierJoin(parent::AA, D::Int, L1::Int, L2::Int, do_join::Bool) where {T, N, AA<:AbstractArray{T, N}}
         return new{T, N, AA}(parent, D, L1, L2, do_join)
     end
@@ -58,6 +75,7 @@ struct FourierJoin{T,N, AA<:AbstractArray{T, N}} <: AbstractArray{T, N}
         return FourierJoin(parent, D, L1, L2, do_join)
     end
 end
+
 Base.IndexStyle(::Type{FS}) where {FS<:FourierJoin} = IndexStyle(parenttype(FS))
 parenttype(::Type{FourierJoin{T,N,AA}}) where {T,N,AA} = AA
 parenttype(A::FourierJoin) = parenttype(typeof(A))

src/czt.jl

@@ -1,7 +1,7 @@
 export czt, iczt
 
 """
-    czt_1d(xin , scaled , d)
+czt_1d(xin , scaled , d)
 
 Chirp z transform along a single direction d of an ND array `xin` into the ND array 'xout'.
 Note that xin and xout can be the same array for inplace operations.
@@ -77,7 +77,8 @@ function czt_1d(xin, scaled, d)
 end
 
 """
-    czt(xin , scale, dims=1:length(size(xin)))
+czt(xin , scale, dims=1:length(size(xin)))
+
 Chirp z transform of the ND array `xin`
 This code is based on a 2D Matlab version of the CZT, written by H. Gross.
 The tuple `scale` defines the zoom factors in the Fourier domain. Each has to be bigger than one.
@@ -135,7 +136,8 @@ function czt(xin::Array{T,N}, scale, dims=1:length(size(xin)))::Array{complex(T)
 end
 
 """
-    iczt(xin , scale, dims=1:length(size(xin)))
+iczt(xin , scale, dims=1:length(size(xin)))
+
 Inverse chirp z transform of the ND array `xin`
 This code is based on a 2D Matlab version of the CZT, written by H. Gross.
 The tuple `scale` defines the zoom factors in the Fourier domain. Each has to be bigger than one.

src/damping.jl

@@ -2,7 +2,7 @@ using IndexFunArrays, LinearAlgebra, NDTools
 export damp_edge_outside
 
 """
-    damp_edge_outside(img::AbstractArray{T,N}, border, mykernel, usepixels)
+damp_edge_outside(img::AbstractArray{T,N}, border, mykernel, usepixels)
     
 Extrapolates the data by filling in blurred information outside the edges. This is a bit like DampEdge but using a normalized convolution with a kernel
 

src/fft_helpers.jl

@@ -5,7 +5,7 @@ export ft2d,ift2d, rft2d, irft2d
 export ffts2d, ffts2d!, iffts2d, rffts2d, irffts2d
 
 """
-    optional_collect(a)
+optional_collect(a)
 
 Only collects certain arrays, for a pure `Array` there is no collect
 and it returns simply `a`.
@@ -27,7 +27,7 @@ end
 
 
 """
-    ffts(A [, dims])
+ffts(A [, dims])
 
 Result is semantically equivalent to `fftshift(fft(A, dims), dims)`
 However, the shift is done with `ShiftedArrays` and therefore doesn't allocate memory.
@@ -41,7 +41,7 @@ end
 
 
 """
-    ffts!(A [, dims])
+ffts!(A [, dims])
 
 Result is semantically equivalent to `fftshift(fft!(A, dims), dims)`.
 `A` is in-place modified.
@@ -55,7 +55,7 @@ function ffts!(mat::AbstractArray{T, N}, dims=ntuple(identity, Val(N))) where {T
 end
 
 """
-    iffts(A [, dims])
+iffts(A [, dims])
 
 Result is semantically equivalent to `ifft(ifftshift(A, dims), dims)`.
 `A` is in-place modified.
@@ -70,7 +70,7 @@ end
 
 
 """
-    rffts(A [, dims])
+rffts(A [, dims])
 
 Calculates a `rfft(A, dims)` and then shift the frequencies to the center.
 `dims[1]` is not shifted, because there is no negative and positive frequency.
@@ -84,7 +84,7 @@ function rffts(mat::AbstractArray{T, N}, dims=ntuple(identity, Val(N))) where {T
 end
 
 """
-    irffts(A, d, [, dims])
+irffts(A, d, [, dims])
 
 Calculates a `irfft(A, d, dims)` and then shift the frequencies back to the corner.
 `dims[1]` is not shifted, because there is no negative and positive frequency.
@@ -100,7 +100,7 @@ end
 
 
 """
-    ft(A [, dims])
+ft(A [, dims])
 
 Digital Fourier-transformation centered in both spaces.
 The result is semantically equivalent to `fftshift(fft(ifftshift(A, dims), dims), dims)`
@@ -129,7 +129,7 @@ end
 
 
 """
-    ift(A [, dims])
+ift(A [, dims])
 
 Digital inverse Fourier-transformation centered in both spaces.
 The result is semantically equivalent to `fftshift(ifft(ifftshift(A, dims), dims), dims)`
@@ -160,7 +160,7 @@ end
 
 
 """
-    rft(A [, dims])
+rft(A [, dims])
 
 Digital real-valued Fourier-transformation centered in both spaces.
 The result is semantically equivalent to `fftshift(rfft(ifftshift(A, dims), dims), dims)`
@@ -185,7 +185,7 @@ function rft(mat::AbstractArray{T, N}, dims=ntuple(identity, Val(N))) where {T,
 end
 
 """
-    irft(A, d, [, dims])
+irft(A, d, [, dims])
 
 Digital real-valued inverse Fourier-transformation centered in both spaces.
 The result is semantically equivalent to `fftshift(irfft(ifftshift(A, dims), dims), dims)`
@@ -212,23 +212,23 @@ end
 
 ## Short-hand versions of the ft functions
 """
-    ft2d(mat::AbstractArray{T, N}) where {T, N}
+ft2d(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
 function ft2d(mat::AbstractArray{T, N}) where {T, N}
     ft(mat,(1,2))
 end
 """
-    ift2d(mat::AbstractArray{T, N}) where {T, N}
+ift2d(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
 function ift2d(mat::AbstractArray{T, N}) where {T, N}
     ift(mat,(1,2))
 end
 """
-    rft2d(mat::AbstractArray{T, N}) where {T, N}
+rft2d(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
@@ -237,7 +237,7 @@ function rft2d(mat::AbstractArray{T, N}) where {T, N}
 end
 
 """
-    irft2d(mat::AbstractArray{T, N}, d) where {T, N}
+irft2d(mat::AbstractArray{T, N}, d) where {T, N}
 
 Only over `dims=(1,2)`.
 """
@@ -246,7 +246,7 @@ function irft2d(mat::AbstractArray{T, N}, d::Int) where {T, N}
 end
 
 """
-    ft2d(mat::AbstractArray{T, N}) where {T, N}
+ft2d(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
@@ -255,7 +255,7 @@ function ffts2d(mat::AbstractArray{T, N}) where {T, N}
 end
 
 """
-    fft2ds!(mat::AbstractArray{T, N}) where {T, N}
+fft2ds!(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
@@ -265,7 +265,7 @@ end
 
 
 """
-    iffts2d(mat::AbstractArray{T, N}) where {T, N}
+iffts2d(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
@@ -282,7 +282,7 @@ function rffts2d(mat::AbstractArray{T, N}) where {T, N}
 end
 
 """
-    riffts2d(mat::AbstractArray{T, N}, d) where {T, N}
+riffts2d(mat::AbstractArray{T, N}, d) where {T, N}
 
 Only over `dims=(1,2)`.
 """
@@ -293,15 +293,15 @@ end
 
 ## Short-hand versions of the fft functions
 """
-    fft2d(mat::AbstractArray{T, N}) where {T, N}
+fft2d(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
 function fft2d(mat::AbstractArray{T, N}) where {T, N}
     fft(mat,(1,2))
 end
 """
-    ifft2d(mat::AbstractArray{T, N}) where {T, N}
+ifft2d(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
@@ -310,7 +310,7 @@ function ifft2d(mat::AbstractArray{T, N}) where {T, N}
 end
 
 """
-    rfft2d(mat::AbstractArray{T, N}) where {T, N}
+rfft2d(mat::AbstractArray{T, N}) where {T, N}
 
 Only over `dims=(1,2)`.
 """
@@ -319,7 +319,7 @@ function rfft2d(mat::AbstractArray{T, N}) where {T, N}
 end
 
 """
-    irfft2d(mat::AbstractArray{T, N}, d) where {T, N}
+irfft2d(mat::AbstractArray{T, N}, d) where {T, N}
 
 Only over `dims=(1,2)`.
 """