Julia 0.7 upgrade (#23)

* Julia 0.7 upgrade

* adjusted README

* simplify Transpose/AdjointMap constructors

* Update travis.yml for Julia 0.7 compliance

* expanded qualifiers, added a few tests

* rm Ax_mul_B, typos, code style, more tests

* removed all `Ax_mul_B` (w/o !) since they are neither exported nor called internally
* added a few more tests to increase coverage
* improved code consistency: brackets, spaces, etc.

* constructors, code style

* removed (::Type{LinearMap{T}} in constructors
* polished code

Author: dkarrasch

.DS_Store

@@ -4,7 +4,7 @@ os:
   - linux
   - osx
 julia:
-  - 0.6
+  - 0.7
   - nightly
 
 matrix:

.travis.yml

@@ -8,7 +8,7 @@
 A Julia package for defining and working with linear maps, also known as linear transformations or linear operators acting on vectors. The only requirement for a LinearMap is that it can act on a vector (by multiplication) efficiently.
 
 ## What's new.
-*   Fully julia v0.6 compatible; dropped compatibility for previous versions of Julia.
+*   Fully julia v0.7 compatible; dropped compatibility for previous versions of Julia.
 
 *   `LinearMap` is now the name of the abstract type on top (used to be `AbstractLinearMap` because you could not have a function/constructor with the same name as an abstract type in older julia versions)
 
@@ -24,11 +24,11 @@ Several iterative linear algebra methods such as linear solvers or eigensolvers
 
 The LinearMaps package provides the following functionality:
 
-1.  A `LinearMap` type that shares with the `AbstractMatrix` type that it responds to the functions `size`, `eltype`, `isreal`, `issymmetric`, `ishermitian` and `isposdef`, `transpose` and `ctranspose` and multiplication with a vector using both `*` or the in-place version `A_mul_B!`. Depending on the subtype, also `At_mul_B`, `At_mul_B!`, `Ac_mul_B` and `Ac_mul_B!` are supported. Linear algebra functions that uses duck-typing for its arguments can handle `LinearMap` objects similar to `AbstractMatrix` objects, provided that they can be written using the above methods. Unlike `AbstractMatrix` types, `LinearMap` objects cannot be indexed, neither using `getindex` or `setindex!`.
+1.  A `LinearMap` type that shares with the `AbstractMatrix` type that it responds to the functions `size`, `eltype`, `isreal`, `issymmetric`, `ishermitian` and `isposdef`, `transpose` and `adjoint` and multiplication with a vector using both `*` or the in-place version `mul!`. Linear algebra functions that uses duck-typing for its arguments can handle `LinearMap` objects similar to `AbstractMatrix` objects, provided that they can be written using the above methods. Unlike `AbstractMatrix` types, `LinearMap` objects cannot be indexed, neither using `getindex` or `setindex!`.
 
 2.  A single method `LinearMap` function that acts as a general purpose constructor (though it only an abstract type) and allows to construct linear map objects from functions, or to wrap objects of type `AbstractMatrix` or `LinearMap`. The latter functionality is useful to (re)define the properties (`isreal`, `issymmetric`, `ishermitian`, `isposdef`) of the existing matrix or linear map.
 
-3.  A framework for combining objects of type `LinearMap` and of type `AbstractMatrix` using linear combinations, transposition and composition, where the  linear map resulting from these operations is never explicitly evaluated but only its matrix vector product is defined (i.e. lazy evaluation). The matrix vector product is written to minimize memory allocation by using a minimal number of temporary vectors. There is full support for the in-place version `A_mul_B!`, which should be preferred for higher efficiency in critical algorithms. In addition, it tries to recognize the properties of combinations of linear maps. In particular, compositions such as `A'*A` for arbitrary `A` or even `A'*B*C*B'*A` with arbitrary `A` and `B` and positive definite `C` are recognized as being positive definite and hermitian. In case a certain property of the resulting `LinearMap` object is not correctly inferred, the `LinearMap` method can be called to redefine the properties.
+3.  A framework for combining objects of type `LinearMap` and of type `AbstractMatrix` using linear combinations, transposition and composition, where the linear map resulting from these operations is never explicitly evaluated but only its matrix vector product is defined (i.e. lazy evaluation). The matrix vector product is written to minimize memory allocation by using a minimal number of temporary vectors. There is full support for the in-place version `mul!`, which should be preferred for higher efficiency in critical algorithms. In addition, it tries to recognize the properties of combinations of linear maps. In particular, compositions such as `A'*A` for arbitrary `A` or even `A'*B*C*B'*A` with arbitrary `A` and `B` and positive definite `C` are recognized as being positive definite and hermitian. In case a certain property of the resulting `LinearMap` object is not correctly inferred, the `LinearMap` method can be called to redefine the properties.
 
 ## Methods
 
@@ -49,7 +49,7 @@ The LinearMaps package provides the following functionality:
 
     Create a `FunctionMap` instance that wraps an object describing the action of the linear map on a vector as a function call. Here, `f` can be a function or any other object for which either the call `f(src::AbstractVector) -> dest::AbstractVector` (when `ismutating = false`) or `f(dest::AbstractVector,src::AbstractVector) -> dest` (when `ismutating = true`) is supported. The value of `ismutating` can be spefified, by default its value is guessed by looking at the number of arguments of the first method in the method list of `f`.
 
-    A second function or object can optionally be provided that implements the action of the adjoint (transposed) linear map. Here, it is always assumed that this represents the conjugate transpose, though this is of course equivalent to the normal transpose for real linear maps. Furthermore, the conjugate transpose also enables the use of `At_mul_B(!)` using some extra conjugation calls on the input and output vector. If no second function is provided, than `At_mul_B(!)` and `Ac_mul_B(!)` cannot be used with this linear map, unless it is symmetric or hermitian.
+    A second function or object can optionally be provided that implements the action of the adjoint (transposed) linear map. Here, it is always assumed that this represents the adjoint/conjugate transpose, though this is of course equivalent to the normal transpose for real linear maps. Furthermore, the conjugate transpose also enables the use of `mul!(y, transpose(A), x)` using some extra conjugation calls on the input and output vector. If no second function is provided, than `mul!(y, transpose(A), x)` and `mul!(y, adjoint(A), x)` cannot be used with this linear map, unless it is symmetric or hermitian.
 
     `M` is the number of rows (length of the output vectors) and `N` the number of columns (length of the input vectors). When the latter is not specified, `N = M`.
 
@@ -62,9 +62,13 @@ The LinearMaps package provides the following functionality:
     *   `ishermitian [=T<:Real && issymmetric]`: whether the function represents the multiplication with a hermitian matrix. If `true`, this will automatically enable `A'*x` and `A.'*x`.
     *   `isposdef [=false]`: whether the function represents the multiplication with a positive definite matrix.
 
-*   `Base.full(linearmap)`
+*   `Base.Array(linearmap)`
 
-    Creates a full matrix representation of the linearmap object, by multiplying it with the successive basis vectors. This is mostly for testing purposes or if you want to have the explicit matrix representation of a linear map for which you only have a function definition (e.g. to be able to use its `(c)transpose`).
+    Creates a dense matrix representation of the `linearmap` object, by multiplying it with the successive basis vectors. This is mostly for testing purposes or if you want to have the explicit matrix representation of a linear map for which you only have a function definition (e.g. to be able to use its `transpose` or `adjoint`).
+
+*   `SparseArrays.sparse(linearmap)`
+
+    Creates a sparse matrix representation of the `linearmap` object, by multiplying it with the successive basis vectors. This is mostly for testing purposes or if you want to have the explicit sparse matrix representation of a linear map for which you only have a function definition (e.g. to be able to use its `transpose` or `adjoint`).
 
 *   All matrix multiplication methods and the corresponding mutating versions.
 
@@ -88,13 +92,13 @@ None of the types below need to be constructed directly; they arise from perform
 
     Type for representing the identity map of a certain size `M=N`, obtained simply as `IdentityMap{T}(M)`, `IdentityMap(T,M)=IdentityMap(T,M,N)=IdentityMap(T,(M,N))` or even `IdentityMap(M)=IdentityMap(M,N)=IdentityMap((M,N))`. If `T` is not specified, `Bool` is assumed, since operations between `Bool` and any other `Number` will always be converted to the type of the other `Number`. If `M!=N`, an error is returned. An `IdentityMap` of the correct size and element type will automatically be created if `LinearMap` objects are combined with `I`, Julia's built in identity (`UniformScaling`).
 
-*   `LinearCombination`, `CompositeMap`, `TransposeMap` and `CTransposeMap`
+*   `LinearCombination`, `CompositeMap`, `TransposeMap` and `AdjointMap`
 
     Used to add and multiply `LinearMap` objects, don't need to be constructed explicitly.
 
 ## Examples
 
-The `LinearMap` object combines well with the iterative eigensolver `eigs`, which is the Julia wrapper for Arpack.
+The `LinearMap` object combines well with the iterative eigensolver `eigs` from [Arpack.jl](https://github.com/JuliaLinearAlgebra/Arpack.jl) and with iterative solvers from [IterativeSolvers.jl](https://github.com/JuliaMath/IterativeSolvers.jl).
 
 ```
 using LinearMaps

README.md

@@ -1 +1 @@
-julia 0.6
+julia 0.7-

REQUIRE

@@ -1,116 +1,76 @@
 __precompile__(true)
 module LinearMaps
 
-export LinearMap, AbstractLinearMap
+export LinearMap
 
-import Base: +, -, *, \, /, ==, transpose
-
-if VERSION >= v"0.7.0-DEV.1415"
-    const adjoint = Base.adjoint
-else
-    const adjoint = Base.ctranspose
-end
+using LinearAlgebra
+import SparseArrays
 
+import Base: +, -, *, \, /, ==
 
 abstract type LinearMap{T} end
 
-const AbstractLinearMap = LinearMap # will be deprecated
-
 Base.eltype(::LinearMap{T}) where {T} = T
-Base.eltype(::Type{L}) where {T,L<:LinearMap{T}} = T
 
 Base.isreal(A::LinearMap) = eltype(A) <: Real
-Base.issymmetric(::LinearMap) = false # default assumptions
-Base.ishermitian(A::LinearMap{<:Real}) = issymmetric(A)
-Base.ishermitian(::LinearMap) = false # default assumptions
-Base.isposdef(::LinearMap) = false # default assumptions
+LinearAlgebra.issymmetric(::LinearMap) = false # default assumptions
+LinearAlgebra.ishermitian(A::LinearMap{<:Real}) = issymmetric(A)
+LinearAlgebra.ishermitian(::LinearMap) = false # default assumptions
+LinearAlgebra.isposdef(::LinearMap) = false # default assumptions
 
 Base.ndims(::LinearMap) = 2
 Base.size(A::LinearMap, n) = (n==1 || n==2 ? size(A)[n] : error("LinearMap objects have only 2 dimensions"))
 Base.length(A::LinearMap) = size(A)[1] * size(A)[2]
 
-# any LinearMap subtype will have to overwrite at least one of the two following methods to avoid running in circles
-*(A::LinearMap, x::AbstractVector) = Base.A_mul_B!(similar(x, promote_type(eltype(A),eltype(x)), size(A,1)), A, x)
-Base.A_mul_B!(y::AbstractVector, A::LinearMap, x::AbstractVector) = begin
-    length(y) == size(A,1) || throw(DimensionMismatch("A_mul_B!"))
-    copy!(y, A*x)
+Base.:(*)(A::LinearMap, x::AbstractVector) = mul!(similar(x, promote_type(eltype(A), eltype(x)), size(A, 1)), A, x)
+function LinearAlgebra.mul!(y::AbstractVector, A::LinearMap, x::AbstractVector)
+    length(y) == size(A, 1) || throw(DimensionMismatch("mul!"))
+    A_mul_B!(y, A, x)
 end
 
-# the following for multiplying with transpose and adjoint map are optional:
-# subtypes can overwrite nonmutating methods, implement mutating methods or do nothing
-function Base.At_mul_B(A::LinearMap, x::AbstractVector)
-    l = methods(Base.At_mul_B!,Tuple{AbstractVector, typeof(A), AbstractVector})
-    if length(l) > 0 && first(l.ms).sig.parameters[3] != LinearMap
-        Base.At_mul_B!(similar(x, promote_type(eltype(A), eltype(x)), size(A,2)), A, x)
-    else
-        throw(MethodError(Base.At_mul_B, (A, x)))
-    end
-end
-function Base.At_mul_B!(y::AbstractVector, A::LinearMap, x::AbstractVector)
-    length(y) == size(A, 2) || throw(DimensionMismatch("At_mul_B!"))
-    l = methods(Base.At_mul_B,Tuple{typeof(A), AbstractVector})
-    if length(l) > 0 && first(l.ms).sig.parameters[2] != LinearMap
-        copy!(y, Base.At_mul_B(A, x))
-    else
-        throw(MethodError(Base.At_mul_B!, (y, A, x)))
-    end
-end
-function Base.Ac_mul_B(A::LinearMap,x::AbstractVector)
-    l = methods(Base.Ac_mul_B!,Tuple{AbstractVector, typeof(A), AbstractVector})
-    if length(l) > 0 && first(l.ms).sig.parameters[3] != LinearMap
-        Base.Ac_mul_B!(similar(x, promote_type(eltype(A), eltype(x)), size(A,2)), A, x)
-    else
-        throw(MethodError(Base.Ac_mul_B, (A, x)))
-    end
-end
-function
-Base.Ac_mul_B!(y::AbstractVector, A::LinearMap, x::AbstractVector)
-    length(y)==size(A,2) || throw(DimensionMismatch("At_mul_B!"))
-    l = methods(Base.Ac_mul_B,Tuple{typeof(A), AbstractVector})
-    if length(l) > 0 && first(l.ms).sig.parameters[2] != LinearMap
-        copy!(y, Base.Ac_mul_B(A, x))
-    else
-        throw(MethodError(Base.Ac_mul_B!, (y, A, x)))
-    end
-end
+A_mul_B!(y::AbstractVector, A::AbstractMatrix, x::AbstractVector) = mul!(y, A, x)
+At_mul_B!(y::AbstractVector, A::AbstractMatrix, x::AbstractVector) = mul!(y, transpose(A), x)
+Ac_mul_B!(y::AbstractVector, A::AbstractMatrix, x::AbstractVector) = mul!(y, adjoint(A), x)
 
-# full: create matrix representation of LinearMap
-function Base.full(A::LinearMap)
+# Matrix: create matrix representation of LinearMap
+function Base.Matrix(A::LinearMap)
     M, N = size(A)
     T = eltype(A)
-    mat = zeros(T, (M, N))
-    v = zeros(T, N)
+    mat = Matrix{T}(undef, (M, N))
+    v = fill(zero(T), N)
     for i = 1:N
         v[i] = one(T)
-        A_mul_B!(view(mat,:,i), A, v)
+        mul!(view(mat, :, i), A, v)
         v[i] = zero(T)
     end
     return mat
 end
 
-# sparse: create sparse matrix representtion of LinearMap
-function Base.sparse(A::LinearMap)
+Base.Array(A::LinearMap) = Base.Matrix(A)
+
+# sparse: create sparse matrix representation of LinearMap
+function SparseArrays.sparse(A::LinearMap)
     M, N = size(A)
     T = eltype(A)
     rowind = Int[]
     nzval = T[]
-    colptr = Vector{Int}(N+1)
-    v = zeros(T, N)
+    colptr = Vector{Int}(undef, N+1)
+    v = fill(zero(T), N)
 
     for i = 1:N
         v[i] = one(T)
-        Lv = A*v
-        js = find(Lv)
-        colptr[i] = length(nzval)+1
+        Lv = A * v
+        js = findall(!iszero, Lv)
+        colptr[i] = length(nzval) + 1
         if length(js) > 0
             append!(rowind, js)
             append!(nzval, Lv[js])
         end
         v[i] = zero(T)
     end
-    colptr[N+1] = length(nzval)+1
-    
-    return SparseMatrixCSC(M, N, colptr, rowind, nzval)
+    colptr[N+1] = length(nzval) + 1
+
+    return SparseArrays.SparseMatrixCSC(M, N, colptr, rowind, nzval)
 end
 
 include("transpose.jl") # transposing linear maps
@@ -127,7 +87,7 @@ include("functionmap.jl") # using a function as linear map
 Construct a linear map object, either from an existing `LinearMap` or `AbstractMatrix` `A`,
 with the purpose of redefining its properties via the keyword arguments `kwargs`, or
 from a function or callable object `f`. In the latter case, one also needs to specialize
-the size of the equivalent matrix representation `(M,N)`, i.e. for functions `f` acting
+the size of the equivalent matrix representation `(M, N)`, i.e. for functions `f` acting
 on length `N` vectors and producing length `M` vectors (with default value `N=M`). Preferably,
 also the `eltype` `T` of the corresponding matrix representation needs to be specified, i.e.
 whether the action of `f` on a vector will be similar to e.g. multiplying by numbers of type `T`.
@@ -139,7 +99,7 @@ The keyword arguments and their default values for functions `f` are
 *   ishermitian::Bool = issymmetric & T<:Real : whether `A` or `f` acts as a Hermitian matrix
 *   isposdef::Bool = false : whether `A` or `f` acts as a positive definite matrix.
 For existing linear maps or matrices `A`, the default values will be taken by calling
-`issymmetric`, `ishermitian` and `isposdef` on the exising object `A`.
+`issymmetric`, `ishermitian` and `isposdef` on the existing object `A`.
 
 For functions `f`, there is one more keyword arguments
 *   ismutating::Bool : flags whether the function acts as a mutating matrix multiplication
@@ -148,21 +108,13 @@ For functions `f`, there is one more keyword arguments
     The default value is guessed by looking at the number of arguments of the first occurence
     of `f` in the method table.
 """
-LinearMap(A::Union{AbstractMatrix,LinearMap}; kwargs...) = WrappedMap(A; kwargs...)
+LinearMap(A::Union{AbstractMatrix, LinearMap}; kwargs...) = WrappedMap(A; kwargs...)
 LinearMap(f, M::Int; kwargs...) = LinearMap{Float64}(f, M; kwargs...)
 LinearMap(f, M::Int, N::Int; kwargs...) = LinearMap{Float64}(f, M, N; kwargs...)
 LinearMap(f, fc, M::Int; kwargs...) = LinearMap{Float64}(f, fc, M; kwargs...)
 LinearMap(f, fc, M::Int, N::Int; kwargs...) = LinearMap{Float64}(f, fc, M, N; kwargs...)
 
-(::Type{LinearMap{T}})(A::Union{AbstractMatrix,LinearMap}; kwargs...) where {T} = WrappedMap{T}(A; kwargs...)
-(::Type{LinearMap{T}})(f, args...; kwargs...) where {T} = FunctionMap{T}(f, args...; kwargs...)
-
-@deprecate LinearMap(f, T::Type, args...; kwargs...) LinearMap{T}(f, args...; kwargs...)
-@deprecate LinearMap(f, fc, T::Type, args...; kwargs...) LinearMap{T}(f, fc, args...; kwargs...)
-
-@deprecate LinearMap(f, M::Int, T::Type; kwargs...) LinearMap{T}(f, M; kwargs...)
-@deprecate LinearMap(f, M::Int, N::Int, T::Type; kwargs...) LinearMap{T}(f, M, N; kwargs...)
-@deprecate LinearMap(f, fc, M::Int, T::Type; kwargs...) LinearMap{T}(f, fc, M; kwargs...)
-@deprecate LinearMap(f, fc, M::Int, N::Int, T::Type; kwargs...) LinearMap{T}(f, fc, M, N; kwargs...)
+LinearMap{T}(A::Union{AbstractMatrix, LinearMap}; kwargs...) where {T} = WrappedMap{T}(A; kwargs...)
+LinearMap{T}(f, args...; kwargs...) where {T} = FunctionMap{T}(f, args...; kwargs...)
 
 end # module