Merge pull request #15434 from JuliaLang/teh/separate_indexes

WIP: Disentangle arrays in iteration

base/abstractarray.jl

@@ -964,21 +964,20 @@ function isequal(A::AbstractArray, B::AbstractArray)
     if isa(A,Range) != isa(B,Range)
         return false
     end
-    for i in eachindex(A,B)
-        if !isequal(A[i], B[i])
+    for (a, b) in zip(A, B)
+        if !isequal(a, b)
             return false
         end
     end
     return true
 end
 
 function lexcmp(A::AbstractArray, B::AbstractArray)
-    nA, nB = length(A), length(B)
-    for i = 1:min(nA, nB)
-        res = lexcmp(A[i], B[i])
+    for (a, b) in zip(A, B)
+        res = lexcmp(a, b)
         res == 0 || return res
     end
-    return cmp(nA, nB)
+    return cmp(length(A), length(B))
 end
 
 function (==)(A::AbstractArray, B::AbstractArray)
@@ -988,8 +987,8 @@ function (==)(A::AbstractArray, B::AbstractArray)
     if isa(A,Range) != isa(B,Range)
         return false
     end
-    for i in eachindex(A,B)
-        if !(A[i]==B[i])
+    for (a, b) in zip(A, B)
+        if !(a == b)
             return false
         end
     end

base/arraymath.jl

@@ -13,8 +13,8 @@ for f in (:-, :~, :conj, :sign)
     @eval begin
         function ($f)(A::AbstractArray)
             F = similar(A)
-            for i in eachindex(A)
-                F[i] = ($f)(A[i])
+            for (iF, iA) in zip(eachindex(F), eachindex(A))
+                F[iF] = ($f)(A[iA])
             end
             return F
         end
@@ -28,8 +28,8 @@ imag(A::AbstractArray) = reshape([ imag(x) for x in A ], size(A))
 
 function !(A::AbstractArray{Bool})
     F = similar(A)
-    for i in eachindex(A)
-        F[i] = !A[i]
+    for (iF, iA) in zip(eachindex(F), eachindex(A))
+        F[iF] = !A[iA]
     end
     return F
 end
@@ -66,35 +66,29 @@ for (f,F) in ((:+,   AddFun()),
     @eval begin
         function ($f){S,T}(A::Range{S}, B::Range{T})
             F = similar(A, promote_op($F,S,T), promote_shape(size(A),size(B)))
-            i = 1
-            for (a,b) in zip(A,B)
-                @inbounds F[i] = ($f)(a, b)
-                i += 1
+            for (iF, iA, iB) in zip(eachindex(F), eachindex(A), eachindex(B))
+                @inbounds F[iF] = ($f)(A[iA], B[iB])
             end
             return F
         end
         function ($f){S,T}(A::AbstractArray{S}, B::Range{T})
             F = similar(A, promote_op($F,S,T), promote_shape(size(A),size(B)))
-            i = 1
-            for b in B
-                @inbounds F[i] = ($f)(A[i], b)
-                i += 1
+            for (iF, iA, iB) in zip(eachindex(F), eachindex(A), eachindex(B))
+                @inbounds F[iF] = ($f)(A[iA], B[iB])
             end
             return F
         end
         function ($f){S,T}(A::Range{S}, B::AbstractArray{T})
             F = similar(B, promote_op($F,S,T), promote_shape(size(A),size(B)))
-            i = 1
-            for a in A
-                @inbounds F[i] = ($f)(a, B[i])
-                i += 1
+            for (iF, iA, iB) in zip(eachindex(F), eachindex(A), eachindex(B))
+                @inbounds F[iF] = ($f)(A[iA], B[iB])
             end
             return F
         end
         function ($f){S,T}(A::AbstractArray{S}, B::AbstractArray{T})
             F = similar(A, promote_op($F,S,T), promote_shape(size(A),size(B)))
-            for i in eachindex(A,B)
-                @inbounds F[i] = ($f)(A[i], B[i])
+            for (iF, iA, iB) in zip(eachindex(F), eachindex(A), eachindex(B))
+                @inbounds F[iF] = ($f)(A[iA], B[iB])
             end
             return F
         end
@@ -116,15 +110,15 @@ for (f,F) in ((:.+,  DotAddFun()),
     @eval begin
         function ($f){T}(A::Number, B::AbstractArray{T})
             F = similar(B, promote_array_type($F,typeof(A),T))
-            for i in eachindex(B)
-                @inbounds F[i] = ($f)(A, B[i])
+            for (iF, iB) in zip(eachindex(F), eachindex(B))
+                @inbounds F[iF] = ($f)(A, B[iB])
             end
             return F
         end
         function ($f){T}(A::AbstractArray{T}, B::Number)
             F = similar(A, promote_array_type($F,typeof(B),T))
-            for i in eachindex(A)
-                @inbounds F[i] = ($f)(A[i], B)
+            for (iF, iA) in zip(eachindex(F), eachindex(A))
+                @inbounds F[iF] = ($f)(A[iA], B)
             end
             return F
         end

base/combinatorics.jl

@@ -140,8 +140,7 @@ Return the inverse permutation of `v`
 function invperm(a::AbstractVector)
     b = zero(a) # similar vector of zeros
     n = length(a)
-    @inbounds for i in eachindex(a)
-        j = a[i]
+    @inbounds for (i, j) in enumerate(a)
         ((1 <= j <= n) && b[j] == 0) ||
             throw(ArgumentError("argument is not a permutation"))
         b[j] = i

base/complex.jl

@@ -795,24 +795,24 @@ promote_array_type{S<:Union{Complex, Real}, AT<:AbstractFloat}(F, ::Type{S}, ::T
 function complex{S<:Real,T<:Real}(A::Array{S}, B::Array{T})
     if size(A) != size(B); throw(DimensionMismatch()); end
     F = similar(A, typeof(complex(zero(S),zero(T))))
-    for i in eachindex(A)
-        @inbounds F[i] = complex(A[i], B[i])
+    for (iF, iA, iB) in zip(eachindex(F), eachindex(A), eachindex(B))
+        @inbounds F[iF] = complex(A[iA], B[iB])
     end
     return F
 end
 
 function complex{T<:Real}(A::Real, B::Array{T})
     F = similar(B, typeof(complex(A,zero(T))))
-    for i in eachindex(B)
-        @inbounds F[i] = complex(A, B[i])
+    for (iF, iB) in zip(eachindex(F), eachindex(B))
+        @inbounds F[iF] = complex(A, B[iB])
     end
     return F
 end
 
 function complex{T<:Real}(A::Array{T}, B::Real)
     F = similar(A, typeof(complex(zero(T),B)))
-    for i in eachindex(A)
-        @inbounds F[i] = complex(A[i], B)
+    for (iF, iA) in zip(eachindex(F), eachindex(A))
+        @inbounds F[iF] = complex(A[iA], B)
     end
     return F
 end

base/dates/periods.jl

@@ -223,7 +223,7 @@ for op in (:.+, :.-)
         ($op_){P<:GeneralPeriod}(x::GeneralPeriod,Y::StridedArray{P}) = ($op)(Y,x) |> ($op_)
         ($op_){P<:GeneralPeriod}(Y::StridedArray{P},x::GeneralPeriod) = ($op)(Y,x)
         ($op_){P<:GeneralPeriod, Q<:GeneralPeriod}(X::StridedArray{P}, Y::StridedArray{Q}) =
-            reshape(CompoundPeriod[($op_)(X[i],Y[i]) for i in eachindex(X, Y)], promote_shape(size(X),size(Y)))
+            reshape(CompoundPeriod[($op_)(x,y) for (x,y) in zip(X, Y)], promote_shape(size(X),size(Y)))
     end
 end
 

base/floatfuncs.jl

@@ -69,44 +69,44 @@ round{T<:Integer}(::Type{T}, x::AbstractFloat, r::RoundingMode) = trunc(T,round(
 for f in (:trunc,:floor,:ceil,:round)
     @eval begin
         function ($f){T,R}(::Type{T}, x::AbstractArray{R,1})
-            [ ($f)(T, x[i])::T for i = 1:length(x) ]
+            [ ($f)(T, y)::T for y in x ]
         end
         function ($f){T,R}(::Type{T}, x::AbstractArray{R,2})
             [ ($f)(T, x[i,j])::T for i = 1:size(x,1), j = 1:size(x,2) ]
         end
         function ($f){T}(::Type{T}, x::AbstractArray)
-            reshape([ ($f)(T, x[i])::T for i in eachindex(x) ], size(x))
+            reshape([ ($f)(T, y)::T for y in x ], size(x))
         end
         function ($f){R}(x::AbstractArray{R,1}, digits::Integer, base::Integer=10)
-            [ ($f)(x[i], digits, base) for i = 1:length(x) ]
+            [ ($f)(y, digits, base) for y in x ]
         end
         function ($f){R}(x::AbstractArray{R,2}, digits::Integer, base::Integer=10)
             [ ($f)(x[i,j], digits, base) for i = 1:size(x,1), j = 1:size(x,2) ]
         end
         function ($f)(x::AbstractArray, digits::Integer, base::Integer=10)
-            reshape([ ($f)(x[i], digits, base) for i in eachindex(x) ], size(x))
+            reshape([ ($f)(y, digits, base) for y in x ], size(x))
         end
     end
 end
 
 function round{R}(x::AbstractArray{R,1}, r::RoundingMode)
-    [ round(x[i], r) for i = 1:length(x) ]
+    [ round(y, r) for y in x ]
 end
 function round{R}(x::AbstractArray{R,2}, r::RoundingMode)
     [ round(x[i,j], r) for i = 1:size(x,1), j = 1:size(x,2) ]
 end
 function round(x::AbstractArray, r::RoundingMode)
-    reshape([ round(x[i], r) for i in eachindex(x) ], size(x))
+    reshape([ round(y, r) for y in x ], size(x))
 end
 
 function round{T,R}(::Type{T}, x::AbstractArray{R,1}, r::RoundingMode)
-    [ round(T, x[i], r)::T for i = 1:length(x) ]
+    [ round(T, y, r)::T for y in x ]
 end
 function round{T,R}(::Type{T}, x::AbstractArray{R,2}, r::RoundingMode)
     [ round(T, x[i,j], r)::T for i = 1:size(x,1), j = 1:size(x,2) ]
 end
 function round{T}(::Type{T}, x::AbstractArray, r::RoundingMode)
-    reshape([ round(T, x[i], r)::T for i in eachindex(x) ], size(x))
+    reshape([ round(T, y, r)::T for y in x ], size(x))
 end
 
 # adapted from Matlab File Exchange roundsd: http://www.mathworks.com/matlabcentral/fileexchange/26212

base/io.jl

@@ -142,10 +142,10 @@ end
 write(s::IO, x::Bool)    = write(s, UInt8(x))
 write(to::IO, p::Ptr) = write(to, convert(UInt, p))
 
-function write(s::IO, a::AbstractArray)
+function write(s::IO, A::AbstractArray)
     nb = 0
-    for i in eachindex(a)
-        nb += write(s, a[i])
+    for a in A
+        nb += write(s, a)
     end
     return nb
 end
@@ -159,8 +159,8 @@ end
         return unsafe_write(s, pointer(a), sizeof(a))
     else
         nb = 0
-        for i in eachindex(a)
-            nb += write(s, a[i])
+        for b in a
+            nb += write(s, b)
         end
         return nb
     end

base/linalg/generic.jl

@@ -22,14 +22,8 @@ function generic_scale!(C::AbstractArray, X::AbstractArray, s::Number)
     if length(C) != length(X)
         throw(DimensionMismatch("first array has length $(length(C)) which does not match the length of the second, $(length(X))."))
     end
-    if size(C) == size(X)
-        for I in eachindex(C, X)
-            @inbounds C[I] = X[I]*s
-        end
-    else
-        for (IC, IX) in zip(eachindex(C), eachindex(X))
-            @inbounds C[IC] = X[IX]*s
-        end
+    for (IC, IX) in zip(eachindex(C), eachindex(X))
+        @inbounds C[IC] = X[IX]*s
     end
     C
 end
@@ -39,14 +33,8 @@ function generic_scale!(C::AbstractArray, s::Number, X::AbstractArray)
         throw(DimensionMismatch("first array has length $(length(C)) which does not
 match the length of the second, $(length(X))."))
     end
-    if size(C) == size(X)
-        for I in eachindex(C, X)
-            @inbounds C[I] = s*X[I]
-        end
-    else
-        for (IC, IX) in zip(eachindex(C), eachindex(X))
-            @inbounds C[IC] = s*X[IX]
-        end
+    for (IC, IX) in zip(eachindex(C), eachindex(X))
+        @inbounds C[IC] = s*X[IX]
     end
     C
 end
@@ -273,14 +261,8 @@ function vecdot(x::AbstractArray, y::AbstractArray)
         return dot(zero(eltype(x)), zero(eltype(y)))
     end
     s = zero(dot(x[1], y[1]))
-    if size(x) == size(y)
-        for I in eachindex(x, y)
-            @inbounds s += dot(x[I], y[I])
-        end
-    else
-        for (Ix, Iy) in zip(eachindex(x), eachindex(y))
-            @inbounds  s += dot(x[Ix], y[Iy])
-        end
+    for (Ix, Iy) in zip(eachindex(x), eachindex(y))
+        @inbounds  s += dot(x[Ix], y[Iy])
     end
     s
 end

base/linalg/lapack.jl

@@ -87,9 +87,9 @@ subsetrows(X::AbstractVector, Y::AbstractArray, k) = Y[1:k]
 subsetrows(X::AbstractMatrix, Y::AbstractArray, k) = Y[1:k, :]
 
 function chkfinite(A::StridedMatrix)
-    for i = eachindex(A)
-        if !isfinite(A[i])
-            throw(ArgumentError("matrix contains NaNs"))
+    for a in A
+        if !isfinite(a)
+            throw(ArgumentError("matrix contains Infs or NaNs"))
         end
     end
     return true

base/math.jl

@@ -250,12 +250,12 @@ function frexp{T<:AbstractFloat}(x::T)
 end
 
 function frexp{T<:AbstractFloat}(A::Array{T})
-    f = similar(A)
-    e = Array(Int, size(A))
-    for i in eachindex(A)
-        f[i], e[i] = frexp(A[i])
+    F = similar(A)
+    E = Array(Int, size(A))
+    for (iF, iE, iA) in zip(eachindex(F), eachindex(E), eachindex(A))
+        F[iF], E[iE] = frexp(A[iA])
     end
-    return (f, e)
+    return (F, E)
 end
 
 modf(x) = rem(x,one(x)), trunc(x)

base/multidimensional.jl

@@ -232,11 +232,9 @@ function _unsafe_getindex(::LinearIndexing, src::AbstractArray, I::AbstractArray
     size(dest) == (N,) || throw(DimensionMismatch())
     D = eachindex(dest)
     Ds = start(D)
-    s = 0
-    for b in eachindex(I)
-        s+=1
-        @inbounds Ib = I[b]
-        if Ib
+    for (i, s) in zip(eachindex(I), eachindex(src))
+        @inbounds Ii = I[i]
+        if Ii
             d, Ds = next(D, Ds)
             @inbounds dest[d] = src[s]
         end
@@ -311,15 +309,13 @@ end
 function _unsafe_setindex!(::LinearIndexing, A::AbstractArray, x, I::AbstractArray{Bool})
     X = _iterable(x)
     Xs = start(X)
-    i = 0
     c = 0
-    for b in eachindex(I)
-        i+=1
-        @inbounds Ib = I[b]
-        if Ib
+    for (iA, i) in zip(eachindex(A), eachindex(I))
+        @inbounds Ii = I[i]
+        if Ii
             done(X, Xs) && throw_setindex_mismatch(x, c+1)
             (v, Xs) = next(X, Xs)
-            @inbounds A[i] = v
+            @inbounds A[iA] = v
             c += 1
         end
     end
@@ -533,25 +529,9 @@ function fill!{T}(A::AbstractArray{T}, x)
 end
 
 function copy!{T,N}(dest::AbstractArray{T,N}, src::AbstractArray{T,N})
-    samesize = true
-    for d = 1:N
-        if size(dest,d) != size(src,d)
-            samesize = false
-            break
-        end
-    end
-    if samesize && linearindexing(dest) == linearindexing(src)
-        for I in eachindex(dest)
-            @inbounds dest[I] = src[I]
-        end
-    else
-        length(dest) >= length(src) || throw(BoundsError())
-        iterdest = eachindex(dest)
-        sdest = start(iterdest)
-        for Isrc in eachindex(src)
-            Idest, sdest = next(iterdest, sdest)
-            @inbounds dest[Idest] = src[Isrc]
-        end
+    length(dest) >= length(src) || throw(BoundsError())
+    for (Isrc, Idest) in zip(eachindex(src), eachindex(dest))
+        @inbounds dest[Idest] = src[Isrc]
     end
     dest
 end