Merge pull request #362 from JuliaArrays/ajf/deps

Catch up on v0.7

Author: andyferris

REQUIRE

@@ -1,2 +1,2 @@
 julia 0.6.0
-Compat 0.39
+Compat 0.46

src/MArray.jl

@@ -74,7 +74,7 @@ end
 @inline MArray(a::StaticArray) = MArray{size_tuple(Size(a))}(Tuple(a))
 
 # Simplified show for the type
-show(io::IO, ::Type{MArray{S, T, N}}) where {S, T, N} = print(io, "MArray{$S,$T,$N}")
+#show(io::IO, ::Type{MArray{S, T, N}}) where {S, T, N} = print(io, "MArray{$S,$T,$N}")
 
 # Some more advanced constructor-like functions
 @inline one(::Type{MArray{S}}) where {S} = one(MArray{S,Float64,tuple_length(S)})
@@ -101,7 +101,7 @@ end
         unsafe_store!(Base.unsafe_convert(Ptr{T}, pointer_from_objref(v)), convert(T, val), i)
     else
         # This one is unsafe (#27)
-        # unsafe_store!(Base.unsafe_convert(Ptr{Ptr{Void}}, pointer_from_objref(v.data)), pointer_from_objref(val), i)
+        # unsafe_store!(Base.unsafe_convert(Ptr{Ptr{Nothing}}, pointer_from_objref(v.data)), pointer_from_objref(val), i)
         error("setindex!() with non-isbits eltype is not supported by StaticArrays. Consider using SizedArray.")
     end
 

src/MMatrix.jl

@@ -57,7 +57,7 @@ end
 @inline MMatrix(a::StaticMatrix) = MMatrix{size(typeof(a),1),size(typeof(a),2)}(Tuple(a))
 
 # Simplified show for the type
-show(io::IO, ::Type{MMatrix{N, M, T}}) where {N, M, T} = print(io, "MMatrix{$N,$M,$T}")
+#show(io::IO, ::Type{MMatrix{N, M, T}}) where {N, M, T} = print(io, "MMatrix{$N,$M,$T}")
 
 # Some more advanced constructor-like functions
 @inline one(::Type{MMatrix{N}}) where {N} = one(MMatrix{N,N})
@@ -78,7 +78,7 @@ show(io::IO, ::Type{MMatrix{N, M, T}}) where {N, M, T} = print(io, "MMatrix{$N,$
     else
         # Not sure about this... slow option for now...
         m.data[i]
-        #unsafe_load(Base.unsafe_convert(Ptr{Ptr{Void}}, pointer_from_objref(m.data)), i)
+        #unsafe_load(Base.unsafe_convert(Ptr{Ptr{Nothing}}, pointer_from_objref(m.data)), i)
     end
 end
 
@@ -92,7 +92,7 @@ end
         unsafe_store!(Base.unsafe_convert(Ptr{T}, pointer_from_objref(m)), val, i)
     else # TODO check that this isn't crazy. Also, check it doesn't cause problems with GC...
         # This one is unsafe (#27)
-        # unsafe_store!(Base.unsafe_convert(Ptr{Ptr{Void}}, pointer_from_objref(m.data)), pointer_from_objref(val), i)
+        # unsafe_store!(Base.unsafe_convert(Ptr{Ptr{Nothing}}, pointer_from_objref(m.data)), pointer_from_objref(val), i)
         error("setindex!() with non-isbits eltype is not supported by StaticArrays. Consider using SizedArray.")
     end
 

src/MVector.jl

@@ -21,7 +21,7 @@ const MVector{S, T} = MArray{Tuple{S}, T, 1, S}
 @inline MVector{S}(x::NTuple{S,Any}) where {S} = MVector{S, promote_tuple_eltype(typeof(x))}(x)
 
 # Simplified show for the type
-show(io::IO, ::Type{MVector{N, T}}) where {N, T} = print(io, "MVector{$N,$T}")
+#show(io::IO, ::Type{MVector{N, T}}) where {N, T} = print(io, "MVector{$N,$T}")
 
 # Some more advanced constructor-like functions
 @inline zeros(::Type{MVector{N}}) where {N} = zeros(MVector{N,Float64})
@@ -46,7 +46,7 @@ end
         unsafe_store!(Base.unsafe_convert(Ptr{T}, pointer_from_objref(v)), val, i)
     else
         # This one is unsafe (#27)
-        #unsafe_store!(Base.unsafe_convert(Ptr{Ptr{Void}}, pointer_from_objref(v.data)), pointer_from_objref(val), i)
+        #unsafe_store!(Base.unsafe_convert(Ptr{Ptr{Nothing}}, pointer_from_objref(v.data)), pointer_from_objref(val), i)
         error("setindex!() with non-isbits eltype is not supported by StaticArrays. Consider using SizedArray.")
     end
 

src/SArray.jl

@@ -53,7 +53,7 @@ end
 @inline SArray(a::StaticArray) = SArray{size_tuple(Size(a))}(Tuple(a))
 
 # Simplified show for the type
-show(io::IO, ::Type{SArray{S, T, N}}) where {S, T, N} = print(io, "SArray{$S,$T,$N}")
+# show(io::IO, ::Type{SArray{S, T, N}}) where {S, T, N} = print(io, "SArray{$S,$T,$N}") # TODO reinstate
 
 # Some more advanced constructor-like functions
 @inline one(::Type{SArray{S}}) where {S} = one(SArray{S, Float64, tuple_length(S)})

src/SDiagonal.jl

@@ -40,7 +40,7 @@ end
 
 # avoid linear indexing?
 @propagate_inbounds function getindex(D::SDiagonal{N,T}, k::Int) where {N,T}
-    i, j = ind2sub(size(D), k)
+    i, j = CartesianIndices(size(D))[k].I
     D[i,j]
 end
 
@@ -85,23 +85,26 @@ eye(::Type{SDiagonal{N,T}}) where {N,T} = SDiagonal(ones(SVector{N,T}))
 one(::Type{SDiagonal{N,T}}) where {N,T} = SDiagonal(ones(SVector{N,T}))
 one(::SDiagonal{N,T}) where {N,T} = SDiagonal(ones(SVector{N,T}))
 Base.zero(::SDiagonal{N,T}) where {N,T} = SDiagonal(zeros(SVector{N,T}))
-
-expm(D::SDiagonal) = SDiagonal(exp.(D.diag))
-logm(D::SDiagonal) = SDiagonal(log.(D.diag))
-sqrtm(D::SDiagonal) = SDiagonal(sqrt.(D.diag))
-Base.chol(D::SDiagonal) = SDiagonal(Base.chol.(D.diag))
-Base.LinAlg._chol!(D::SDiagonal, ::Type{UpperTriangular}) = chol(D)
-
+if VERSION < v"0.7-"
+    expm(D::SDiagonal) = SDiagonal(exp.(D.diag))
+    logm(D::SDiagonal) = SDiagonal(log.(D.diag))
+    sqrtm(D::SDiagonal) = SDiagonal(sqrt.(D.diag))
+else
+    exp(D::SDiagonal) = SDiagonal(exp.(D.diag))
+    log(D::SDiagonal) = SDiagonal(log.(D.diag))
+    sqrt(D::SDiagonal) = SDiagonal(sqrt.(D.diag))
+end
+LinearAlgebra.chol(D::SDiagonal) = SDiagonal(Base.chol.(D.diag))
+LinearAlgebra._chol!(D::SDiagonal, ::Type{UpperTriangular}) = chol(D)
 
 \(D::SDiagonal, B::StaticMatrix) = scalem(1 ./ D.diag, B)
 /(B::StaticMatrix, D::SDiagonal) = scalem(1 ./ D.diag, B)
 \(Da::SDiagonal, Db::SDiagonal) = SDiagonal(Db.diag ./ Da.diag)
 /(Da::SDiagonal, Db::SDiagonal) = SDiagonal(Da.diag ./ Db.diag )
 
-
 @generated function check_singular(D::SDiagonal{N}) where {N}
     quote
-    Base.Cartesian.@nexprs $N i->(@inbounds iszero(D.diag[i]) && throw(Base.LinAlg.SingularException(i)))
+    Base.Cartesian.@nexprs $N i->(@inbounds iszero(D.diag[i]) && throw(LinearAlgebra.SingularException(i)))
     end
 end
 

src/SMatrix.jl

@@ -57,7 +57,7 @@ end
 @inline SMatrix(a::StaticMatrix) = SMatrix{size(typeof(a),1),size(typeof(a),2)}(Tuple(a))
 
 # Simplified show for the type
-show(io::IO, ::Type{SMatrix{N, M, T}}) where {N, M, T} = print(io, "SMatrix{$N,$M,$T}")
+# show(io::IO, ::Type{SMatrix{N, M, T}}) where {N, M, T} = print(io, "SMatrix{$N,$M,$T}") # TODO reinstate
 
 # Some more advanced constructor-like functions
 @inline one(::Type{SMatrix{N}}) where {N} = one(SMatrix{N,N})

src/SVector.jl

@@ -23,7 +23,7 @@ const SVector{S, T} = SArray{Tuple{S}, T, 1, S}
 #@inline convert{S,T}(::Type{SVector{S}}, a::AbstractArray{T}) = SVector{S,T}((a...))
 
 # Simplified show for the type
-show(io::IO, ::Type{SVector{N, T}}) where {N, T} = print(io, "SVector{$N,$T}")
+# show(io::IO, ::Type{SVector{N, T}}) where {N, T} = print(io, "SVector{$N,$T}") # TODO reinstate
 
 # Some more advanced constructor-like functions
 @inline zeros(::Type{SVector{N}}) where {N} = zeros(SVector{N,Float64})

src/StaticArrays.jl

@@ -4,19 +4,42 @@ module StaticArrays
 
 import Base: @_inline_meta, @_propagate_inbounds_meta, @_pure_meta, @propagate_inbounds, @pure
 
-import Base: getindex, setindex!, size, similar, vec, show,
-             length, convert, promote_op, promote_rule, map, map!, reduce, reducedim, mapreducedim,
-             mapreduce, broadcast, broadcast!, conj, transpose,
-             hcat, vcat, ones, zeros, eye, one, cross, vecdot, reshape, fill,
-             fill!, det, logdet, inv, eig, eigvals, eigfact, expm, logm, sqrtm, lyap, trace, kron, diag, vecnorm, norm, dot, diagm, diag,
-             lu, svd, svdvals, svdfact, factorize, ishermitian, issymmetric, isposdef,
-             iszero, sum, diff, prod, count, any, all, minimum,
-             maximum, extrema, mean, copy, rand, randn, randexp, rand!, randn!,
-             randexp!, normalize, normalize!, read, read!, write, Eigen
-
-import Compat.adjoint
-
-using Compat
+import Base: getindex, setindex!, size, similar, vec, show, length, convert, promote_op,
+             promote_rule, map, map!, reduce, reducedim, mapreducedim, mapreduce, broadcast,
+             broadcast!, conj, hcat, vcat, ones, zeros, one, reshape, fill, fill!, inv,
+             iszero, sum, prod, count, any, all, minimum, maximum, extrema, mean,
+             copy, read, read!, write
+
+if VERSION < v"0.7-"
+    using Compat
+
+    using Base.Random
+    import Base: rand, randn, randexp, rand!, randn!, randexp!
+    using Core.Inference.return_type
+
+    import Base.LinAlg: transpose, ctranspose, eye, vecdot, eig, eigvals, eigfact, expm,
+                        logm, sqrtm, lyap, trace, kron, diag, vecnorm, norm, dot, diagm, lu,
+                        svd, svdvals, svdfact, factorize, ishermitian, issymmetric,
+                        isposdef, normalize, normalize!, Eigen, det, logdet, cross, diff, qr
+    const LinearAlgebra = Base.LinAlg
+
+    const adjoint = ctranspose
+    const Adjoint = RowVector
+else
+    using Compat
+
+    using Random
+    import Random: rand, randn, randexp, rand!, randn!, randexp!
+    using Core.Compiler: return_type
+
+    import Base: sqrt, exp, log
+
+    using LinearAlgebra
+    import LinearAlgebra: transpose, adjoint, vecdot, eig, eigvals, eigfact, lyap, trace,
+                          kron, diag, vecnorm, norm, dot, diagm, lu, svd, svdvals, svdfact,
+                          factorize, ishermitian, issymmetric, isposdef, normalize,
+                          normalize!, Eigen, det, logdet, cross, diff, qr
+end
 
 export StaticScalar, StaticArray, StaticVector, StaticMatrix
 export Scalar, SArray, SVector, SMatrix

src/abstractarray.jl

@@ -11,7 +11,7 @@ end
 
 # This seems to confuse Julia a bit in certain circumstances (specifically for trailing 1's)
 @inline function Base.isassigned(a::StaticArray, i::Int...)
-    ii = sub2ind(size(a), i...)
+    ii = LinearIndices(size(a))[i...]
     1 <= ii <= length(a) ? true : false
 end