More inferrability & performance work

Author: timholy

src/abstract.jl

@@ -128,9 +128,9 @@ function CompositeLinearOperator(
   prod!::F,
   tprod!::Ft,
   ctprod!::Fct,
-  args5::Bool;
-  S::Type = Vector{T},
-) where {I <: Integer, F, Ft, Fct}
+  args5::Bool,
+  ::Type{S},
+) where {S, I <: Integer, F, Ft, Fct}
   Mv5, Mtu5 = S(undef, 0), S(undef, 0)
   allocated5 = true
   use_prod5! = true
@@ -153,6 +153,20 @@ function CompositeLinearOperator(
   )
 end
 
+# backward compatibility (not inferrable)
+CompositeLinearOperator(
+  T::Type,
+  nrow::I,
+  ncol::I,
+  symmetric::Bool,
+  hermitian::Bool,
+  prod!::F,
+  tprod!::Ft,
+  ctprod!::Fct,
+  args5::Bool;
+  S::Type = Vector{T}) where {I <: Integer, F, Ft, Fct} =
+  CompositeLinearOperator(T, nrow, ncol, symmetric, hermitian, prod!, tprod!, ctprod!, args5, S)
+
 nprod(op::AbstractLinearOperator) = op.nprod
 ntprod(op::AbstractLinearOperator) = op.ntprod
 nctprod(op::AbstractLinearOperator) = op.nctprod

src/cat.jl

@@ -48,7 +48,7 @@ function hcat(A::AbstractLinearOperator, B::AbstractLinearOperator)
   S = promote_type(storage_type(A), storage_type(B))
   isconcretetype(S) ||
     throw(LinearOperatorException("storage types cannot be promoted to a concrete type"))
-  CompositeLinearOperator(T, nrow, ncol, false, false, prod!, tprod!, ctprod!, args5, S = S)
+  CompositeLinearOperator(T, nrow, ncol, false, false, prod!, tprod!, ctprod!, args5, S)
 end
 
 function hcat(ops::AbstractLinearOperator...)
@@ -107,7 +107,7 @@ function vcat(A::AbstractLinearOperator, B::AbstractLinearOperator)
   S = promote_type(storage_type(A), storage_type(B))
   isconcretetype(S) ||
     throw(LinearOperatorException("storage types cannot be promoted to a concrete type"))
-  CompositeLinearOperator(T, nrow, ncol, false, false, prod!, tprod!, ctprod!, args5, S = S)
+  CompositeLinearOperator(T, nrow, ncol, false, false, prod!, tprod!, ctprod!, args5, S)
 end
 
 function vcat(ops::AbstractLinearOperator...)

src/operations.jl

@@ -150,7 +150,7 @@ function *(op1::AbstractLinearOperator, op2::AbstractLinearOperator)
   tprod! = @closure (res, u, α, β) -> prod_op!(res, transpose(op2), transpose(op1), utmp, u, α, β)
   ctprod! = @closure (res, w, α, β) -> prod_op!(res, adjoint(op2), adjoint(op1), wtmp, w, α, β)
   args5 = (has_args5(op1) && has_args5(op2))
-  CompositeLinearOperator(T, m1, n2, false, false, prod!, tprod!, ctprod!, args5, S = S)
+  CompositeLinearOperator(T, m1, n2, false, false, prod!, tprod!, ctprod!, args5, S)
 end
 
 ## Matrix times operator.
@@ -213,7 +213,7 @@ function +(op1::AbstractLinearOperator, op2::AbstractLinearOperator)
   S = promote_type(storage_type(op1), storage_type(op2))
   isconcretetype(S) ||
     throw(LinearOperatorException("storage types cannot be promoted to a concrete type"))
-  return CompositeLinearOperator(T, m1, n1, symm, herm, prod!, tprod!, ctprod!, args5, S = S)
+  return CompositeLinearOperator(T, m1, n1, symm, herm, prod!, tprod!, ctprod!, args5, S)
 end
 
 # Operator + matrix.

src/special-operators.jl

@@ -165,7 +165,7 @@ function opDiagonal(nrow::I, ncol::I, d::AbstractVector{T}) where {T, I <: Integ
 end
 
 function mulRestrict!(res, I, v, α, β)
-  res .= v[I]
+  res .= view(v, I)
 end
 
 function multRestrict!(res, I, u, α, β)
@@ -291,5 +291,5 @@ function BlockDiagonalOperator(ops...; S = promote_type(storage_type.(ops)...))
   symm = all((issymmetric(op) for op ∈ ops))
   herm = all((ishermitian(op) for op ∈ ops))
   args5 = all((has_args5(op) for op ∈ ops))
-  CompositeLinearOperator(T, nrow, ncol, symm, herm, prod!, tprod!, ctprod!, args5, S = S)
+  CompositeLinearOperator(T, nrow, ncol, symm, herm, prod!, tprod!, ctprod!, args5, S)
 end