reintroduce the old interface but still allow to use the factory method

Author: tknopp

Project.toml

@@ -9,6 +9,7 @@ LinearOperators = "5c8ed15e-5a4c-59e4-a42b-c7e8811fb125"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 
 [weakdeps]
 Wavelets = "29a6e085-ba6d-5f35-a997-948ac2efa89a"
@@ -18,7 +19,7 @@ NFFT = "efe261a4-0d2b-5849-be55-fc731d526b0d"
 [extensions]
 LinearOperatorWaveletExt = "Wavelets"
 LinearOperatorFFTWExt = "FFTW"
-LinearOperatorNFFTExt = "NFFT"
+LinearOperatorNFFTExt = ["NFFT", "FFTW"]
 
 [compat]
 julia = "1.6"

ext/LinearOperatorFFTWExt/DCTOp.jl

@@ -1,10 +1,5 @@
 export DCTOpImpl
 
-function LinearOperatorCollection.constructLinearOperator(::Type{Op};
-  shape::Tuple, dcttype::Int) where Op <: DCTOp{T} where T <: Number
-  return DCTOpImpl(T, shape, dcttype)
-end
-
 mutable struct DCTOpImpl{T} <: DCTOp{T}
   nrow :: Int
   ncol :: Int
@@ -37,7 +32,7 @@ returns a `DCTOpImpl <: AbstractLinearOperator` which performs a DCT on a given
 * `shape::Tuple`  - size of the array to transform
 * `dcttype`       - type of DCT (currently `2` and `4` are supported)
 """
-function DCTOpImpl(T::Type, shape::Tuple, dcttype=2)
+function LinearOperatorCollection.DCTOp(T::Type; shape::Tuple, dcttype=2)
 
   tmp=Array{Complex{real(T)}}(undef, shape) 
   if dcttype == 2

ext/LinearOperatorFFTWExt/DSTOp.jl

@@ -1,10 +1,5 @@
 export DSTOpImpl
 
-function LinearOperatorCollection.constructLinearOperator(::Type{Op};
-  shape::Tuple, shift::Bool=true, unitary::Bool=true, cuda::Bool=false) where Op <: DSTOp{T} where T <: Number
-  return DSTOpImpl(T, shape)
-end
-
 mutable struct DSTOpImpl{T} <: DSTOp{T}
   nrow :: Int
   ncol :: Int
@@ -28,15 +23,15 @@ end
 LinearOperators.storage_type(op::DSTOpImpl) = typeof(op.Mv5)
 
 """
-  DSTOpImpl(T::Type, shape::Tuple)
+  DSTOp(T::Type, shape::Tuple)
 
 returns a `LinearOperator` which performs a DST on a given input array.
 
 # Arguments:
 * `T::Type`       - type of the array to transform
 * `shape::Tuple`  - size of the array to transform
 """
-function DSTOpImpl(T::Type, shape::Tuple)
+function LinearOperatorCollection.DSTOp(T::Type; shape::Tuple)
   tmp=Array{Complex{real(T)}}(undef, shape)
 
   plan = FFTW.plan_r2r!(tmp,FFTW.RODFT10)

ext/LinearOperatorFFTWExt/FFTOp.jl

@@ -1,11 +1,6 @@
 export FFTOpImpl
 import Base.copy
 
-function LinearOperatorCollection.constructLinearOperator(::Type{Op};
-  shape::Tuple, shift::Bool=true, unitary::Bool=true, cuda::Bool=false) where Op <: FFTOp{T} where T <: Number
-  return FFTOpImpl(T, shape, shift; unitary, cuda)
-end
-
 mutable struct FFTOpImpl{T} <: FFTOp{T}
   nrow :: Int
   ncol :: Int
@@ -31,7 +26,7 @@ end
 LinearOperators.storage_type(op::FFTOpImpl) = typeof(op.Mv5)
 
 """
-  FFTOpImpl(T::Type, shape::Tuple, shift=true, unitary=true)
+  FFTOp(T::Type; shape::Tuple, shift=true, unitary=true)
 
 returns an operator which performs an FFT on Arrays of type T
 
@@ -41,7 +36,7 @@ returns an operator which performs an FFT on Arrays of type T
 * (`shift=true`)  - if true, fftshifts are performed
 * (`unitary=true`)  - if true, FFT is normalized such that it is unitary
 """
-function FFTOpImpl(T::Type, shape::NTuple{D,Int64}, shift::Bool=true; unitary::Bool=true, cuda::Bool=false) where D
+function LinearOperatorCollection.FFTOp(T::Type; shape::NTuple{D,Int64}, shift::Bool=true, unitary::Bool=true, cuda::Bool=false) where D
 
   #tmpVec = cuda ? CuArray{T}(undef,shape) : Array{Complex{real(T)}}(undef, shape)
   tmpVec = Array{Complex{real(T)}}(undef, shape)

ext/LinearOperatorNFFTExt/LinearOperatorNFFTExt.jl

@@ -1,6 +1,6 @@
 module LinearOperatorNFFTExt
 
-using LinearOperatorCollection, NFFT
+using LinearOperatorCollection, NFFT, FFTW
 
 include("NFFTOp.jl")
 

ext/LinearOperatorNFFTExt/NFFTOp.jl

@@ -1,10 +1,13 @@
-export NFFTOpImpl
 import Base.adjoint
 
-function LinearOperatorCollection.constructLinearOperator(::Type{Op};
-    shape::Tuple, nodes::AbstractMatrix{T}, toeplitz=false, oversamplingFactor=1.25, 
-   kernelSize=3, kargs...) where Op <: NFFTOp{T} where T <: Number
-  return NFFTOpImpl(T, shape, nodes; toeplitz, oversamplingFactor, kernelSize, kargs... )
+function LinearOperatorCollection.createLinearOperator(::Type{Op}; kargs...) where Op <: NFFTOp{T} where T <: Number
+  return NFFTOp(T; kargs...)
+end
+
+function LinearOperatorCollection.NFFTOp(::Type{T};
+    shape::Tuple, nodes::AbstractMatrix{U}, toeplitz=false, oversamplingFactor=1.25, 
+   kernelSize=3, kargs...) where {U <: Number, T <: Number}
+  return NFFTOpImpl(shape, nodes; toeplitz, oversamplingFactor, kernelSize, kargs... )
 end
 
 mutable struct NFFTOpImpl{T} <: NFFTOp{T}
@@ -155,7 +158,7 @@ function LinearOperatorCollection.normalOperator(S::NFFTOpImpl{T}, W=opEye(T,siz
   if S.toeplitz
     return NFFTToeplitzNormalOp(S,W)
   else
-    return NormalOp(S,W)
+    return LinearOperatorCollection.NormalOpImpl(S,W)
   end
 end
 

ext/LinearOperatorWaveletExt/LinearOperatorWaveletExt.jl

@@ -1,5 +1,7 @@
 module LinearOperatorWaveletExt
-  
+
+using LinearOperatorCollection, Wavelets
+
 include("WaveletOp.jl")
 
 end

ext/LinearOperatorWaveletExt/WaveletOp.jl

@@ -1,11 +1,3 @@
-export WaveletOpImpl
-
-using LinearOperatorCollection, Wavelets
-
-function LinearOperatorCollection.constructLinearOperator(::Type{Op};
-       shape::Tuple, wt=wavelet(WT.db2)) where Op <: WaveletOp{T} where T <: Number
-  return WaveletOpImpl(T, shape, wt)
-end
 
 """
   WaveletOp(shape, wt=wavelet(WT.db2))
@@ -18,7 +10,7 @@ a given input array.
 * `shape`                 - size of the Array to transform
 * (`wt=wavelet(WT.db2)`)  - Wavelet to apply
 """
-function WaveletOpImpl(T::Type, shape, wt=wavelet(WT.db2))
+function LinearOperatorCollection.WaveletOp(::Type{T}; shape::Tuple, wt=wavelet(WT.db2)) where T <: Number
   return LinearOperator(T, prod(shape), prod(shape), false, false
             , (res,x)->dwt!(reshape(res,shape), reshape(x,shape), wt)
             , nothing

src/GradientOp.jl

@@ -1,5 +1,5 @@
-function LinearOperatorCollection.constructLinearOperator(::Type{Op};
-  shape::Tuple, dim::Union{Nothing,Int64}=nothing) where Op <: GradientOp{T} where T <: Number
+function LinearOperatorCollection.GradientOp(::Type{T};
+  shape::Tuple, dim::Union{Nothing,Int64}=nothing) where T <: Number
   if dim == nothing
     return GradientOpImpl(T, shape)
   else

src/LinearOperatorCollection.jl

@@ -6,6 +6,7 @@ import LinearAlgebra.BLAS: gemv, gemv!
 import LinearAlgebra: BlasFloat, normalize!, norm, rmul!, lmul!
 using SparseArrays
 using Random
+using InteractiveUtils
 
 using Reexport
 @reexport using Reexport
@@ -26,7 +27,7 @@ function wrapProd(prod::Function)
   return λ
 end
 
-export linearOperatorList, constructLinearOperator
+export linearOperatorList, createLinearOperator
 export AbstractLinearOperatorFromCollection, WaveletOp, FFTOp, DCTOp, DSTOp, NFFTOp,
        SamplingOp, NormalOp, WeightingOp, GradientOp
 
@@ -41,9 +42,6 @@ abstract type NormalOp{T} <: AbstractLinearOperatorFromCollection{T} end
 abstract type WeightingOp{T} <: AbstractLinearOperatorFromCollection{T} end
 abstract type GradientOp{T} <: AbstractLinearOperatorFromCollection{T} end
 
-function constructLinearOperator(::Type{<:AbstractLinearOperatorFromCollection}, args...; kargs...) 
-  error("Operator can't be constructed. You need to load another package!")
-end
 
 """
   returns a list of currently implemented `LinearOperator`s
@@ -52,6 +50,16 @@ function linearOperatorList()
   return subtypes(AbstractLinearOperatorFromCollection)
 end
 
+# Next we create the factory methods. We probably want to given
+# a better error message if the extension module is not loaded
+for op in linearOperatorList()
+  @eval begin
+    function createLinearOperator(::Type{ Op }; kargs...) where Op <: $op{T} where T <: Number
+      return $op(T; kargs...)
+    end
+  end
+end
+
 include("GradientOp.jl")
 include("SamplingOp.jl")
 include("WeightingOp.jl")