Merge pull request #394 from JuliaArrays/ajf/fix-some-v0.7-issues

Fix some v0.7 issues

Author: andyferris

src/SDiagonal.jl

@@ -73,7 +73,7 @@ transpose(D::SDiagonal) = D
 adjoint(D::SDiagonal) = conj(D)
 
 diag(D::SDiagonal) = D.diag
-trace(D::SDiagonal) = sum(D.diag)
+tr(D::SDiagonal) = sum(D.diag)
 det(D::SDiagonal) = prod(D.diag)
 logdet(D::SDiagonal{N,T}) where {N,T<:Real} = sum(log.(D.diag))
 function logdet(D::SDiagonal{N,T}) where {N,T<:Complex} #Make sure branch cut is correct

src/StaticArrays.jl

@@ -25,6 +25,7 @@ if VERSION < v"0.7-"
 
     const adjoint = ctranspose
     const Adjoint = RowVector
+    const tr = trace
 else
     using Compat
 
@@ -35,7 +36,7 @@ else
     import Base: sqrt, exp, log
 
     using LinearAlgebra
-    import LinearAlgebra: transpose, adjoint, eye, vecdot, eig, eigvals, eigfact, lyap, trace,
+    import LinearAlgebra: transpose, adjoint, eye, vecdot, eig, eigvals, eigfact, lyap, tr,
                           kron, diag, vecnorm, norm, dot, diagm, lu, svd, svdvals, svdfact,
                           factorize, ishermitian, issymmetric, isposdef, normalize,
                           normalize!, Eigen, det, logdet, cross, diff, qr

src/abstractarray.jl

@@ -105,7 +105,7 @@ similar(::Type{A},::Type{T},s::Size{S}) where {A<:Array,T,S} = sizedarray_simila
     if indexstyle == IndexLinear
         exprs = [:(a[$i]) for i = 1:prod(S)]
     else
-        exprs = [:(a[$(inds)]) for inds ∈ CartesianRange(S)]
+        exprs = [:(a[$(inds)]) for inds ∈ CartesianIndices(S)]
     end
 
     return quote

src/broadcast.jl

@@ -59,10 +59,6 @@ else
         Broadcast.DefaultArrayStyle(Broadcast._max(Val(M), Val(N)))
     BroadcastStyle(::StaticArrayStyle{M}, ::Broadcast.DefaultArrayStyle{0}) where {M} =
         StaticArrayStyle{M}()
-    # FIXME: These two rules should be removed once VectorStyle and MatrixStyle are removed from base/broadcast.jl
-    BroadcastStyle(::StaticArrayStyle{M}, ::Broadcast.VectorStyle) where M = Broadcast.Unknown()
-    BroadcastStyle(::StaticArrayStyle{M}, ::Broadcast.MatrixStyle) where M = Broadcast.Unknown()
-    # End FIXME
 
     # Add a broadcast method that calls the @generated routine
     @inline function broadcast(f, ::StaticArrayStyle, ::Nothing, ::Nothing, As...)
@@ -134,7 +130,7 @@ end
         exprs_vals = [(!(a[i] <: AbstractArray) ? :(a[$i][]) : :(a[$i][$(broadcasted_index(sizes[i], current_ind))])) for i = 1:length(sizes)]
         exprs[current_ind...] = :(f($(exprs_vals...)))
 
-        # increment current_ind (maybe use CartesianRange?)
+        # increment current_ind (maybe use CartesianIndices?)
         current_ind[1] += 1
         for i ∈ 1:length(newsize)
             if current_ind[i] > newsize[i]
@@ -151,7 +147,7 @@ end
         end
     end
 
-    eltype_exprs = [t <: AbstractArray ? :($(eltype(t))) : :($t) for t ∈ a]
+    eltype_exprs = [t <: Union{AbstractArray, Ref} ? :(eltype($t)) : :($t) for t ∈ a]
     newtype_expr = :(return_type(f, Tuple{$(eltype_exprs...)}))
 
     return quote
@@ -197,7 +193,7 @@ end
         exprs_vals = [(!(as[i] <: AbstractArray) ? :(as[$i][]) : :(as[$i][$(broadcasted_index(sizes[i], current_ind))])) for i = 1:length(sizes)]
         exprs[current_ind...] = :(dest[$j] = f($(exprs_vals...)))
 
-        # increment current_ind (maybe use CartesianRange?)
+        # increment current_ind (maybe use CartesianIndices?)
         current_ind[1] += 1
         for i ∈ 1:length(newsize)
             if current_ind[i] > newsize[i]

src/eigen.jl

@@ -100,7 +100,7 @@ end
 
     eig3 = q + 2 * p * cos(phi)
     eig1 = q + 2 * p * cos(phi + (2*Sreal(pi)/3))
-    eig2 = 3 * q - eig1 - eig3     # since trace(A) = eig1 + eig2 + eig3
+    eig2 = 3 * q - eig1 - eig3     # since tr(A) = eig1 + eig2 + eig3
 
     return SVector(eig1, eig2, eig3)
 end
@@ -268,7 +268,7 @@ end
 
     eig3 = q + 2 * p * cos(phi)
     eig1 = q + 2 * p * cos(phi + (2*Sreal(pi)/3))
-    eig2 = 3 * q - eig1 - eig3     # since trace(A) = eig1 + eig2 + eig3
+    eig2 = 3 * q - eig1 - eig3     # since tr(A) = eig1 + eig2 + eig3
 
     if r > 0 # Helps with conditioning the eigenvector calculation
         (eig1, eig3) = (eig3, eig1)

src/indexing.jl

@@ -224,7 +224,7 @@ end
 @generated function _getindex(a::AbstractArray, ind_sizes::Tuple{Vararg{Size}}, inds)
     newsize = out_index_size(ind_sizes.parameters...)
     linearsizes = linear_index_size(ind_sizes.parameters...)
-    exprs = Array{Expr}(linearsizes)
+    exprs = Array{Expr}(undef, linearsizes)
 
     # Iterate over input indices
     ind_types = inds.parameters
@@ -326,7 +326,7 @@ end
 # setindex! from a scalar
 @generated function _setindex!(a::AbstractArray, value, ind_sizes::Tuple{Vararg{Size}}, inds)
     linearsizes = linear_index_size(ind_sizes.parameters...)
-    exprs = Array{Expr}(linearsizes)
+    exprs = Array{Expr}(undef, linearsizes)
 
     # Iterate over input indices
     ind_types = inds.parameters
@@ -363,7 +363,7 @@ end
 # setindex! from an array
 @generated function _setindex!(a::AbstractArray, v::AbstractArray, ind_sizes::Tuple{Vararg{Size}}, inds)
     linearsizes = linear_index_size(ind_sizes.parameters...)
-    exprs = Array{Expr}(linearsizes)
+    exprs = Array{Expr}(undef, linearsizes)
 
     # Iterate over input indices
     ind_types = inds.parameters

src/linalg.jl

@@ -314,11 +314,11 @@ end
 @inline normalize(a::StaticVector) = inv(vecnorm(a))*a
 @inline normalize(a::StaticVector, p::Real) = inv(vecnorm(a, p))*a
 
-@inline normalize!(a::StaticVector) = (a .*= inv(vecnorm(a)))
-@inline normalize!(a::StaticVector, p::Real) = (a .*= inv(vecnorm(a, p)))
+@inline normalize!(a::StaticVector) = (a .*= inv(vecnorm(a)); return a)
+@inline normalize!(a::StaticVector, p::Real) = (a .*= inv(vecnorm(a, p)); return a)
 
-@inline trace(a::StaticMatrix) = _trace(Size(a), a)
-@generated function _trace(::Size{S}, a::StaticMatrix) where {S}
+@inline tr(a::StaticMatrix) = _tr(Size(a), a)
+@generated function _tr(::Size{S}, a::StaticMatrix) where {S}
     if S[1] != S[2]
         throw(DimensionMismatch("matrix is not square"))
     end

src/lyap.jl

@@ -4,7 +4,7 @@ _lyap(::Size{(1,1)}, ::Size{(1,1)}, a::StaticMatrix,  c::StaticMatrix) = -c/(2a[
 
 @inline function _lyap(::Size{(2,2)}, ::Size{(2,2)}, a::StaticMatrix,  c::StaticMatrix)
     d = det(a)
-    t = trace(a)
+    t = tr(a)
      -(d*c  + (a - t*I)*c*(a-t*I)')/(2*d*t) # http://www.nber.org/papers/w8956.pdf
 end
 

src/mapreduce.jl

@@ -97,7 +97,7 @@ end
 ##################
 
 # I'm not sure why the signature for this from Base precludes multiple arrays?
-# (also, why now mutating `mapreducedim!` and `reducedim!`?)
+# (also, why not mutating `mapreducedim!` and `reducedim!`?)
 # (similarly, `broadcastreduce` and `broadcastreducedim` sounds useful)
 @inline function mapreducedim(f, op, a::StaticArray, ::Type{Val{D}}) where {D}
     _mapreducedim(f, op, Size(a), a, Val{D})

test/SDiagonal.jl

@@ -32,10 +32,16 @@
         @test logdet(m) == logdet(m2)
         @test logdet(im*m) ≈ logdet(im*m2)
         @test det(m) == det(m2)
-        @test trace(m) == trace(m2)
-        @test logm(m) == logm(m2)
-        @test expm(m) == expm(m2)
-        @test sqrtm(m) == sqrtm(m2)
+        @test tr(m) == tr(m2)
+        if VERSION < v"0.7-"
+            @test logm(m) == logm(m2)
+            @test expm(m) == expm(m2)
+            @test sqrtm(m) == sqrtm(m2)
+        else
+            @test log(m) == log(m2)
+            @test exp(m) == exp(m2)
+            @test sqrt(m) == sqrt(m2)
+        end
         @test chol(m) == chol(m2)
 
         # Aparently recursive chol never really worked

test/indexing.jl

@@ -169,6 +169,10 @@
     @testset "inferabilty of index_sizes helper" begin
         # see JuliaLang/julia#21244
         # it's not about inferring the correct type, but about inference throwing an error
-        @test code_warntype(DevNull, StaticArrays.index_sizes, Tuple{Vararg{Any}}) == nothing
+        if VERSION < v"0.7-"
+            @test code_warntype(DevNull, StaticArrays.index_sizes, Tuple{Vararg{Any}}) == nothing
+        else
+            @test code_warntype(devnull, StaticArrays.index_sizes, Tuple{Vararg{Any}}) == nothing
+        end
     end
 end

test/linalg.jl

@@ -161,16 +161,16 @@ using StaticArrays, Base.Test
     end
 
     @testset "trace" begin
-        @test trace(@SMatrix [1.0 2.0; 3.0 4.0]) === 5.0
-        @test_throws DimensionMismatch trace(@SMatrix ones(5,4))
+        @test tr(@SMatrix [1.0 2.0; 3.0 4.0]) === 5.0
+        @test_throws DimensionMismatch tr(@SMatrix ones(5,4))
     end
 
     @testset "size zero" begin
         @test vecdot(SVector{0, Float64}(()), SVector{0, Float64}(())) === 0.
         @test StaticArrays.bilinear_vecdot(SVector{0, Float64}(()), SVector{0, Float64}(())) === 0.
         @test vecnorm(SVector{0, Float64}(())) === 0.
         @test vecnorm(SVector{0, Float64}(()), 1) === 0.
-        @test trace(SMatrix{0,0,Float64}(())) === 0.
+        @test tr(SMatrix{0,0,Float64}(())) === 0.
     end
 
     @testset "kron" begin

test/runtests.jl

@@ -3,11 +3,13 @@ if VERSION > v"0.7-"
     using Test
     using Random
     using LinearAlgebra
+    using InteractiveUtils
 else
     using Base.Test
     using Base.Random
     const LinearAlgebra = Base.LinAlg
     const Adjoint = RowVector
+    const tr = trace
 end
 
 # We generate a lot of matrices using rand(), but unit tests should be