added booleans the the two types FourierJoin and FourierSplit

Author: RainerHeintzmann

src/custom_fourier_types.jl

@@ -1,20 +1,22 @@
 ##  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
-    function FourierSplit(parent::AA, D::Int,L1::Int,L2::Int) where {T,N, AA<:AbstractArray{T, N}}
-        return new{T,N, AA}(parent, D, L1, 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
-    function FourierSplit(parent::AA, D::Int,L1::Int) where {T,N, AA<:AbstractArray{T, N}}
+    function FourierSplit(parent::AA, D::Int,L1::Int, do_split::Bool) where {T,N, AA<:AbstractArray{T, N}}
         mid = fft_center(size(parent)[D])
         L2 = mid + (mid-L1)
-        return FourierSplit(parent, D,L1,L2)
+        return FourierSplit(parent, D,L1,L2, do_split)
     end
 end
 
@@ -25,7 +27,7 @@ Base.parent(A::FourierSplit) = A.parent
 Base.size(A::FourierSplit) = size(parent(A))
 
 @inline function Base.getindex(A::FourierSplit{T,N, <:AbstractArray{T, N}}, i::Vararg{Int,N}) where {T,N}
-    if i[A.D]==A.L2 || i[A.D]==A.L1 # index along this dimension A.D corrsponds to slice L2
+    if (i[A.D]==A.L2 || i[A.D]==A.L1) && A.do_split # index along this dimension A.D corrsponds to slice L2
         # not that "setindex" in the line below modifies only the index, not the array
         @inbounds return parent(A)[Base.setindex(i,A.L1, A.D)...] / 2
     else i[A.D]==A.L2
@@ -36,22 +38,24 @@ 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
 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
-    function FourierJoin(parent::AA, D::Int, L1::Int, L2::Int) where {T, N, AA<:AbstractArray{T, N}}
-        return new{T, N, AA}(parent, D, L1, 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
 
-    function FourierJoin(parent::AA, D::Int,L1::Int) where {T, N, AA<:AbstractArray{T, N}}
+    function FourierJoin(parent::AA, D::Int,L1::Int, do_join::Bool) where {T, N, AA<:AbstractArray{T, N}}
         mid = fft_center(size(parent)[D])
         L2 = mid + (mid-L1)
-        return FourierJoin(parent, D, L1, L2)
+        return FourierJoin(parent, D, L1, L2, do_join)
     end
 end
 Base.IndexStyle(::Type{FS}) where {FS<:FourierJoin} = IndexStyle(parenttype(FS))
@@ -61,7 +65,7 @@ Base.parent(A::FourierJoin) = A.parent
 Base.size(A::FourierJoin) = size(parent(A))
 
 @inline function Base.getindex(A::FourierJoin{T,N, <:AbstractArray{T, N}}, i::Vararg{Int,N}) where {T,N}
-    if i[A.D]==A.L1
+    if i[A.D]==A.L1 && A.do_join
         @inbounds return (parent(A)[i...] + parent(A)[Base.setindex(i, A.L2, A.D)...])
     else 
         @inbounds return (parent(A)[i...])

src/fourier_resizing.jl

@@ -142,10 +142,9 @@ function ft_fix_before(mat, size_old, size_new; start_dim=1)
     for d = start_dim:ndims(mat)
         sn = size_new[d]
         so = size_old[d]
-        if sn < so && iseven(sn)
-            L1 = (size_old[d] -size_new[d] )÷2 +1
-            mat = FourierJoin(mat, d, L1)
-        end
+        do_join = (sn < so && iseven(sn))
+        L1 = (size_old[d] -size_new[d] )÷2 +1
+        mat = FourierJoin(mat, d, L1, do_join)
     end
     return mat
 end
@@ -156,32 +155,29 @@ function ft_fix_after(mat,size_old,size_new; start_dim=1)
     for d=start_dim:ndims(mat)
         sn = size_new[d]
         so = size_old[d]
-        if sn > so && iseven(so)
-            L1 = (size_new[d]-size_old[d])÷2+1
-            mat = FourierSplit(mat,d,L1)
-        end
         # if equal do nothing
+        do_split = (sn > so && iseven(so))
+        L1 = (size_new[d]-size_old[d])÷2+1
+        mat = FourierSplit(mat,d,L1, do_split)
     end
     return mat
 end
 
 function rft_fix_first_dim_before(mat,size_old,size_new;dim=1)
     sn = size_new[dim] # Note that this dim is the corresponding real-space size
     so = size_old[dim] # Note that this dim is the corresponding real-space size
-    if sn < so && iseven(sn) # result size is even upon cropping
-        L1 = size_new[dim] ÷ 2 + 1
-        mat = FourierJoin(mat, dim, L1, L1) # a hack to dublicate the value
-    end
+    do_join = (sn < so && iseven(sn)) # result size is even upon cropping
+    L1 = size_new[dim] ÷ 2 + 1
+    mat = FourierJoin(mat, dim, L1, L1, do_join) # a hack to dublicate the value
     return mat
 end
 
 function rft_fix_first_dim_after(mat,size_old,size_new;dim=1)
     sn = size_new[dim] # Note that this dim is the corresponding real-space size
     so = size_old[dim] # Note that this dim is the corresponding real-space size
-    if sn > so && iseven(so) # source size is even upon padding
-        L1 = size_old[dim] ÷ 2 + 1
-        mat = FourierSplit(mat,dim,L1,-1) # This hack prevents a second position to be affected
-    end
+    do_split = (sn > so && iseven(so)) # source size is even upon padding
+    L1 = size_old[dim] ÷ 2 + 1
+    mat = FourierSplit(mat,dim,L1,-1, do_split) # This hack prevents a second position to be affected
     # if equal do nothing
     return mat
 end

test/custom_fourier_types.jl

@@ -2,10 +2,10 @@
 @testset "Custom Fourier Types" begin
     N = 5
     x = randn((N, N))
-    fs = FourierTools.FourierSplit(x, 2, 2, 4)
+    fs = FourierTools.FourierSplit(x, 2, 2, 4, true)
     @test FourierTools.parenttype(fs) == typeof(x)
 
-    fj = FourierTools.FourierJoin(x, 2, 2, 4)
+    fj = FourierTools.FourierJoin(x, 2, 2, 4, true)
 
     @test FourierTools.parenttype(fj) == typeof(x)
     @test FourierTools.parenttype(typeof(fj)) == typeof(x)