zero for safety

Author: vpuri3

src/basic.jl

@@ -376,7 +376,7 @@ getindex(L::AddedOperator, i::Int) = sum(op -> op[i], L.ops)
 getindex(L::AddedOperator, I::Vararg{Int, N}) where {N} = sum(op -> op[I...], L.ops)
 
 function Base.:*(L::AddedOperator, u::AbstractVecOrMat)
-    sum(op -> iszero(op) ? similar(u, Bool) * false : op * u, L.ops)
+    sum(op -> iszero(op) ? zero(u) : op * u, L.ops)
 end
 
 function LinearAlgebra.mul!(v::AbstractVecOrMat, L::AddedOperator, u::AbstractVecOrMat)
@@ -522,7 +522,7 @@ Base.:*(L::ComposedOperator, u::AbstractVecOrMat) = foldl((acc, op) -> op * acc,
 Base.:\(L::ComposedOperator, u::AbstractVecOrMat) = foldl((acc, op) -> op \ acc, L.ops; init=u)
 
 function cache_self(L::ComposedOperator, u::AbstractVecOrMat)
-    vec = similar(u)
+    vec = zero(u)
     cache = (vec,)
     for i in reverse(2:length(L.ops))
         vec   = L.ops[i] * vec
@@ -641,7 +641,7 @@ Base.:*(L::InvertedOperator, u::AbstractVecOrMat) = L.L \ u
 Base.:\(L::InvertedOperator, u::AbstractVecOrMat) = L.L * u
 
 function cache_self(L::InvertedOperator, u::AbstractVecOrMat)
-    cache = similar(u)
+    cache = zero(u)
     @set! L.cache = cache
     L
 end

src/func.jl

@@ -126,8 +126,8 @@ function FunctionOperator(op;
              )
 
     cache = (
-             similar(input_prototype),
-             similar(output_prototype),
+             zero(input_prototype),
+             zero(output_prototype),
             )
     isset = cache === nothing
 
@@ -265,13 +265,13 @@ Base.:\(L::FunctionOperator{false}, u::AbstractVecOrMat) = L.op_inverse(u, L.p,
 
 function Base.:*(L::FunctionOperator{true}, u::AbstractVecOrMat)
     _, co = L.cache
-    du = similar(co)
+    du = zero(co)
     L.op(du, u, L.p, L.t)
 end
 
 function Base.:\(L::FunctionOperator{true}, u::AbstractVecOrMat)
     ci, _ = L.cache
-    du = similar(ci)
+    du = zero(ci)
     L.op_inverse(du, u, L.p, L.t)
 end
 

src/tensor.jl

@@ -123,10 +123,10 @@ function cache_self(L::TensorProductOperator, u::AbstractVecOrMat)
     mo, no = size(L.outer)
     k = size(u, 2)
 
-    c1 = similar(u, (mi, no*k))  # c1 = L.inner * u
-    c2 = similar(u, (no, mi, k)) # permut (2, 1, 3)
-    c3 = similar(u, (mo, mi*k))  # c3 = L.outer * c2
-    c4 = similar(u, (mo*mi, k))  # cache v in 5 arg mul!
+    c1 = false * similar(u, (mi, no*k))  # c1 = L.inner * u
+    c2 = false * similar(u, (no, mi, k)) # permut (2, 1, 3)
+    c3 = false * similar(u, (mo, mi*k))  # c3 = L.outer * c2
+    c4 = false * similar(u, (mo*mi, k))  # cache v in 5 arg mul!
 
     @set! L.cache = (c1, c2, c3, c4,)
     L