done

Author: vpuri3

src/func.jl

@@ -91,7 +91,7 @@ function FunctionOperator(op,
                           isinplace::Union{Nothing,Bool}=nothing,
                           outofplace::Union{Nothing,Bool}=nothing,
                           has_mul5::Union{Nothing,Bool}=nothing,
-                          cache::Union{Nothing, Bool, NTuple{2}}=nothing,
+                          cache::Union{Nothing, NTuple{2}}=nothing,
                           T::Union{Type{<:Number},Nothing}=nothing,
 
                           op_adjoint=nothing,
@@ -113,8 +113,8 @@ function FunctionOperator(op,
                          )
 
     sz = (size(output, 1), size(input, 1))
-    T  = T isa Nothing ? promote_type(eltype.((input, output))...) : T
-    t  = t isa Nothing ? zero(real(T)) : t
+    T  = isnothing(T) ? promote_type(eltype.((input, output))...) : T
+    t  = isnothing(t) ? zero(real(T)) : t
 
     isinplace = if isnothing(isinplace)
         static_hasmethod(op, typeof((output, input, p, t)))
@@ -141,14 +141,6 @@ function FunctionOperator(op,
         has_mul5
     end
 
-    need_cache = if isnothing(cache)
-        true
-    elseif cache isa Bool
-        need_cache = cache
-        cache = nothing
-        need_cache
-    end
-
     if !isinplace & !outofplace
         @error "Please provide a funciton with signatures `op(u, p, t)` for applying
         the operator out-of-place, and/or the signature is `op(du, u, p, t)` for
@@ -181,7 +173,7 @@ function FunctionOperator(op,
               isinplace = isinplace,
               outofplace = outofplace,
               has_mul5 = has_mul5,
-              need_cache = need_cache,
+              ifcache = ifcache,
               T = T,
               size = sz,
              )
@@ -197,7 +189,11 @@ function FunctionOperator(op,
                          cache,
                         )
 
-    ifcache ? cache_operator(L, input, output) : L
+    if ifcache & isnothing(L.cache)
+        L = cache_operator(L, input, output)
+    end
+
+    L
 end
 
 function update_coefficients(L::FunctionOperator, u, p, t)
@@ -229,7 +225,13 @@ function update_coefficients!(L::FunctionOperator, u, p, t)
     nothing
 end
 
+function iscached(L::FunctionOperator)
+    L.traits.ifcache ? !isnothing(L.cache) : !L.traits.ifcache
+    !isnothing(L.cache)
+end
+
 function cache_self(L::FunctionOperator, u::AbstractVecOrMat, v::AbstractVecOrMat)
+    L.traits.ifcache && @warn "you are allocating cache for a FunctionOperator for which ifcache = false."
     @set! L.cache = zero.((u, v))
     L
 end
@@ -373,7 +375,7 @@ function LinearAlgebra.mul!(v::AbstractVecOrMat, L::FunctionOperator{false}, u::
     @error "LinearAlgebra.mul! not defined for out-of-place FunctionOperators"
 end
 
-function LinearAlgebra.mul!(v::AbstractVecOrMat, L::FunctionOperator{true}, u::AbstractVecOrMat, α, β)
+function LinearAlgebra.mul!(v::AbstractVecOrMat, L::FunctionOperator{true, oop, false}, u::AbstractVecOrMat, α, β) where{oop}
     _, co = L.cache
 
     copy!(co, v)
@@ -382,6 +384,10 @@ function LinearAlgebra.mul!(v::AbstractVecOrMat, L::FunctionOperator{true}, u::A
     axpy!(β, co, v)
 end
 
+function LinearAlgebra.mul!(v::AbstractVecOrMat, L::FunctionOperator{true, oop, true}, u::AbstractVecOrMat, α, β) where{oop}
+    L.op(v, u, L.p, L.t, α, β)
+end
+
 function LinearAlgebra.ldiv!(v::AbstractVecOrMat, L::FunctionOperator{true}, u::AbstractVecOrMat)
     L.op_inverse(v, u, L.p, L.t)
 end

src/interface.jl

@@ -39,7 +39,7 @@ getops(L) = ()
 function iscached(L::AbstractSciMLOperator)
 
     has_cache = hasfield(typeof(L), :cache) # TODO - confirm this is static
-    isset = has_cache ? L.cache !== nothing : true
+    isset = has_cache ? !isnothing(L.cache) : true
 
     return isset & all(iscached, getops(L)) 
 end

test/func.jl

@@ -17,12 +17,15 @@ K = 12
 
     A = rand(N,N) |> Symmetric
     F = lu(A)
+    Ai = inv(A)
 
     f1(u, p, t)  = A * u
     f1i(u, p, t) = A \ u
 
     f2(du, u, p, t)  = mul!(du, A, u)
+    f2(du, u, p, t, α, β)  = mul!(du, A, u, α, β)
     f2i(du, u, p, t) = ldiv!(du, F, u)
+    f2i(du, u, p, t, α, β) = mul!(du, Ai, u, α, β)
 
     # out of place
     op1 = FunctionOperator(f1, u, A*u;
@@ -51,6 +54,7 @@ K = 12
                            ishermitian=true,
                            isposdef=true,
                           )
+
     @test issquare(op1)
     @test issquare(op2)
 
@@ -76,6 +80,12 @@ K = 12
     @test !iscached(op1)
     @test !iscached(op2)
 
+    @test !op1.traits.has_mul5
+    @test op2.traits.has_mul5
+
+    # 5-arg mul! (w/o cache)
+    v = rand(N,K); w=copy(v); @test α*(A*u)+ β*w ≈ mul!(v, op2, u, α, β)
+
     op1 = cache_operator(op1, u, A * u)
     op2 = cache_operator(op2, u, A * u)