some more renaming and fix matrix tests

Author: ChrisRackauckas

src/matrix.jl

@@ -228,23 +228,23 @@ function Base.copy(L::MatrixOperator)
 end
 
 # operator application
-Base.:*(L::MatrixOperator, u::AbstractVecOrMat) = L.A * u
-Base.:\(L::MatrixOperator, u::AbstractVecOrMat) = L.A \ u
+Base.:*(L::MatrixOperator, v::AbstractVecOrMat) = L.A * v
+Base.:\(L::MatrixOperator, v::AbstractVecOrMat) = L.A \ v
 @inline function LinearAlgebra.mul!(
-        v::AbstractVecOrMat, L::MatrixOperator, u::AbstractVecOrMat)
-    mul!(v, L.A, u)
+        w::AbstractVecOrMat, L::MatrixOperator, v::AbstractVecOrMat)
+    mul!(w, L.A, v)
 end
-@inline function LinearAlgebra.mul!(v::AbstractVecOrMat,
+@inline function LinearAlgebra.mul!(w::AbstractVecOrMat,
         L::MatrixOperator,
-        u::AbstractVecOrMat,
+        v::AbstractVecOrMat,
         α,
         β)
-    mul!(v, L.A, u, α, β)
+    mul!(w, L.A, v, α, β)
 end
-function LinearAlgebra.ldiv!(v::AbstractVecOrMat, L::MatrixOperator, u::AbstractVecOrMat)
-    ldiv!(v, L.A, u)
+function LinearAlgebra.ldiv!(w::AbstractVecOrMat, L::MatrixOperator, v::AbstractVecOrMat)
+    ldiv!(w, L.A, v)
 end
-LinearAlgebra.ldiv!(L::MatrixOperator, u::AbstractVecOrMat) = ldiv!(L.A, u)
+LinearAlgebra.ldiv!(L::MatrixOperator, v::AbstractVecOrMat) = ldiv!(L.A, v)
 
 """
 $SIGNATURES
@@ -400,30 +400,30 @@ isconvertible(L::InvertibleOperator) = isconvertible(L.L)
 has_ldiv(L::InvertibleOperator) = has_mul(L.F)
 has_ldiv!(L::InvertibleOperator) = has_ldiv!(L.F)
 
-function cache_internals(L::InvertibleOperator, u::AbstractVecOrMat)
-    @reset L.L = cache_operator(L.L, u)
-    @reset L.F = cache_operator(L.F, u)
+function cache_internals(L::InvertibleOperator, v::AbstractVecOrMat)
+    @reset L.L = cache_operator(L.L, v)
+    @reset L.F = cache_operator(L.F, v)
 
     L
 end
 
 # operator application
 Base.:*(L::InvertibleOperator, x::AbstractVecOrMat) = L.L * x
 Base.:\(L::InvertibleOperator, x::AbstractVecOrMat) = L.F \ x
-function LinearAlgebra.mul!(v::AbstractVecOrMat, L::InvertibleOperator, u::AbstractVecOrMat)
-    mul!(v, L.L, u)
+function LinearAlgebra.mul!(w::AbstractVecOrMat, L::InvertibleOperator, v::AbstractVecOrMat)
+    mul!(w, L.L, v)
 end
-function LinearAlgebra.mul!(v::AbstractVecOrMat,
+function LinearAlgebra.mul!(w::AbstractVecOrMat,
         L::InvertibleOperator,
-        u::AbstractVecOrMat,
+        v::AbstractVecOrMat,
         α,
         β)
-    mul!(v, L.L, u, α, β)
+    mul!(w, L.L, v, α, β)
 end
-function LinearAlgebra.ldiv!(v::AbstractVecOrMat,
+function LinearAlgebra.ldiv!(w::AbstractVecOrMat,
         L::InvertibleOperator,
-        u::AbstractVecOrMat)
-    ldiv!(v, L.F, u)
+        v::AbstractVecOrMat)
+    ldiv!(w, L.F, v)
 end
 LinearAlgebra.ldiv!(L::InvertibleOperator, u::AbstractVecOrMat) = ldiv!(L.F, u)
 
@@ -641,38 +641,38 @@ function cache_internals(L::AffineOperator, u::AbstractVecOrMat)
 end
 
 # operator application
-function Base.:*(L::AffineOperator, u::AbstractVecOrMat)
-    @assert size(L.b, 2) == size(u, 2)
-    (L.A * u) + (L.B * L.b)
+function Base.:*(L::AffineOperator, v::AbstractVecOrMat)
+    @assert size(L.b, 2) == size(v, 2)
+    (L.A * v) + (L.B * L.b)
 end
 
-function Base.:\(L::AffineOperator, u::AbstractVecOrMat)
-    @assert size(L.b, 2) == size(u, 2)
-    L.A \ (u - (L.B * L.b))
+function Base.:\(L::AffineOperator, v::AbstractVecOrMat)
+    @assert size(L.b, 2) == size(v, 2)
+    L.A \ (v - (L.B * L.b))
 end
 
-function LinearAlgebra.mul!(v::AbstractVecOrMat, L::AffineOperator, u::AbstractVecOrMat)
-    mul!(v, L.B, L.b)
-    mul!(v, L.A, u, true, true)
+function LinearAlgebra.mul!(w::AbstractVecOrMat, L::AffineOperator, v::AbstractVecOrMat)
+    mul!(w, L.B, L.b)
+    mul!(w, L.A, v, true, true)
 end
 
-function LinearAlgebra.mul!(v::AbstractVecOrMat,
+function LinearAlgebra.mul!(w::AbstractVecOrMat,
         L::AffineOperator,
-        u::AbstractVecOrMat,
+        v::AbstractVecOrMat,
         α,
         β)
-    mul!(v, L.B, L.b, α, β)
-    mul!(v, L.A, u, α, true)
+    mul!(w, L.B, L.b, α, β)
+    mul!(w, L.A, v, α, true)
 end
 
-function LinearAlgebra.ldiv!(v::AbstractVecOrMat, L::AffineOperator, u::AbstractVecOrMat)
-    copy!(v, u)
-    ldiv!(L, v)
+function LinearAlgebra.ldiv!(w::AbstractVecOrMat, L::AffineOperator, v::AbstractVecOrMat)
+    copy!(w, v)
+    ldiv!(L, w)
 end
 
-function LinearAlgebra.ldiv!(L::AffineOperator, u::AbstractVecOrMat)
-    mul!(u, L.B, L.b, -1, 1)
-    ldiv!(L.A, u)
+function LinearAlgebra.ldiv!(L::AffineOperator, v::AbstractVecOrMat)
+    mul!(v, L.B, L.b, -1, 1)
+    ldiv!(L.A, v)
 end
 # Out-of-place: v is action vector, u is update vector
 function (L::AffineOperator)(v::AbstractVecOrMat, u, p, t; kwargs...)

src/tensor.jl

@@ -268,7 +268,7 @@ function LinearAlgebra.mul!(w::AbstractVecOrMat,
     # V .= U * B' <===> V' .= B * C'
     outer_mul!(w, L, v)
 
-    v
+    w
 end
 
 function LinearAlgebra.mul!(w::AbstractVecOrMat,
@@ -416,9 +416,9 @@ function outer_mul!(w::AbstractVecOrMat, L::TensorProductOperator, v::AbstractVe
     k = size(v, 2)
 
     if k == 1
-        V = reshape(w, (mi, mo))
+        W = reshape(w, (mi, mo))
         C1 = reshape(C1, (mi, no))
-        mul!(transpose(V), outer, transpose(C1))
+        mul!(transpose(W), outer, transpose(C1))
         return w
     end
 
@@ -429,13 +429,13 @@ function outer_mul!(w::AbstractVecOrMat, L::TensorProductOperator, v::AbstractVe
     C2 = reshape(C2, (no, mi * k))
     mul!(C3, outer, C2)
     C3 = reshape(C3, (mo, mi, k))
-    V = reshape(w, (mi, mo, k))
-    permutedims!(V, C3, PERM)
+    W = reshape(w, (mi, mo, k))
+    permutedims!(W, C3, PERM)
 
     w
 end
 
-function outer_mul!(v::AbstractVecOrMat, L::TensorProductOperator,
+function outer_mul!(w::AbstractVecOrMat, L::TensorProductOperator,
         v::AbstractVecOrMat, α, β)
     outer, inner = L.ops
 
@@ -456,23 +456,23 @@ function outer_mul!(v::AbstractVecOrMat, L::TensorProductOperator,
     mo, no = size(outer)
 
     if k == 1
-        V = reshape(w, (mi, mo))
+        W = reshape(w, (mi, mo))
         C = reshape(v, (mi, no))
-        mul!(transpose(V), outer, transpose(C), α, β)
+        mul!(transpose(W), outer, transpose(C), α, β)
         return w
     end
 
     C2, C3, c4 = L.cache[2:4]
 
-    C = reshape(c, (mi, no, k))
+    C = reshape(v, (mi, no, k))
     permutedims!(C2, C, PERM)
     C2 = reshape(C2, (no, mi * k))
     mul!(C3, outer, C2)
     C3 = reshape(C3, (mo, mi, k))
-    V = reshape(v, (mi, mo, k))
-    copy!(c4, v)
-    permutedims!(V, C3, PERM)
-    axpby!(β, c4, α, v)
+    W = reshape(w, (mi, mo, k))
+    copy!(c4, w)
+    permutedims!(W, C3, PERM)
+    axpby!(β, c4, α, w)
 
     w
 end