Fix more deprecations.

Author: traktofon

src/linalg.jl

@@ -25,7 +25,7 @@ function axpy!(α, x::DArray, y::DArray)
     end
     asyncmap(procs(y)) do p
         @async remotecall_fetch(p) do
-            Base.axpy!(α, localpart(x), localpart(y))
+            axpy!(α, localpart(x), localpart(y))
             return nothing
         end
     end
@@ -192,7 +192,7 @@ end
 function _matmatmul!(α::Number, A::DMatrix, B::AbstractMatrix, β::Number, C::DMatrix, tA)
     # error checks
     Ad1, Ad2 = (tA == 'N') ? (1,2) : (2,1)
-    mA, nA = size(A, Ad1, Ad2)
+    mA, nA = (size(A, Ad1), size(A, Ad2))
     mB, nB = size(B)
     if mB != nA
         throw(DimensionMismatch("matrix A has dimensions ($mA, $nA), matrix B has dimensions ($mB, $nB)"))
@@ -263,12 +263,12 @@ _matmul_op = (t,s) -> t*s + t*s
 
 function Base.:*(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}(undef, 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 Base.:*(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}(undef, 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))))
@@ -277,15 +277,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}(undef, 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}(undef, 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

@@ -1,6 +1,7 @@
 ## higher-order functions ##
 
 import Base: +, -, div, mod, rem, &, |, xor
+import SparseArrays: nnz
 
 Base.map(f, d0::DArray, ds::AbstractArray...) = broadcast(f, d0, ds...)
 
@@ -21,7 +22,7 @@ Base.BroadcastStyle(::Type{<:DArray}, ::Any) = Broadcast.ArrayStyle{DArray}()
 
 function Base.similar(bc::Broadcast.Broadcasted{Broadcast.ArrayStyle{DArray}}, ::Type{ElType}) where {ElType}
    DA = find_darray(bc)
-   similar(DA, ElType)
+   DArray(I -> Array{ElType}(undef, map(length,I)), DA)
 end
 
 "`DA = find_darray(As)` returns the first DArray among the arguments."
@@ -201,18 +202,21 @@ for f in (:+, :-, :div, :mod, :rem, :&, :|, :xor)
     end
 end
 
-function mapslices(f::Function, D::DArray{T,N,A}, dims::AbstractVector) where {T,N,A}
+function Base.mapslices(f, D::DArray{T,N,A}; dims) where {T,N,A}
+    if !(dims isa AbstractVector)
+        dims = [dims...]
+    end
     if !all(t -> t == 1, size(D.indices)[dims])
         p = ones(Int, ndims(D))
         nondims = filter(t -> !(t in dims), 1:ndims(D))
         p[nondims] = defaultdist([size(D)...][[nondims...]], procs(D))
         DD = DArray(size(D), procs(D), p) do I
             return convert(A, D[I...])
         end
-        return mapslices(f, DD, dims)
+        return mapslices(f, DD, dims=dims)
     end
 
-    refs = Future[remotecall((x,y,z)->mapslices(x,localpart(y),z), p, f, D, dims) for p in procs(D)]
+    refs = Future[remotecall((x,y,z)->mapslices(x,localpart(y),dims=z), p, f, D, dims) for p in procs(D)]
 
     DArray(reshape(refs, size(procs(D))))
 end
@@ -246,7 +250,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)}(undef, Rsize...)
 
     for i = 1:dimlength
         for j = 1:narg
@@ -273,7 +277,7 @@ Evaluates the callable argument `f` on slices of the elements of the `D` tuple.
 `f` can be any callable object that accepts sliced or broadcasted elements of `D`.
 The result returned from `f` must be either an array or a scalar.
 
-`D` has any number of elements and the alements can have any type. If an element
+`D` has any number of elements and the elements can have any type. If an element
 of `D` is a distributed array along the dimension specified by `dim`. If an
 element of `D` is not distributed, the element is by default broadcasted and
 applied on all evaluations of `f`.
@@ -286,7 +290,7 @@ broadcasted to all evaluations of `f`.
 
 #### Result
 `ppeval` returns a distributed array of dimension `p+1` where the first `p`
-sizes correspond to the sizes of return values of `f`. The last dimention of
+sizes correspond to the sizes of return values of `f`. The last dimension of
 the return array from `ppeval` has the same length as the dimension over which
 the input arrays are sliced.
 

src/sort.jl

@@ -38,7 +38,7 @@ function scatter_n_sort_localparts(d, myidx, refs, boundaries::Array{T}; by = id
         end
 
         if p_till == p_sorted
-            @async put!(r, Array{T}(0))
+            @async put!(r, Array{T}(undef,0))
         else
             v = sorted[p_sorted:p_till-1]
             @async put!(r, v)
@@ -66,7 +66,7 @@ function compute_boundaries(d::DVector{T}; kwargs...) where T
 
     results = asyncmap(p -> remotecall_fetch(sample_n_setup_ref, p, d, sample_sz_on_wrkr; kwargs...), pids)
 
-    samples = Array{T}(undef, 0)
+    samples = Array{T}(undef,0)
     for x in results
         append!(samples, x[1])
     end
@@ -128,7 +128,7 @@ function Base.sort(d::DVector{T}; sample=true, kwargs...) where T
 
         @assert lb<=ub
 
-        s = Array{T}(np)
+        s = Array{T}(undef,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(d::DVector{T}; sample=true, kwargs...) where T
         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}(undef,np)
 
     Base.asyncmap!((i,p) -> remotecall_fetch(
             scatter_n_sort_localparts, p, presorted ? nothing : d, i, refs, boundaries; kwargs...),

test/darray.jl

@@ -1,5 +1,6 @@
 using Test, LinearAlgebra, SpecialFunctions
 using Statistics: mean
+using SparseArrays: nnz
 @everywhere using SparseArrays: sprandn
 
 @testset "test distribute and other constructors" begin
@@ -713,35 +714,35 @@ check_leaks()
 @testset "test mapslices" begin
     A = randn(5,5,5)
     D = distribute(A, procs = workers(), dist = [1, 1, min(nworkers(), 5)])
-    @test mapslices(svdvals, D, (1,2)) ≈ mapslices(svdvals, A, (1,2))
-    @test mapslices(svdvals, D, (1,3)) ≈ mapslices(svdvals, A, (1,3))
-    @test mapslices(svdvals, D, (2,3)) ≈ mapslices(svdvals, A, (2,3))
-    @test mapslices(sort, D, (1,)) ≈ mapslices(sort, A, (1,))
-    @test mapslices(sort, D, (2,)) ≈ mapslices(sort, A, (2,))
-    @test mapslices(sort, D, (3,)) ≈ mapslices(sort, A, (3,))
+    @test mapslices(svdvals, D, dims=(1,2)) ≈ mapslices(svdvals, A, dims=(1,2))
+    @test mapslices(svdvals, D, dims=(1,3)) ≈ mapslices(svdvals, A, dims=(1,3))
+    @test mapslices(svdvals, D, dims=(2,3)) ≈ mapslices(svdvals, A, dims=(2,3))
+    @test mapslices(sort, D, dims=(1,)) ≈ mapslices(sort, A, dims=(1,))
+    @test mapslices(sort, D, dims=(2,)) ≈ mapslices(sort, A, dims=(2,))
+    @test mapslices(sort, D, dims=(3,)) ≈ mapslices(sort, A, dims=(3,))
 
     # issue #3613
-    B = mapslices(sum, dones(Float64, (2,3,4), workers(), [1,1,min(nworkers(),4)]), [1,2])
+    B = mapslices(sum, dones(Float64, (2,3,4), workers(), [1,1,min(nworkers(),4)]), dims=[1,2])
     @test size(B) == (1,1,4)
     @test all(B.==6)
 
     # issue #5141
-    C1 = mapslices(x-> maximum(-x), D, [])
+    C1 = mapslices(x-> maximum(-x), D, dims=[])
     @test C1 == -D
 
     # issue #5177
     c = dones(Float64, (2,3,4,5), workers(), [1,1,1,min(nworkers(),5)])
-    m1 = mapslices(x-> ones(2,3), c, [1,2])
-    m2 = mapslices(x-> ones(2,4), c, [1,3])
-    m3 = mapslices(x-> ones(3,4), c, [2,3])
+    m1 = mapslices(x-> ones(2,3), c, dims=[1,2])
+    m2 = mapslices(x-> ones(2,4), c, dims=[1,3])
+    m3 = mapslices(x-> ones(3,4), c, dims=[2,3])
     @test size(m1) == size(m2) == size(m3) == size(c)
 
-    n1 = mapslices(x-> ones(6), c, [1,2])
-    n2 = mapslices(x-> ones(6), c, [1,3])
-    n3 = mapslices(x-> ones(6), c, [2,3])
-    n1a = mapslices(x-> ones(1,6), c, [1,2])
-    n2a = mapslices(x-> ones(1,6), c, [1,3])
-    n3a = mapslices(x-> ones(1,6), c, [2,3])
+    n1 = mapslices(x-> ones(6), c, dims=[1,2])
+    n2 = mapslices(x-> ones(6), c, dims=[1,3])
+    n3 = mapslices(x-> ones(6), c, dims=[2,3])
+    n1a = mapslices(x-> ones(1,6), c, dims=[1,2])
+    n2a = mapslices(x-> ones(1,6), c, dims=[1,3])
+    n3a = mapslices(x-> ones(1,6), c, dims=[2,3])
     @test (size(n1a) == (1,6,4,5) && size(n2a) == (1,3,6,5) && size(n3a) == (2,1,6,5))
     @test (size(n1) == (6,1,4,5) && size(n2) == (6,3,1,5) && size(n3) == (2,6,1,5))
     close(D)
@@ -757,22 +758,22 @@ check_leaks()
     c = drand(20,20)
     d = convert(Array, c)
 
-    @testset "$f" for f in (:+, :-, :.+, :.-, :.*, :./, :.%)
+    @testset "$f" for f in (:+, :-, :*, :/, :%)
         x = rand()
-        @test @eval ($f)($a, $x) == ($f)($b, $x)
-        @test @eval ($f)($x, $a) == ($f)($x, $b)
-        @test @eval ($f)($a, $c) == ($f)($b, $d)
+        @test @eval ($f).($a, $x) == ($f).($b, $x)
+        @test @eval ($f).($x, $a) == ($f).($x, $b)
+        @test @eval ($f).($a, $c) == ($f).($b, $d)
     end
 
     close(a)
     close(c)
 
     a = dones(Int, 20, 20)
     b = convert(Array, a)
-    @testset "$f" for f in (:.<<, :.>>)
-        @test @eval ($f)($a, 2)  == ($f)($b, 2)
-        @test @eval ($f)(2, $a)  == ($f)(2, $b)
-        @test @eval ($f)($a, $a) == ($f)($b, $b)
+    @testset "$f" for f in (:<<, :>>)
+        @test @eval ($f).($a, 2)  == ($f).($b, 2)
+        @test @eval ($f).(2, $a)  == ($f).(2, $b)
+        @test @eval ($f).($a, $a) == ($f).($b, $b)
     end
 
     @testset "$f" for f in (:rem,)
@@ -792,7 +793,7 @@ check_leaks()
     nrows = 20 * nwrkrs
     ncols = 10 * nwrkrs
     a = drand((nrows,ncols), wrkrs, (1, nwrkrs))
-    m = mean(a, 1)
+    m = mean(a, dims=1)
     c = a .- m
     d = convert(Array, a) .- convert(Array, m)
     @test c == d
@@ -854,7 +855,7 @@ check_leaks()
         R[:, i] = convert(Array, A)[:, :, i]*convert(Array, B)[:, i]
     end
     @test convert(Array, ppeval(*, A, B)) ≈ R
-    @test sum(ppeval(eigvals, A)) ≈ sum(ppeval(eigvals, A, eye(10, 10)))
+    @test sum(ppeval(eigvals, A)) ≈ sum(ppeval(eigvals, A, Matrix{Float64}(I,10,10)))
     close(A)
     close(B)
     d_closeall()  # close the temporaries created above
@@ -887,7 +888,7 @@ end
     d_closeall()  # close the temporaries created above
 end
 
-@testset "sort, T = $T" for i in 0:6, T in [Int, Float64]
+@testset "sort, T = $T, 10^$i elements" for i in 0:6, T in [Int, Float64]
     d = DistributedArrays.drand(T, 10^i)
     @testset "sample = $sample" for sample in Any[true, false, (minimum(d),maximum(d)), rand(T, 10^i>512 ? 512 : 10^i)]
         d2 = DistributedArrays.sort(d; sample=sample)