updates for latest FFTW.jl (#34)

Author: stevengj

Project.toml

@@ -1,6 +1,6 @@
 name = "Hadamard"
 uuid = "4a05ff16-5f95-55f4-bb53-bb3f467c689a"
-version = "1.6.0"
+version = "1.7.0"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -10,7 +10,7 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 [compat]
 julia = "1.6"
 AbstractFFTs = "0.4,0.5,1"
-FFTW = "1.6"
+FFTW = "1.9"
 LinearAlgebra = "<0.0.1, 1"
 
 [extras]

src/Hadamard.jl

@@ -17,8 +17,8 @@ module Hadamard
 export fwht, ifwht, fwht_natural, ifwht_natural, fwht_natural!, ifwht_natural!, fwht_dyadic, ifwht_dyadic, hadamard, walsh
 
 using FFTW, LinearAlgebra
-import FFTW: set_timelimit, dims_howmany, unsafe_execute!, cFFTWPlan, r2rFFTWPlan, PlanPtr, fftwNumber, ESTIMATE, NO_TIMELIMIT, R2HC
-import AbstractFFTs: normalization, complexfloat
+using FFTW: @exclusive, unsafe_set_timelimit, dims_howmany, unsafe_execute!, cFFTWPlan, r2rFFTWPlan, PlanPtr, fftwNumber, ESTIMATE, NO_TIMELIMIT, R2HC
+using AbstractFFTs: normalization, complexfloat
 
 # A power-of-two dimension to be transformed is interpreted as a
 # 2x2x2x....x2x2  multidimensional DFT.  This function transforms
@@ -62,19 +62,20 @@ const libfftwf = isdefined(FFTW, :libfftwf) ? FFTW.libfftwf : FFTW.libfftw3f
 
 for (Tr,Tc,fftw,lib) in ((:Float64,:ComplexF64,"fftw",libfftw),
                          (:Float32,:ComplexF32,"fftwf",libfftwf))
-    @eval function Plan_Hadamard(X::StridedArray{$Tc,N}, Y::StridedArray{$Tc,N},
+    @eval @exclusive function Plan_Hadamard(X::StridedArray{$Tc,N}, Y::StridedArray{$Tc,N},
                                  region, flags::Unsigned, timelimit::Real,
                                  bitreverse::Bool) where {N}
-        set_timelimit($Tr, timelimit)
-        dims, howmany = dims_howmany(X, Y, [size(X)...], region)
+        unsafe_set_timelimit($Tr, timelimit)
+        R = isa(region, Tuple) ? region : copy(region)
+        dims, howmany = dims_howmany(X, Y, size(X), R)
         dims = hadamardize(dims, bitreverse)
-        plan = ccall(($(string(fftw,"_plan_guru64_dft")),$lib[]),
+        plan = ccall(($(string(fftw,"_plan_guru64_dft")),$lib()),
                      PlanPtr,
                      (Int32, Ptr{Int}, Int32, Ptr{Int},
                       Ptr{$Tc}, Ptr{$Tc}, Int32, UInt32),
                      size(dims,2), dims, size(howmany,2), howmany,
                      X, Y, FFTW.FORWARD, flags)
-        set_timelimit($Tr, NO_TIMELIMIT)
+        unsafe_set_timelimit($Tr, NO_TIMELIMIT)
         if plan == C_NULL
             if $(FFTW.fftw_provider == "mkl")
                 error("MKL is not supported — reconfigure FFTW.jl to use FFTW")
@@ -85,21 +86,22 @@ for (Tr,Tc,fftw,lib) in ((:Float64,:ComplexF64,"fftw",libfftw),
         return cFFTWPlan{$Tc,FFTW.FORWARD,X===Y,N}(plan, flags, region, X, Y)
     end
 
-    @eval function Plan_Hadamard(X::StridedArray{$Tr,N}, Y::StridedArray{$Tr,N},
+    @eval @exclusive function Plan_Hadamard(X::StridedArray{$Tr,N}, Y::StridedArray{$Tr,N},
                                  region, flags::Unsigned, timelimit::Real,
                                  bitreverse::Bool) where {N}
-        set_timelimit($Tr, timelimit)
-        dims, howmany = dims_howmany(X, Y, [size(X)...], region)
+        unsafe_set_timelimit($Tr, timelimit)
+        R = isa(region, Tuple) ? region : copy(region)
+        dims, howmany = dims_howmany(X, Y, size(X), R)
         dims = hadamardize(dims, bitreverse)
         kind = Array{Int32}(undef, size(dims,2))
         kind .= R2HC
-        plan = ccall(($(string(fftw,"_plan_guru64_r2r")),$lib[]),
+        plan = ccall(($(string(fftw,"_plan_guru64_r2r")),$lib()),
                      PlanPtr,
                      (Int32, Ptr{Int}, Int32, Ptr{Int},
                       Ptr{$Tr}, Ptr{$Tr}, Ptr{Int32}, UInt32),
                      size(dims,2), dims, size(howmany,2), howmany,
                      X, Y, kind, flags)
-        set_timelimit($Tr, NO_TIMELIMIT)
+        unsafe_set_timelimit($Tr, NO_TIMELIMIT)
         if plan == C_NULL
             if $(FFTW.fftw_provider == "mkl")
                 error("MKL is not supported — reconfigure FFTW.jl to use FFTW")
@@ -371,7 +373,7 @@ end
 """
     walsh(n)
 
-Return a Walsh matrix of order `n`, which must be a power of two, in sequency ordering. 
+Return a Walsh matrix of order `n`, which must be a power of two, in sequency ordering.
 This is related to the Hadamard matrix [`hadamard(n)`](@ref) by a bit-reversal permutation
 followed by a Gray-code permutation of the rows.
 
@@ -390,7 +392,7 @@ function walsh(n::Int)
               j = b ⊻ (b >> 1) # binary sequency index
               j + 1 # 1-based index
           end
-          for i in 0:n-1 ] 
+          for i in 0:n-1 ]
 
     return hadamard(n)[j, :]
 end