Modernize syntax (#153)

* Modernize w/ struct and where

* Clean up some imports

* Update deprecated / removed exception type and add a test for it

* Remove compat

* Add row number to SingularException

* @fact_throws -> @test_throws

Author: haampie

REQUIRE

@@ -4,4 +4,3 @@ UnicodePlots
 RecipesBase
 SugarBLAS
 LinearMaps
-Compat 0.18.0

src/IterativeSolvers.jl

@@ -7,8 +7,6 @@ module IterativeSolvers
 
 using SugarBLAS
 
-using Compat
-
 include("common.jl")
 include("orthogonalize.jl")
 include("history.jl")

src/bicgstabl.jl

@@ -2,7 +2,7 @@ export bicgstabl, bicgstabl!, bicgstabl_iterator, bicgstabl_iterator!, BiCGStabI
 
 import Base: start, next, done
 
-type BiCGStabIterable{precT, matT, vecT <: AbstractVector, smallMatT <: AbstractMatrix, realT <: Real, scalarT <: Number}
+mutable struct BiCGStabIterable{precT, matT, vecT <: AbstractVector, smallMatT <: AbstractMatrix, realT <: Real, scalarT <: Number}
     A::matT
     b::vecT
     l::Int

src/cg.jl

@@ -2,7 +2,7 @@ import Base: start, next, done
 
 export cg, cg!, CGIterable, PCGIterable, cg_iterator, cg_iterator!
 
-type CGIterable{matT, vecT <: AbstractVector, numT <: Real}
+mutable struct CGIterable{matT, vecT <: AbstractVector, numT <: Real}
     A::matT
     x::vecT
     b::vecT
@@ -16,7 +16,7 @@ type CGIterable{matT, vecT <: AbstractVector, numT <: Real}
     mv_products::Int
 end
 
-type PCGIterable{precT, matT, vecT <: AbstractVector, numT <: Real, paramT <: Number}
+mutable struct PCGIterable{precT, matT, vecT <: AbstractVector, numT <: Real, paramT <: Number}
     Pl::precT
     A::matT
     x::vecT

src/chebyshev.jl

@@ -2,7 +2,7 @@ import Base: next, start, done
 
 export chebyshev, chebyshev!
 
-type ChebyshevIterable{precT, matT, vecT, realT <: Real}
+mutable struct ChebyshevIterable{precT, matT, vecT, realT <: Real}
     Pl::precT
     A::matT
     b::vecT

src/common.jl

@@ -1,9 +1,8 @@
-import  Base: eltype, length, ndims, real, size, *,
-        A_mul_B!, Ac_mul_B, Ac_mul_B!
+import Base: A_ldiv_B!, \
 
-using   LinearMaps, Compat
+using LinearMaps
 
-export  A_mul_B, Identity
+export Identity
 
 #### Type-handling
 """
@@ -47,10 +46,10 @@ solve(A::Function,b) = A(b)
 
 solve(A,b) = A\b
 
-solve!{T}(out::AbstractArray{T},A::Int,b::AbstractArray{T}) = scale!(out,b, 1/A)
+solve!(out::AbstractArray{T},A::Int,b::AbstractArray{T}) where {T} = scale!(out,b, 1/A)
 
-solve!{T}(out::AbstractArray{T},A,b::AbstractArray{T}) = A_ldiv_B!(out,A,b)
-solve!{T}(out::AbstractArray{T},A::Function,b::AbstractArray{T}) = copy!(out,A(b))
+solve!(out::AbstractArray{T},A,b::AbstractArray{T}) where {T} = A_ldiv_B!(out,A,b)
+solve!(out::AbstractArray{T},A::Function,b::AbstractArray{T}) where {T} = copy!(out,A(b))
 
 """
     initrand!(v)
@@ -67,17 +66,9 @@ end
 _randn!(v::Array{Float64}) = randn!(v)
 _randn!(v) = copy!(v, randn(length(v)))
 
-#### Errors
-export PosSemidefException
-
-type PosSemidefException <: Exception
-    msg :: AbstractString
-    PosSemidefException(msg::AbstractString="Matrix was not positive semidefinite") = new(msg)
-end
-
 # Identity preconditioner
-immutable Identity end
+struct Identity end
 
-Base.:\(::Identity, x) = copy(x)
-Base.A_ldiv_B!(::Identity, x) = x
-Base.A_ldiv_B!(y, ::Identity, x) = copy!(y, x)
+\(::Identity, x) = copy(x)
+A_ldiv_B!(::Identity, x) = x
+A_ldiv_B!(y, ::Identity, x) = copy!(y, x)

src/factorization.jl

@@ -14,7 +14,7 @@ and `P` computed by `idfact()`. See the documentation of `idfact()` for details.
 
 \\cite{Cheng2005, Liberty2007}
 """
-immutable Interpolative{T} <: Factorization{T}
+struct Interpolative{T} <: Factorization{T}
     B :: AbstractMatrix{T}
     P :: AbstractMatrix{T}
 end

src/gmres.jl

@@ -2,19 +2,19 @@ import Base: start, next, done
 
 export gmres, gmres!
 
-type ArnoldiDecomp{T, matT}
+mutable struct ArnoldiDecomp{T, matT}
     A::matT
     V::Matrix{T} # Orthonormal basis vectors
     H::Matrix{T} # Hessenberg matrix
 end
 
-ArnoldiDecomp{matT}(A::matT, order::Int, T::Type) = ArnoldiDecomp{T, matT}(
+ArnoldiDecomp(A::matT, order::Int, T::Type) where {matT} = ArnoldiDecomp{T, matT}(
     A,
     zeros(T, size(A, 1), order + 1),
     zeros(T, order + 1, order)
 )
 
-type Residual{numT, resT}
+mutable struct Residual{numT, resT}
     current::resT # Current, absolute, preconditioned residual
     accumulator::resT # Used to compute the residual on the go
     nullvec::Vector{numT} # Vector in the null space of H to compute residuals
@@ -28,7 +28,7 @@ Residual(order, T::Type) = Residual{T, real(T)}(
     one(real(T))
 )
 
-type GMRESIterable{preclT, precrT, vecT <: AbstractVector, arnoldiT <: ArnoldiDecomp, residualT <: Residual, resT <: Real}
+mutable struct GMRESIterable{preclT, precrT, vecT <: AbstractVector, arnoldiT <: ArnoldiDecomp, residualT <: Residual, resT <: Real}
     Pl::preclT
     Pr::precrT
     x::vecT
@@ -172,7 +172,7 @@ function update_residual!(r::Residual, arnoldi::ArnoldiDecomp, k::Int)
     r.current = r.β / √r.accumulator
 end
 
-function init!{T}(arnoldi::ArnoldiDecomp{T}, x, b, Pl, Ax; initially_zero::Bool = false)
+function init!(arnoldi::ArnoldiDecomp{T}, x, b, Pl, Ax; initially_zero::Bool = false) where {T}
     # Initialize the Krylov subspace with the initial residual vector
     # This basically does V[1] = Pl \ (b - A * x) and then normalize
 
@@ -194,12 +194,12 @@ function init!{T}(arnoldi::ArnoldiDecomp{T}, x, b, Pl, Ax; initially_zero::Bool
     β
 end
 
-@inline function init_residual!{numT,resT}(r::Residual{numT, resT}, β)
+@inline function init_residual!(r::Residual{numT, resT}, β) where {numT,resT}
     r.accumulator = one(resT)
     r.β = β
 end
 
-function solve_least_squares!{T}(arnoldi::ArnoldiDecomp{T}, β, k::Int)
+function solve_least_squares!(arnoldi::ArnoldiDecomp{T}, β, k::Int) where {T}
     # Compute the least-squares solution to Hy = β e1 via Given's rotations
     rhs = zeros(T, k)
     rhs[1] = β
@@ -210,14 +210,14 @@ function solve_least_squares!{T}(arnoldi::ArnoldiDecomp{T}, β, k::Int)
     rhs
 end
 
-function update_solution!{T}(x, y, arnoldi::ArnoldiDecomp{T}, Pr::Identity, k::Int, Ax)
+function update_solution!(x, y, arnoldi::ArnoldiDecomp{T}, Pr::Identity, k::Int, Ax) where {T}
     # Update x ← x + V * y
 
     # TODO: find the SugarBLAS alternative
     BLAS.gemv!('N', one(T), view(arnoldi.V, :, 1 : k - 1), y, one(T), x)
 end
 
-function update_solution!{T}(x, y, arnoldi::ArnoldiDecomp{T}, Pr, k::Int, Ax)
+function update_solution!(x, y, arnoldi::ArnoldiDecomp{T}, Pr, k::Int, Ax) where {T}
     # Computing x ← x + Pr \ (V * y) and use Ax as a work space
     A_mul_B!(Ax, view(arnoldi.V, :, 1 : k - 1), y)
     A_ldiv_B!(Pr, Ax)

src/hessenberg.jl

@@ -1,7 +1,7 @@
 import Base.LinAlg: Givens, givensAlgorithm
 import Base.A_ldiv_B!
 
-type Hessenberg{T<:AbstractMatrix}
+mutable struct Hessenberg{T<:AbstractMatrix}
     H::T # H is assumed to be Hessenberg of size (m + 1) × m
 end
 

src/history.jl

@@ -51,7 +51,7 @@ ploted as series and matrices as scatterplots.
 `Base`: `getindex`, `setindex!`, `push!`
 
 """
-type ConvergenceHistory{T,K}
+mutable struct ConvergenceHistory{T,K}
     mvps::Int
     mtvps::Int
     iters::Int
@@ -68,22 +68,22 @@ end
 """
 Stores information of the current iteration.
 """
-@compat const PartialHistory = ConvergenceHistory{false}
+const PartialHistory = ConvergenceHistory{false}
 
 """
 Stores the information of all the iterations.
 """
-@compat const CompleteHistory = ConvergenceHistory{true}
+const CompleteHistory = ConvergenceHistory{true}
 
 """
 History without resets.
 """
-@compat const UnrestartedHistory{T} = ConvergenceHistory{T, Void}
+const UnrestartedHistory{T} = ConvergenceHistory{T, Void}
 
 """
 History with resets.
 """
-@compat const RestartedHistory{T} = ConvergenceHistory{T, Int}
+const RestartedHistory{T} = ConvergenceHistory{T, Int}
 
 
 #############
@@ -256,8 +256,8 @@ nrests(ch::RestartedHistory) = Int(ceil(ch.iters/ch.restart))
 Determine whether a collection `x` is plotable. Only vectors and matrices are
 such objects.
 """
-plotable{T<:Real}(::VecOrMat{T})::Bool = true
-plotable(::Any)::Bool = false
+plotable(::VecOrMat{T}) where {T <: Real} = true
+plotable(::Any) = false
 
 # inner plots
 
@@ -286,10 +286,10 @@ Build a `UnicodePlot.Plot` object from the plotable collection `x`.
 If `x` is a vector, a series will be made. In case of being a matrix an scatterplot
 will be returned.
 """
-function plot_collection{T<:Real}(vals::Vector{T}, iters::Int, gap::Int;
+function plot_collection(vals::Vector{T}, iters::Int, gap::Int;
     restarts=Int(ceil(iters/gap)), color::Symbol=:blue, name::AbstractString="",
     title::AbstractString="", left::Int=1
-    )
+    ) where {T <: Real}
     maxy = round(maximum(vals),2)
     miny = round(minimum(vals),2)
     plot = lineplot([left],[miny],xlim=[left,iters],ylim=[miny,maxy],title=title,name=name)
@@ -303,10 +303,10 @@ function plot_collection{T<:Real}(vals::Vector{T}, iters::Int, gap::Int;
     end
     plot
 end
-function plot_collection{T<:Real}(vals::Matrix{T}, iters::Int, gap::Int;
+function plot_collection(vals::Matrix{T}, iters::Int, gap::Int;
     restarts=Int(ceil(iters/gap)), color::Symbol=:blue, name::AbstractString="",
     title::AbstractString="", left::Int=1
-    )
+    ) where {T <: Real}
     n = size(vals,2)
     maxy = round(maximum(vals),2)
     miny = round(minimum(vals),2)