Merge pull request #124 from JuliaParallel/anj/bc

Update to broadcast API changes in base

Author: andreasnoack

src/darray.jl

@@ -56,7 +56,7 @@ type DArray{T,N,A} <: AbstractArray{T,N}
 end
 
 eltype{T}(::Type{DArray{T}}) = T
-empty_localpart(T,N,A) = convert(A, Array(T, ntuple(zero, N)))
+empty_localpart(T,N,A) = convert(A, Array{T}(ntuple(zero, N)))
 
 typealias SubDArray{T,N,D<:DArray} SubArray{T,N,D}
 typealias SubOrDArray{T,N} Union{DArray{T,N}, SubDArray{T,N}}
@@ -177,14 +177,14 @@ function DArray(refs)
     id = next_did()
 
     npids = [r.where for r in refs]
-    nsizes = Array(Tuple, dimdist)
+    nsizes = Array{Tuple}(dimdist)
     @sync for i in 1:length(refs)
         let i=i
             @async nsizes[i] = remotecall_fetch(sz_localpart_ref, npids[i], refs[i], id)
         end
     end
 
-    nindexes = Array(NTuple{length(dimdist),UnitRange{Int}}, dimdist...)
+    nindexes = Array{NTuple{length(dimdist),UnitRange{Int}}}(dimdist...)
 
     for i in 1:length(nindexes)
         subidx = ind2sub(dimdist, i)
@@ -231,7 +231,7 @@ DArray(init, d::DArray) = DArray(next_did(), init, size(d), procs(d), d.indexes,
 
 sz_localpart_ref(ref, id) = size(fetch(ref))
 
-Base.similar(d::DArray, T::Type, dims::Dims) = DArray(I->Array(T, map(length,I)), dims, procs(d))
+Base.similar(d::DArray, T::Type, dims::Dims) = DArray(I->Array{T}(map(length,I)), dims, procs(d))
 Base.similar(d::DArray, T::Type) = similar(d, T, size(d))
 Base.similar{T}(d::DArray{T}, dims::Dims) = similar(d, T, dims)
 Base.similar{T}(d::DArray{T}) = similar(d, T, size(d))
@@ -284,7 +284,7 @@ end
 function chunk_idxs(dims, chunks)
     cuts = map(defaultdist, dims, chunks)
     n = length(dims)
-    idxs = Array(NTuple{n,UnitRange{Int}},chunks...)
+    idxs = Array{NTuple{n,UnitRange{Int}}}(chunks...)
     for cidx in CartesianRange(tuple(chunks...))
         idxs[cidx.I...] = ntuple(i -> (cuts[i][cidx[i]]:cuts[i][cidx[i] + 1] - 1), n)
     end
@@ -456,7 +456,7 @@ end
 Base.convert{T,N,S<:AbstractArray}(::Type{DArray{T,N,S}}, A::S) = distribute(convert(AbstractArray{T,N}, A))
 
 Base.convert{S,T,N}(::Type{Array{S,N}}, d::DArray{T,N}) = begin
-    a = Array(S, size(d))
+    a = Array{S}(size(d))
     @sync begin
         for i = 1:length(d.pids)
             @async a[d.indexes[i]...] = chunk(d, i)
@@ -475,7 +475,7 @@ Base.convert{S,T,N}(::Type{Array{S,N}}, s::SubDArray{T,N}) = begin
             return chunk(d, l...)
         end
     end
-    a = Array(S, size(s))
+    a = Array{S}(size(s))
     a[[1:size(a,i) for i=1:N]...] = s
     return a
 end
@@ -484,7 +484,7 @@ function Base.convert{T,N}(::Type{DArray}, SD::SubArray{T,N})
     D = SD.parent
     DArray(size(SD), procs(D)) do I
         TR = typeof(SD.indexes[1])
-        lindices = Array(TR, 0)
+        lindices = Array{TR}(0)
         for (i,r) in zip(I, SD.indexes)
             st = step(r)
             lrstart = first(r) + st*(first(i)-1)
@@ -508,7 +508,7 @@ Base.reshape{T,S<:Array}(A::DArray{T,1,S}, d::Dims) = begin
         d1offs = first(I[1])
         nd = length(I)
 
-        B = Array(T,sz)
+        B = Array{T}(sz)
         nr = size(B,1)
         sztail = size(B)[2:end]
 
@@ -667,16 +667,17 @@ import Base: checkbounds_indices
 #    the local portion of the source array
 function Base.setindex!(a::Array, s::SubDArray,
         I::Union{UnitRange{Int},Colon,Vector{Int},StepRange{Int,Int}}...)
-    Base.setindex_shape_check(s, Base.index_lengths(a, I...)...)
-    n = length(I)
+    Inew = Base.to_indices(a, I)
+    Base.setindex_shape_check(s, Base.index_lengths(Inew...)...)
+    n = length(Inew)
     d = s.parent
-    J = Base.decolon(d, s.indexes...)
+    J = Base.to_indices(d, s.indexes)
     @sync for i = 1:length(d.pids)
         K_c = d.indexes[i]
         K = map(intersect, J, K_c)
         if !any(isempty, K)
             K_mask = map(indexin_mask, J, K_c)
-            idxs = restrict_indices(Base.decolon(a, I...), K_mask)
+            idxs = restrict_indices(Inew, K_mask)
             if isequal(K, K_c)
                 # whole chunk
                 @async a[idxs...] = chunk(d, i)

src/linalg.jl

@@ -1,14 +1,14 @@
 function Base.ctranspose{T}(D::DArray{T,2})
     DArray(reverse(size(D)), procs(D)) do I
-        lp = Array(T, map(length, I))
+        lp = Array{T}(map(length, I))
         rp = convert(Array, D[reverse(I)...])
         ctranspose!(lp, rp)
     end
 end
 
 function Base.transpose{T}(D::DArray{T,2})
     DArray(reverse(size(D)), procs(D)) do I
-        lp = Array(T, map(length, I))
+        lp = Array{T}(map(length, I))
         rp = convert(Array, D[reverse(I)...])
         transpose!(lp, rp)
     end
@@ -91,7 +91,7 @@ function A_mul_B!(α::Number, A::DMatrix, x::AbstractVector, β::Number, y::DVec
     end
 
     # Multiply on each tile of A
-    R = Array(Future, size(A.pids)...)
+    R = Array{Future}(size(A.pids)...)
     for j = 1:size(A.pids, 2)
         xj = x[A.cuts[2][j]:A.cuts[2][j + 1] - 1]
         for i = 1:size(A.pids, 1)
@@ -135,7 +135,7 @@ function Ac_mul_B!(α::Number, A::DMatrix, x::AbstractVector, β::Number, y::DVe
     end
 
     # Multiply on each tile of A
-    R = Array(Future, reverse(size(A.pids))...)
+    R = Array{Future}(reverse(size(A.pids))...)
     for j = 1:size(A.pids, 1)
         xj = x[A.cuts[1][j]:A.cuts[1][j + 1] - 1]
         for i = 1:size(A.pids, 2)
@@ -201,9 +201,9 @@ function _matmatmul!(α::Number, A::DMatrix, B::AbstractMatrix, β::Number, C::D
 
     # Multiply on each tile of A
     if tA == 'N'
-        R = Array(Future, size(procs(A))..., size(procs(C), 2))
+        R = Array{Future}(size(procs(A))..., size(procs(C), 2))
     else
-        R = Array(Future, reverse(size(procs(A)))..., size(procs(C), 2))
+        R = Array{Future}(reverse(size(procs(A)))..., size(procs(C), 2))
     end
     for j = 1:size(A.pids, Ad2)
         for k = 1:size(C.pids, 2)
@@ -258,12 +258,12 @@ _matmul_op = (t,s) -> t*s + t*s
 
 function (*)(A::DMatrix, x::AbstractVector)
     T = Base.promote_op(_matmul_op, eltype(A), eltype(x))
-    y = DArray(I -> Array(T, map(length, I)), (size(A, 1),), procs(A)[:,1], (size(procs(A), 1),))
+    y = DArray(I -> Array{T}(map(length, I)), (size(A, 1),), procs(A)[:,1], (size(procs(A), 1),))
     return A_mul_B!(one(T), A, x, zero(T), y)
 end
 function (*)(A::DMatrix, B::AbstractMatrix)
     T = Base.promote_op(_matmul_op, eltype(A), eltype(B))
-    C = DArray(I -> Array(T, map(length, I)),
+    C = DArray(I -> Array{T}(map(length, I)),
             (size(A, 1), size(B, 2)),
             procs(A)[:,1:min(size(procs(A), 2), size(procs(B), 2))],
             (size(procs(A), 1), min(size(procs(A), 2), size(procs(B), 2))))
@@ -272,15 +272,15 @@ end
 
 function Ac_mul_B(A::DMatrix, x::AbstractVector)
     T = Base.promote_op(_matmul_op, eltype(A), eltype(x))
-    y = DArray(I -> Array(T, map(length, I)),
+    y = DArray(I -> Array{T}(map(length, I)),
             (size(A, 2),),
             procs(A)[1,:],
             (size(procs(A), 2),))
     return Ac_mul_B!(one(T), A, x, zero(T), y)
 end
 function Ac_mul_B(A::DMatrix, B::AbstractMatrix)
     T = Base.promote_op(_matmul_op, eltype(A), eltype(B))
-    C = DArray(I -> Array(T, map(length, I)), (size(A, 2),
+    C = DArray(I -> Array{T}(map(length, I)), (size(A, 2),
         size(B, 2)),
         procs(A)[1:min(size(procs(A), 1), size(procs(B), 2)),:],
         (size(procs(A), 2), min(size(procs(A), 1), size(procs(B), 2))))

src/mapreduce.jl

@@ -9,7 +9,7 @@ Base.map!{F}(f::F, dest::DArray, src::DArray) = begin
     return dest
 end
 
-Base.Broadcast.containertype{D<:DArray}(::Type{D}) = DArray
+Base.Broadcast._containertype{D<:DArray}(::Type{D}) = DArray
 
 Base.Broadcast.promote_containertype(::Type{DArray}, ::Type{DArray}) = DArray
 Base.Broadcast.promote_containertype(::Type{DArray}, ::Type{Array})  = DArray
@@ -131,7 +131,7 @@ Base.mapreducedim(f, op, R::DArray, A::DArray) = begin
 end
 
 function nnz(A::DArray)
-    B = Array(Any, size(A.pids))
+    B = Array{Any}(size(A.pids))
     @sync begin
         for i in eachindex(A.pids)
             @async B[i...] = remotecall_fetch(x -> nnz(localpart(x)), A.pids[i...], A)
@@ -301,7 +301,7 @@ function _ppeval(f, A...; dim = map(ndims, A))
     push!(ridx, 1)
     Rsize = map(last, ridx)
     Rsize[end] = dimlength
-    R = Array(eltype(R1), Rsize...)
+    R = Array{eltype(R1)}(Rsize...)
 
     for i = 1:dimlength
         for j = 1:narg

src/sort.jl

@@ -38,7 +38,7 @@ function scatter_n_sort_localparts{T}(d, myidx, refs::Array{RemoteChannel}, boun
         end
 
         if p_till == p_sorted
-            @async put!(r, Array(T,0))
+            @async put!(r, Array{T}(0))
         else
             v = sorted[p_sorted:p_till-1]
             @async put!(r, v)
@@ -66,7 +66,7 @@ function compute_boundaries{T}(d::DVector{T}; kwargs...)
 
     results = asyncmap(p -> remotecall_fetch(sample_n_setup_ref, p, d, sample_sz_on_wrkr; kwargs...), pids)
 
-    samples = Array(T,0)
+    samples = Array{T}(0)
     for x in results
         append!(samples, x[1])
     end
@@ -128,7 +128,7 @@ function Base.sort{T}(d::DVector{T}; sample=true, kwargs...)
 
         @assert lb<=ub
 
-        s = Array(T, np)
+        s = Array{T}(np)
         part = abs(ub - lb)/np
         (isnan(part) || isinf(part)) && throw(ArgumentError("lower and upper bounds must not be infinities"))
 
@@ -155,7 +155,7 @@ function Base.sort{T}(d::DVector{T}; sample=true, kwargs...)
         throw(ArgumentError("keyword arg `sample` must be Boolean, Tuple(Min,Max) or an actual sample of data : " * string(sample)))
     end
 
-    local_sort_results = Array(Tuple, np)
+    local_sort_results = Array{Tuple}(np)
 
     Base.asyncmap!((i,p) -> remotecall_fetch(
             scatter_n_sort_localparts, p, presorted ? nothing : d, i, refs, boundaries; kwargs...),

test/darray.jl

@@ -343,7 +343,7 @@ end
 check_leaks(t)
 
 t=@testset "test max / min / sum" begin
-    a = map(x -> Int(round(rand() * 100)) - 50, Array(Int, 100,1000))
+    a = map(x -> Int(round(rand() * 100)) - 50, Array{Int}(100,1000))
     d = distribute(a)
 
     @test sum(d)          == sum(a)
@@ -359,7 +359,7 @@ end
 check_leaks(t)
 
 t=@testset "test all / any" begin
-    a = map(x->Int(round(rand() * 100)) - 50, Array(Int, 100,1000))
+    a = map(x->Int(round(rand() * 100)) - 50, Array{Int}(100,1000))
     a = [true for i in 1:100]
     d = distribute(a)
 
@@ -752,9 +752,9 @@ t=@testset "test scalar ops" begin
         @test @eval ($f)($a, $a) == ($f)($b, $b)
     end
 
-    @testset "$f" for f in (rem,)
+    @testset "$f" for f in (:rem,)
         x = rand()
-        @test f(a, x) == f(b, x)
+        @test @eval ($f).($a, $x) == ($f).($b, $x)
     end
     close(a)
     close(c)