rm Base.* wrapper for non OOp FunctionOperator

Author: vpuri3

docs/src/tutorials/fftw.md

@@ -19,21 +19,22 @@ x  = range(start=-L/2, stop=L/2-dx, length=n) |> Array
 u  = @. sin(5x)cos(7x);
 du = @. 5cos(5x)cos(7x) - 7sin(5x)sin(7x);
 
-k  = rfftfreq(n, 2π*n/L) |> Array
-m  = length(k)
-transform = plan_rfft(x)
+k = rfftfreq(n, 2π*n/L) |> Array
+m = length(k)
+P = plan_rfft(x)
+
+F = FunctionOperator(fwd, x, im*k;
+        T=ComplexF64,
 
-T = FunctionOperator((du,u,p,t) -> mul!(du, transform, u), x, im*k;
-                     isinplace=true,
-                     T=ComplexF64,
+        op_adjoint = bwd,
+        op_inverse = bwd,
+        op_adjoint_inverse = fwd,
 
-                     op_adjoint = (du,u,p,t) -> ldiv!(du, transform, u),
-                     op_inverse = (du,u,p,t) -> ldiv!(du, transform, u),
-                     op_adjoint_inverse = (du,u,p,t) -> ldiv!(du, transform, u),
-                    )
+        islinear=true,
+        )
 
 ik = im * DiagonalOperator(k)
-Dx = T \ ik * T
+Dx = F \ ik * F
 
 Dx = cache_operator(Dx, x)
 
@@ -79,18 +80,17 @@ Now we are ready to define our wrapper for the FFT object. To `FunctionOperator`
 pass the in-place forward application of the transform,
 `(du,u,p,t) -> mul!(du, transform, u)`, its inverse application,
 `(du,u,p,t) -> ldiv!(du, transform, u)`, as well as input and output prototype vectors.
-We also set the flag `isinplace` to `true` to signal that we intend to use the operator
-in a non-allocating way, and pass in the element-type and size of the operator.
 
 ```
-T = FunctionOperator((du,u,p,t) -> mul!(du, transform, u), x, im*k;
-                     isinplace=true,
-                     T=ComplexF64,
-
-                     op_adjoint = (du,u,p,t) -> ldiv!(du, transform, u),
-                     op_inverse = (du,u,p,t) -> ldiv!(du, transform, u),
-                     op_adjoint_inverse = (du,u,p,t) -> ldiv!(du, transform, u),
-                    )
+F = FunctionOperator(fwd, x, im*k;
+        T=ComplexF64,
+
+        op_adjoint = bwd,
+        op_inverse = bwd,
+        op_adjoint_inverse = fwd,
+
+        islinear=true,
+        )
 ```
 
 After wrapping the FFT with `FunctionOperator`, we are ready to compose it with other
@@ -100,7 +100,7 @@ both in-place, and out-of-place by comparing its output to the analytical deriva
 
 ```
 ik = im * DiagonalOperator(k)
-Dx = T \ ik * T
+Dx = F \ ik * F
 
 @show ≈(Dx * u, du; atol=1e-8)
 @show ≈(mul!(copy(u), Dx, u), du; atol=1e-8)

test/total.jl

@@ -16,20 +16,25 @@ K = 12
     dx = L / n
     x  = -L/2:dx:L/2-dx |> Array
 
-    k  = rfftfreq(n, 2π*n/L) |> Array
-    m  = length(k)
-    tr = plan_rfft(x)
+    k = rfftfreq(n, 2π*n/L) |> Array
+    m = length(k)
+    P = plan_rfft(x)
 
-    ftr = FunctionOperator((du,u,p,t) -> mul!(du, tr, u), x, im*k;
-                           isinplace=true,
-                           T=ComplexF64,
+    fwd(u, p, t) = P * u
+    bwd(u, p, t) = P \ u
 
-                           op_adjoint = (du,u,p,t) -> ldiv!(du, tr, u),
-                           op_inverse = (du,u,p,t) -> ldiv!(du, tr, u),
-                           op_adjoint_inverse = (du,u,p,t) -> ldiv!(du, tr, u),
+    fwd(du, u, p, t) = mul!(du, P, u)
+    bwd(du, u, p, t) = ldiv!(du, P, u)
 
-                           islinear=true,
-                          )
+    ftr = FunctionOperator(fwd, x, im*k;
+        T=ComplexF64,
+
+        op_adjoint = bwd,
+        op_inverse = bwd,
+        op_adjoint_inverse = fwd,
+
+        islinear=true,
+    )
 
     @test size(ftr) == (length(k), length(x))