Fix type issues (#141)

Author: lostella

src/calculus/tilt.jl

@@ -10,7 +10,7 @@ Given function `f`, an array `a` and a constant `b` (optional), return function
 g(x) = f(x) + \\langle a, x \\rangle + b.
 ```
 """
-struct Tilt{T, S <: AbstractArray, R <: Real}
+struct Tilt{T, S, R}
     f::T
     a::S
     b::R
@@ -24,18 +24,18 @@ is_smooth(::Type{<:Tilt{T}}) where T = is_smooth(T)
 is_generalized_quadratic(::Type{<:Tilt{T}}) where T = is_generalized_quadratic(T)
 is_strongly_convex(::Type{<:Tilt{T}}) where T = is_strongly_convex(T)
 
-Tilt(f::T, a::S) where {R <: Real, T, S <: AbstractArray{R}} = Tilt{T, S, R}(f, a, R(0))
+Tilt(f::T, a::S) where {T, S} = Tilt{T, S, real(eltype(S))}(f, a, real(eltype(S))(0))
 
-function (g::Tilt)(x::AbstractArray{T}) where T <: RealOrComplex
-    return g.f(x) + dot(g.a, x) + g.b
+function (g::Tilt)(x)
+    return g.f(x) + real(dot(g.a, x)) + g.b
 end
 
-function prox!(y::AbstractArray{T}, g::Tilt, x::AbstractArray{T}, gamma=R(1)) where {R <: Real, T <: RealOrComplex{R}}
+function prox!(y, g::Tilt, x, gamma)
     v = prox!(y, g.f, x .- gamma .* g.a, gamma)
-    return v + dot(g.a, y) + g.b
+    return v + real(dot(g.a, y)) + g.b
 end
 
-function prox_naive(g::Tilt, x::AbstractArray{T}, gamma=R(1)) where {R <: Real, T <: RealOrComplex{R}}
+function prox_naive(g::Tilt, x, gamma)
     y, v = prox_naive(g.f, x .- gamma .* g.a, gamma)
-    return y, v + dot(g.a, y) + g.b
+    return y, v + real(dot(g.a, y)) + g.b
 end

src/functions/indGraphSkinny.jl

@@ -2,7 +2,7 @@
 
 using LinearAlgebra
 
-struct IndGraphSkinny{T <: RealOrComplex} <: IndGraph
+struct IndGraphSkinny{T} <: IndGraph
   m::Int
   n::Int
   A::Matrix{T}

src/functions/indPSD.jl

@@ -33,7 +33,7 @@ end
 
 IndPSD(; scaling=false) = IndPSD(scaling)
 
-function (::IndPSD)(X::HermOrSym)
+function (::IndPSD)(X::Union{Symmetric, Hermitian})
     R = real(eltype(X))
     F = eigen(X)
     for i in eachindex(F.values)
@@ -48,7 +48,7 @@ end
 is_convex(f::Type{<:IndPSD}) = true
 is_cone(f::Type{<:IndPSD}) = true
 
-function prox!(Y::HermOrSym, ::IndPSD, X::HermOrSym, gamma)
+function prox!(Y::Union{Symmetric, Hermitian}, ::IndPSD, X::Union{Symmetric, Hermitian}, gamma)
     R = real(eltype(X))
     n = size(X, 1)
     F = eigen(X)
@@ -65,7 +65,7 @@ function prox!(Y::HermOrSym, ::IndPSD, X::HermOrSym, gamma)
     return R(0)
 end
 
-function prox_naive(::IndPSD, X::HermOrSym, gamma)
+function prox_naive(::IndPSD, X::Union{Symmetric, Hermitian}, gamma)
     R = real(eltype(X))
     F = eigen(X)
     return F.vectors * Diagonal(max.(R(0), F.values)) * F.vectors', R(0)

src/functions/leastSquaresDirect.jl

@@ -49,7 +49,7 @@ function LeastSquaresDirect(A::M, b, lambda) where M <: SparseMatrixCSC
     LeastSquaresDirect{ndims(b), R, C, M, typeof(b), SuiteSparse.CHOLMOD.Factor{C}, lambda >= 0}(A, b, R(lambda))
 end
 
-function LeastSquaresDirect(A::TransposeOrAdjoint, b, lambda)
+function LeastSquaresDirect(A::Union{Transpose, Adjoint}, b, lambda)
     LeastSquaresDirect(copy(A), b, lambda)
 end
 

src/functions/leastSquaresIterative.jl

@@ -26,9 +26,9 @@ function LeastSquaresIterative(A::M, b, lambda) where M
     m, n = size(A)
     x_shape = infer_shape_of_x(A, b)
     shape, S, res2 = if m >= n
-        :Tall, AcA(A), []
+        :Tall, AcA(A, x_shape), []
     else
-        :Fat, AAc(A), zero(b)
+        :Fat, AAc(A, size(b)), zero(b)
     end
     RC = eltype(A)
     R = real(RC)

src/utilities/linops.jl

@@ -17,15 +17,16 @@ size(Op::LinOp, i::Integer) = i <= 2 ? size(Op)[i] : 1
 
 # AAc (Gram matrix)
 
-mutable struct AAc{M, T} <: LinOp
+struct AAc{M, T} <: LinOp
     A::M
-    buf::Maybe{AbstractArray{T}}
-    function AAc{M, T}(A::M) where {M, T}
-        new(A, nothing)
-    end
+    buf::T
 end
 
-AAc(A::M) where {M} = AAc{M, eltype(A)}(A)
+function AAc(A::M, input_shape::Tuple) where M
+    buffer_shape = (size(A, 2), input_shape[2:end]...)
+    buffer = zeros(eltype(A), buffer_shape)
+    AAc(A, buffer)
+end
 
 function mul!(y, Op::AAc, x)
     if Op.buf === nothing
@@ -43,15 +44,16 @@ eltype(Op::AAc) = eltype(Op.A)
 
 # AcA (Covariance matrix)
 
-mutable struct AcA{M, T} <: LinOp
+struct AcA{M, T} <: LinOp
     A::M
-    buf::Maybe{AbstractArray{T}}
-    function AcA{M, T}(A::M) where {M, T}
-        new(A, nothing)
-    end
+    buf::T
 end
 
-AcA(A::M) where {M} = AcA{M, eltype(A)}(A)
+function AcA(A::M, input_shape::Tuple) where M
+    buffer_shape = (size(A, 1), input_shape[2:end]...)
+    buffer = zeros(eltype(A), buffer_shape)
+    AcA(A, buffer)
+end
 
 function mul!(y, Op::AcA, x)
     if Op.buf === nothing