Simplify array constructors.

Author: maleadt

src/construction.jl

@@ -1,9 +1,9 @@
 function Base.fill(X::Type{<: GPUArray}, val::T, dims::NTuple{N, Integer}) where {T, N}
-    res = similar(X, T, dims)
+    res = similar(X{T}, dims)
     fill!(res, val)
 end
 function Base.fill(X::Type{<: GPUArray{T}}, val, dims::NTuple{N, Integer}) where {T, N}
-    res = similar(X, T, dims)
+    res = similar(X, dims)
     fill!(res, convert(T, val))
 end
 function Base.fill!(A::GPUArray{T}, x) where T
@@ -33,17 +33,6 @@ function (T::Type{<: GPUArray})(s::UniformScaling, dims::Dims{2})
 end
 (T::Type{<: GPUArray})(s::UniformScaling, m::Integer, n::Integer) = T(s, Dims((m, n)))
 
-(T::Type{<: GPUArray})(x) = convert(T, x)
-(T::Type{<: GPUArray})(dims::Integer...) = T(dims)
-(T::Type{<: GPUArray})(dims::NTuple{N, Base.OneTo{Int}}) where N = T(undef, length.(dims))
-(T::Type{<: GPUArray{X} where X})(dims::NTuple{N, Integer}) where N = similar(T, eltype(T), dims)
-(T::Type{<: GPUArray{X} where X})(::UndefInitializer, dims::NTuple{N, Integer}) where N = similar(T, eltype(T), dims)
-
-Base.similar(x::X, ::Type{T}, size::Base.Dims{N}) where {X <: GPUArray, T, N} = similar(X, T, size)
-Base.similar(::Type{X}, ::Type{T}, size::NTuple{N, Base.OneTo{Int}}) where {X <: GPUArray, T, N} = similar(X, T, length.(size))
-
-Base.convert(AT::Type{<: GPUArray{T, N}}, A::GPUArray{T, N}) where {T, N} = A
-
 function indexstyle(x::T) where T
     style = try
         Base.IndexStyle(x)
@@ -84,15 +73,15 @@ function Base.convert(AT::Type{<: GPUArray}, iter)
 end
 
 function Base.convert(AT::Type{<: GPUArray{T, N}}, A::DenseArray{T, N}) where {T, N}
-    copyto!(AT(Base.size(A)), A)
+    copyto!(AT(undef, size(A)), A)
 end
 
 function Base.convert(AT::Type{<: GPUArray{T1}}, A::DenseArray{T2, N}) where {T1, T2, N}
-    copyto!(similar(AT, T1, size(A)), convert(Array{T1, N}, A))
+    copyto!(similar(AT{T1}, size(A)), convert(Array{T1, N}, A))
 end
 
 function Base.convert(AT::Type{<: GPUArray}, A::DenseArray{T2, N}) where {T2, N}
-    copyto!(similar(AT, T2, size(A)), A)
+    copyto!(similar(AT{T2}, size(A)), A)
 end
 
 function Base.convert(AT::Type{Array{T, N}}, A::GPUArray{CT, CN}) where {T, N, CT, CN}

src/random.jl

@@ -51,21 +51,16 @@ end
 
 struct RNG <: AbstractRNG
     state::GPUArray{NTuple{4,UInt32},1}
-
-    function RNG(A::GPUArray)
-        dev = GPUArrays.device(A)
-        N = GPUArrays.threads(dev)
-        state = similar(A, NTuple{4, UInt32}, N)
-        copyto!(state, [ntuple(i-> rand(UInt32), 4) for i=1:N])
-        new(state)
-    end
 end
 
 const GLOBAL_RNGS = Dict()
 function global_rng(A::GPUArray)
     dev = GPUArrays.device(A)
     get!(GLOBAL_RNGS, dev) do
-        RNG(A)
+        N = GPUArrays.threads(dev)
+        state = similar(A, NTuple{4, UInt32}, N)
+        copyto!(state, [ntuple(i-> rand(UInt32), 4) for i=1:N])
+        RNG(state)
     end
 end
 

src/testsuite/construction.jl

@@ -10,22 +10,22 @@ end
 function constructors(AT)
     @testset "constructors + similar" begin
         for T in supported_eltypes()
-            B = AT{T}(10)
+            B = AT{T}(undef, 10)
             @test B isa AT{T,1}
             @test size(B) == (10,)
             @test eltype(B) == T
 
-            B = AT{T}(10, 10)
+            B = AT{T}(undef, 10, 10)
             @test B isa AT{T,2}
             @test size(B) == (10, 10)
             @test eltype(B) == T
 
-            B = AT{T}((10, 10))
+            B = AT{T}(undef, (10, 10))
             @test B isa AT{T,2}
             @test size(B) == (10, 10)
             @test eltype(B) == T
 
-            B = similar(B, Int32, (11, 15))
+            B = similar(B, Int32, 11, 15)
             @test B isa AT{Int32,2}
             @test size(B) == (11, 15)
             @test eltype(B) == Int32
@@ -50,11 +50,6 @@ function constructors(AT)
             @test size(B) == (11, 15)
             @test eltype(B) == Int32
 
-            B = similar(AT{Int32, 2}, T, (11, 15))
-            @test B isa AT{T,2}
-            @test size(B) == (11, 15)
-            @test eltype(B) == T
-
             B = similar(AT{T}, (5,))
             @test B isa AT{T,1}
             @test size(B) == (5,)
@@ -127,7 +122,7 @@ function value_constructor(AT)
             @test Array(x3) ≈ x
 
             fill!(x1, 2f0)
-            x2 = fill!(AT{Int32}((4, 4, 4)), 77f0)
+            x2 = fill!(AT{Int32}(undef, (4, 4, 4)), 77f0)
             @test all(x-> x == 2f0, Array(x1))
             @test all(x-> x == Int32(77), Array(x2))
 
@@ -152,7 +147,7 @@ function iterator_constructors(AT)
                 x = AT{Float32}(Fill(T(0), (10, 10)))
                 @test eltype(x) == Float32
                 @test AT(Eye{T}((10))) == AT{T}(I, 10, 10)
-                x = AT{Float32}(Eye{T}((10)))
+                x = AT{Float32}(Eye{T}(10))
                 @test eltype(x) == Float32
             end
         end

src/testsuite/indexing.jl

@@ -13,7 +13,7 @@ function test_indexing(AT)
             end
             @testset "multi dim, sliced setindex" begin
                 x = fill(AT{T}, T(0), (10, 10, 10, 10))
-                y = AT{T}(5, 5, 10, 10)
+                y = AT{T}(undef, 5, 5, 10, 10)
                 rand!(y)
                 x[2:6, 2:6, :, :] = y
                 x[2:6, 2:6, :, :] == y

src/testsuite/random.jl

@@ -2,7 +2,7 @@ function test_random(AT)
     @testset "Random" begin
         @testset "rand" begin  # uniform
             for T in (Float32, Float64, Int64, Int32), d in (2, (2,2))
-                A = AT{T}(d)
+                A = AT{T}(undef, d)
                 B = copy(A)
                 rand!(A)
                 rand!(B)