rewrite zeros(T, dims) to fill(zero(T), dims)

Author: fredrikekre

base/env.jl

@@ -13,7 +13,7 @@ if Sys.iswindows()
         if len == 0
             return Libc.GetLastError() != ERROR_ENVVAR_NOT_FOUND ? "" : onError(str)
         end
-        val = zeros(UInt16,len)
+        val = fill(zero(UInt16), len)
         ret = ccall(:GetEnvironmentVariableW,stdcall,UInt32,(Ptr{UInt16},Ptr{UInt16},UInt32),var,val,len)
         if (ret == 0 && len != 1) || ret != len-1 || val[end] != 0
             error(string("getenv: ", str, ' ', len, "-1 != ", ret, ": ", Libc.FormatMessage()))

base/linalg/bidiag.jl

@@ -135,7 +135,7 @@ end
 #Converting from Bidiagonal to dense Matrix
 function Matrix{T}(A::Bidiagonal) where T
     n = size(A, 1)
-    B = zeros(T, n, n)
+    B = fill(zero(T), n, n)
     for i = 1:n - 1
         B[i,i] = A.dv[i]
         if A.uplo == 'U'
@@ -605,7 +605,7 @@ function eigvecs(M::Bidiagonal{T}) where T
     n = length(M.dv)
     Q = Matrix{T}(uninitialized, n,n)
     blks = [0; find(x -> x == 0, M.ev); n]
-    v = zeros(T, n)
+    v = fill(zero(T), n)
     if M.uplo == 'U'
         for idx_block = 1:length(blks) - 1, i = blks[idx_block] + 1:blks[idx_block + 1] #index of eigenvector
             fill!(v, zero(T))

base/linalg/bitarray.jl

@@ -23,8 +23,8 @@ end
     #if mA == 0; return C; end
     #col_ch = num_bit_chunks(mA)
     ## TODO: avoid using aux chunks and copy (?)
-    #aux_chunksA = zeros(UInt64, col_ch)
-    #aux_chunksB = [zeros(UInt64, col_ch) for j=1:nB]
+    #aux_chunksA = fill(zero(UInt64), col_ch)
+    #aux_chunksB = [fill(zero(UInt64), col_ch) for j=1:nB]
     #for j = 1:nB
         #Base.copy_chunks!(aux_chunksB[j], 1, B.chunks, (j-1)*mA+1, mA)
     #end

base/linalg/cholesky.jl

@@ -404,7 +404,7 @@ function getproperty(C::CholeskyPivoted{T}, d::Symbol) where T<:BlasFloat
         return getfield(C, :piv)
     elseif d == :P
         n = size(C, 1)
-        P = zeros(T, n, n)
+        P = fill(zero(T), n, n)
         for i = 1:n
             P[getfield(C, :piv)[i], i] = one(T)
         end

base/linalg/dense.jl

@@ -335,7 +335,7 @@ end
 function diagm_container(kv::Pair{<:Integer,<:AbstractVector}...)
     T = promote_type(map(x -> eltype(x.second), kv)...)
     n = mapreduce(x -> length(x.second) + abs(x.first), max, kv)
-    return zeros(T, n, n)
+    return fill(zero(T), n, n)
 end
 function diagm_container(kv::Pair{<:Integer,<:BitVector}...)
     n = mapreduce(x -> length(x.second) + abs(x.first), max, kv)
@@ -1280,7 +1280,7 @@ function pinv(A::StridedMatrix{T}, tol::Real) where T
     if istril(A)
         if istriu(A)
             maxabsA = maximum(abs.(diag(A)))
-            B = zeros(Tout, n, m)
+            B = fill(zero(Tout), n, m)
             for i = 1:min(m, n)
                 if abs(A[i,i]) > tol*maxabsA
                     Aii = inv(A[i,i])
@@ -1294,7 +1294,7 @@ function pinv(A::StridedMatrix{T}, tol::Real) where T
     end
     SVD         = svdfact(A, full = false)
     Stype       = eltype(SVD.S)
-    Sinv        = zeros(Stype, length(SVD.S))
+    Sinv        = fill(zero(Stype), length(SVD.S))
     index       = SVD.S .> tol*maximum(SVD.S)
     Sinv[index] = one(Stype) ./ SVD.S[index]
     Sinv[find(.!isfinite.(Sinv))] = zero(Stype)

base/linalg/diagonal.jl

@@ -82,7 +82,7 @@ end
     r
 end
 diagzero(::Diagonal{T},i,j) where {T} = zero(T)
-diagzero(D::Diagonal{Matrix{T}},i,j) where {T} = zeros(T, size(D.diag[i], 1), size(D.diag[j], 2))
+diagzero(D::Diagonal{Matrix{T}},i,j) where {T} = fill(zero(T), size(D.diag[i], 1), size(D.diag[j], 2))
 
 function setindex!(D::Diagonal, v, i::Int, j::Int)
     @boundscheck checkbounds(D, i, j)

base/linalg/hessenberg.jl

@@ -67,9 +67,9 @@ function getproperty(F::Hessenberg, d::Symbol)
 end
 
 function getindex(A::HessenbergQ, i::Integer, j::Integer)
-    x = zeros(eltype(A), size(A, 1))
+    x = fill(zero(eltype(A)), size(A, 1))
     x[i] = 1
-    y = zeros(eltype(A), size(A, 2))
+    y = fill(zero(eltype(A)), size(A, 2))
     y[j] = 1
     return dot(x, mul!(A, y))
 end

base/linalg/lapack.jl

@@ -736,7 +736,7 @@ and `tau`, which stores the elementary reflectors.
 """
 function geqp3!(A::AbstractMatrix{<:BlasFloat})
     m, n = size(A)
-    geqp3!(A, zeros(BlasInt, n), similar(A, min(m, n)))
+    geqp3!(A, fill(zero(BlasInt), n), similar(A, min(m, n)))
 end
 
 ## Complete orthogonaliztion tools
@@ -1206,7 +1206,7 @@ for (gelsd, gelsy, elty) in
             if size(B, 1) != m
                 throw(DimensionMismatch("B has leading dimension $(size(B,1)) but needs $m"))
             end
-            newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
+            newB = [B; fill(zero($elty), max(0, n - size(B, 1)), size(B, 2))]
             s     = similar(A, $elty, min(m, n))
             rnk   = Ref{BlasInt}()
             info  = Ref{BlasInt}()
@@ -1250,10 +1250,10 @@ for (gelsd, gelsy, elty) in
             if size(B, 1) != m
                 throw(DimensionMismatch("B has leading dimension $(size(B,1)) but needs $m"))
             end
-            newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
+            newB = [B; fill(zero($elty), max(0, n - size(B, 1)), size(B, 2))]
             lda = max(1, stride(A,2))
             ldb = max(1, stride(newB,2))
-            jpvt = zeros(BlasInt, n)
+            jpvt = fill(zero(BlasInt), n)
             rnk = Ref{BlasInt}()
             work = Vector{$elty}(uninitialized, 1)
             lwork = BlasInt(-1)
@@ -1299,7 +1299,7 @@ for (gelsd, gelsy, elty, relty) in
             if size(B, 1) != m
                 throw(DimensionMismatch("B has leading dimension $(size(B,1)) but needs $m"))
             end
-            newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
+            newB = [B; fill(zero($elty), max(0, n - size(B, 1)), size(B, 2))]
             s     = similar(A, $relty, min(m, n))
             rnk   = Ref{BlasInt}()
             info  = Ref{BlasInt}()
@@ -1345,10 +1345,10 @@ for (gelsd, gelsy, elty, relty) in
             if size(B, 1) != m
                 throw(DimensionMismatch("B has leading dimension $(size(B,1)) but needs $m"))
             end
-            newB = [B; zeros($elty, max(0, n - size(B, 1)), size(B, 2))]
+            newB = [B; fill(zero($elty), max(0, n - size(B, 1)), size(B, 2))]
             lda = max(1, m)
             ldb = max(1, m, n)
-            jpvt = zeros(BlasInt, n)
+            jpvt = fill(zero(BlasInt), n)
             rnk = Ref{BlasInt}(1)
             work = Vector{$elty}(uninitialized, 1)
             lwork = BlasInt(-1)
@@ -1424,7 +1424,7 @@ for (gglse, elty) in ((:dgglse_, :Float64),
             if length(d) != p
                 throw(DimensionMismatch("d has length $(length(d)), needs $p"))
             end
-            X = zeros($elty, n)
+            X = fill(zero($elty), n)
             info  = Ref{BlasInt}()
             work  = Vector{$elty}(uninitialized, 1)
             lwork = BlasInt(-1)
@@ -3721,7 +3721,7 @@ for (stev, stebz, stegr, stein, elty) in
             if length(ev_in) != n - 1
                 throw(DimensionMismatch("ev_in has length $(length(ev_in)) but needs one less than dv's length, $n)"))
             end
-            ev = [ev_in; zeros($elty,1)]
+            ev = [ev_in; fill(zero($elty),1)]
             ldz = n #Leading dimension
             #Number of eigenvalues to find
             if !(1 <= length(w_in) <= n)

base/linalg/lq.jl

@@ -86,7 +86,7 @@ function getproperty(F::LQ, d::Symbol)
 end
 
 getindex(A::LQPackedQ, i::Integer, j::Integer) =
-    mul!(A, setindex!(zeros(eltype(A), size(A, 2)), 1, j))[i]
+    mul!(A, setindex!(fill(zero(eltype(A)), size(A, 2)), 1, j))[i]
 
 function show(io::IO, C::LQ)
     println(io, "$(typeof(C)) with factors L and Q:")
@@ -160,7 +160,7 @@ function *(adjA::Adjoint{<:Any,<:LQPackedQ}, B::StridedVecOrMat)
     if size(B,1) == size(A.factors,2)
         mul!(adjoint(AbstractMatrix{TAB}(A)), copy_oftype(B, TAB))
     elseif size(B,1) == size(A.factors,1)
-        mul!(adjoint(AbstractMatrix{TAB}(A)), [B; zeros(TAB, size(A.factors, 2) - size(A.factors, 1), size(B, 2))])
+        mul!(adjoint(AbstractMatrix{TAB}(A)), [B; fill(zero(TAB), size(A.factors, 2) - size(A.factors, 1), size(B, 2))])
     else
         throw(DimensionMismatch("first dimension of B, $(size(B,1)), must equal one of the dimensions of A, $(size(A))"))
     end
@@ -235,7 +235,7 @@ function *(A::StridedVecOrMat, Q::LQPackedQ)
     if size(A, 2) == size(Q.factors, 2)
         C = copy_oftype(A, TR)
     elseif size(A, 2) == size(Q.factors, 1)
-        C = zeros(TR, size(A, 1), size(Q.factors, 2))
+        C = fill(zero(TR), size(A, 1), size(Q.factors, 2))
         copyto!(C, 1, A, 1, length(A))
     else
         _rightappdimmismatch("columns")
@@ -248,7 +248,7 @@ function *(adjA::Adjoint{<:Any,<:StridedMatrix}, Q::LQPackedQ)
     if size(A, 1) == size(Q.factors, 2)
         C = adjoint!(similar(A, TR, reverse(size(A))), A)
     elseif size(A, 1) == size(Q.factors, 1)
-        C = zeros(TR, size(A, 2), size(Q.factors, 2))
+        C = fill(zero(TR), size(A, 2), size(Q.factors, 2))
         adjoint!(view(C, :, 1:size(A, 1)), A)
     else
         _rightappdimmismatch("rows")

base/linalg/qr.jl

@@ -135,7 +135,7 @@ QRPivoted(factors::AbstractMatrix{T}, τ::Vector{T}, jpvt::Vector{BlasInt}) wher
 
 function qrfactUnblocked!(A::AbstractMatrix{T}) where {T}
     m, n = size(A)
-    τ = zeros(T, min(m,n))
+    τ = fill(zero(T), min(m,n))
     for k = 1:min(m - 1 + !(T<:Real), n)
         x = view(A, k:m, k)
         τk = reflector!(x)
@@ -460,7 +460,7 @@ function getproperty(F::QRPivoted{T}, d::Symbol) where T
     elseif d == :P
         p = F.p
         n = length(p)
-        P = zeros(T, n, n)
+        P = fill(zero(T), n, n)
         for i in 1:n
             P[p[i],i] = one(T)
         end
@@ -514,9 +514,9 @@ size(A::AbstractQ) = size(A, 1), size(A, 2)
 
 
 function getindex(A::AbstractQ, i::Integer, j::Integer)
-    x = zeros(eltype(A), size(A, 1))
+    x = fill(zero(eltype(A)), size(A, 1))
     x[i] = 1
-    y = zeros(eltype(A), size(A, 2))
+    y = fill(zero(eltype(A)), size(A, 2))
     y[j] = 1
     return dot(x, mul!(A, y))
 end
@@ -558,7 +558,7 @@ function (*)(A::AbstractQ, b::StridedVector)
     if size(A.factors, 1) == length(b)
         bnew = copy_oftype(b, TAb)
     elseif size(A.factors, 2) == length(b)
-        bnew = [b; zeros(TAb, size(A.factors, 1) - length(b))]
+        bnew = [b; fill(zero(TAb), size(A.factors, 1) - length(b))]
     else
         throw(DimensionMismatch("vector must have length either $(size(A.factors, 1)) or $(size(A.factors, 2))"))
     end
@@ -570,7 +570,7 @@ function (*)(A::AbstractQ, B::StridedMatrix)
     if size(A.factors, 1) == size(B, 1)
         Bnew = copy_oftype(B, TAB)
     elseif size(A.factors, 2) == size(B, 1)
-        Bnew = [B; zeros(TAB, size(A.factors, 1) - size(B,1), size(B, 2))]
+        Bnew = [B; fill(zero(TAB), size(A.factors, 1) - size(B,1), size(B, 2))]
     else
         throw(DimensionMismatch("first dimension of matrix must have size either $(size(A.factors, 1)) or $(size(A.factors, 2))"))
     end
@@ -711,7 +711,7 @@ function *(A::StridedMatrix, adjB::Adjoint{<:Any,<:AbstractQ})
         copyto!(AA, A)
         return mul!(AA, adjoint(BB))
     elseif size(A,2) == size(B.factors,2)
-        return mul!([A zeros(TAB, size(A, 1), size(B.factors, 1) - size(B.factors, 2))], adjoint(BB))
+        return mul!([A fill(zero(TAB), size(A, 1), size(B.factors, 1) - size(B.factors, 2))], adjoint(BB))
     else
         throw(DimensionMismatch("matrix A has dimensions $(size(A)) but matrix B has dimensions $(size(B))"))
     end
@@ -788,7 +788,7 @@ function ldiv!(A::QR{T}, B::StridedMatrix{T}) where T
     R = A.R
     @inbounds begin
         if n > m # minimum norm solution
-            τ = zeros(T,m)
+            τ = fill(zero(T),m)
             for k = m:-1:1 # Trapezoid to triangular by elementary operation
                 x = view(R, k, [k; m + 1:n])
                 τk = reflector!(x)
@@ -845,8 +845,8 @@ _cut_B(x::AbstractVector, r::UnitRange) = length(x)  > length(r) ? x[r]   : x
 _cut_B(X::AbstractMatrix, r::UnitRange) = size(X, 1) > length(r) ? X[r,:] : X
 
 ## append right hand side with zeros if necessary
-_zeros(::Type{T}, b::AbstractVector, n::Integer) where {T} = zeros(T, max(length(b), n))
-_zeros(::Type{T}, B::AbstractMatrix, n::Integer) where {T} = zeros(T, max(size(B, 1), n), size(B, 2))
+_zeros(::Type{T}, b::AbstractVector, n::Integer) where {T} = fill(zero(T), max(length(b), n))
+_zeros(::Type{T}, B::AbstractMatrix, n::Integer) where {T} = fill(zero(T), max(size(B, 1), n), size(B, 2))
 
 function (\)(A::Union{QR{TA},QRCompactWY{TA},QRPivoted{TA}}, B::AbstractVecOrMat{TB}) where {TA,TB}
     S = promote_type(TA,TB)