Further reduce imports.

Author: maleadt

src/GPUArrays.jl

@@ -13,7 +13,6 @@ using LinearAlgebra.BLAS
 using Base.Cartesian
 
 using FFTW
-import FFTW: *, plan_ifft!, plan_fft!, plan_fft, plan_ifft, size, plan_bfft, plan_bfft!
 
 include("abstractarray.jl")
 include("abstract_gpu_interface.jl")

src/abstractarray.jl

@@ -1,5 +1,3 @@
-import Base: similar, convert, _reshape, map!, copyto!, map, copy, deepcopy
-
 # Dense GPU Array
 abstract type GPUArray{T, N} <: DenseArray{T, N} end
 
@@ -172,8 +170,8 @@ function Base.copyto!(
     dest
 end
 
-copy(x::GPUArray) = identity.(x)
-deepcopy(x::GPUArray) = copy(x)
+Base.copy(x::GPUArray) = identity.(x)
+Base.deepcopy(x::GPUArray) = copy(x)
 
 #=
 reinterpret taken from julia base/array.jl
@@ -222,13 +220,13 @@ function reinterpret(::Type{T}, a::GPUArray{S}, dims::NTuple{N, Integer}) where
     unsafe_reinterpret(T, a, dims)
 end
 
-function _reshape(A::GPUArray{T}, dims::Dims) where T
+function Base._reshape(A::GPUArray{T}, dims::Dims) where T
     n = length(A)
     prod(dims) == n || throw(DimensionMismatch("parent has $n elements, which is incompatible with size $dims"))
     return unsafe_reinterpret(T, A, dims)
 end
 #ambig
-function _reshape(A::GPUArray{T, 1}, dims::Tuple{Integer}) where T
+function Base._reshape(A::GPUArray{T, 1}, dims::Tuple{Integer}) where T
     n = Base._length(A)
     prod(dims) == n || throw(DimensionMismatch("parent has $n elements, which is incompatible with size $dims"))
     return unsafe_reinterpret(T, A, dims)

src/array.jl

@@ -120,7 +120,6 @@ function AbstractDeviceArray(ptr::Array, shape::Vararg{Integer, N}) where N
     reshape(ptr, shape)
 end
 
-
 function _gpu_call(f, A::JLArray, args::Tuple, blocks_threads::Tuple{T, T}) where T <: NTuple{N, Integer} where N
     blocks, threads = blocks_threads
     idx = ntuple(i-> 1, length(blocks))
@@ -170,32 +169,21 @@ end
 blas_module(::JLArray) = LinearAlgebra.BLAS
 blasbuffer(A::JLArray) = A.data
 
-# defining our own plan type is the easiest way to pass around the plans in Base interface
+# defining our own plan type is the easiest way to pass around the plans in FFTW interface
 # without ambiguities
 
 struct FFTPlan{T}
     p::T
 end
-function plan_fft(A::JLArray; kw_args...)
-    FFTPlan(plan_fft(A.data; kw_args...))
-end
-function plan_fft!(A::JLArray; kw_args...)
-    FFTPlan(plan_fft!(A.data; kw_args...))
-end
-function plan_bfft!(A::JLArray; kw_args...)
-    FFTPlan(plan_bfft!(A.data; kw_args...))
-end
-function plan_bfft(A::JLArray; kw_args...)
-    FFTPlan(plan_bfft(A.data; kw_args...))
-end
-function plan_ifft!(A::JLArray; kw_args...)
-    FFTPlan(plan_ifft!(A.data; kw_args...))
-end
-function plan_ifft(A::JLArray; kw_args...)
-    FFTPlan(plan_ifft(A.data; kw_args...))
-end
 
-function *(plan::FFTPlan, A::JLArray)
+FFTW.plan_fft(A::JLArray; kw_args...) = FFTPlan(plan_fft(A.data; kw_args...))
+FFTW.plan_fft!(A::JLArray; kw_args...) = FFTPlan(plan_fft!(A.data; kw_args...))
+FFTW.plan_bfft!(A::JLArray; kw_args...) = FFTPlan(plan_bfft!(A.data; kw_args...))
+FFTW.plan_bfft(A::JLArray; kw_args...) = FFTPlan(plan_bfft(A.data; kw_args...))
+FFTW.plan_ifft!(A::JLArray; kw_args...) = FFTPlan(plan_ifft!(A.data; kw_args...))
+FFTW.plan_ifft(A::JLArray; kw_args...) = FFTPlan(plan_ifft(A.data; kw_args...))
+
+function Base.:(*)(plan::FFTPlan, A::JLArray)
     x = plan.p * A.data
     JLArray(x)
 end

src/base.jl

@@ -1,10 +1,10 @@
 allequal(x) = true
 allequal(x, y, z...) = x == y && allequal(y, z...)
-function map!(f, y::GPUArray, xs::GPUArray...)
+function Base.map!(f, y::GPUArray, xs::GPUArray...)
     @assert allequal(size.((y, xs...))...)
     return y .= f.(xs...)
 end
-function map(f, y::GPUArray, xs::GPUArray...)
+function Base.map(f, y::GPUArray, xs::GPUArray...)
     @assert allequal(size.((y, xs...))...)
     return f.(y, xs...)
 end

src/construction.jl

@@ -1,16 +1,12 @@
-import Base: fill!, zeros, ones, fill
-
-
-
-function fill(X::Type{<: GPUArray}, val::T, dims::NTuple{N, Integer}) where {T, N}
+function Base.fill(X::Type{<: GPUArray}, val::T, dims::NTuple{N, Integer}) where {T, N}
     res = similar(X, T, dims)
     fill!(res, val)
 end
-function fill(X::Type{<: GPUArray{T}}, val, dims::NTuple{N, Integer}) where {T, N}
+function Base.fill(X::Type{<: GPUArray{T}}, val, dims::NTuple{N, Integer}) where {T, N}
     res = similar(X, T, dims)
     fill!(res, convert(T, val))
 end
-function fill!(A::GPUArray{T}, x) where T
+function Base.fill!(A::GPUArray{T}, x) where T
     gpu_call(A, (A, convert(T, x))) do state, a, val
         idx = @linearidx(a, state)
         @inbounds a[idx] = val
@@ -19,8 +15,8 @@ function fill!(A::GPUArray{T}, x) where T
     A
 end
 
-zeros(T::Type{<: GPUArray}, dims::NTuple{N, Integer}) where N = fill(T, zero(eltype(T)), dims)
-ones(T::Type{<: GPUArray}, dims::NTuple{N, Integer}) where N = fill(T, one(eltype(T)), dims)
+Base.zeros(T::Type{<: GPUArray}, dims::NTuple{N, Integer}) where N = fill(T, zero(eltype(T)), dims)
+Base.ones(T::Type{<: GPUArray}, dims::NTuple{N, Integer}) where N = fill(T, one(eltype(T)), dims)
 
 function uniformscaling_kernel(state, res::AbstractArray{T}, stride, s::UniformScaling) where T
     i = linear_index(state)

src/linalg.jl

@@ -90,9 +90,9 @@ function LinearAlgebra.permutedims!(dest::GPUArray, src::GPUArray, perm::NTuple{
 end
 
 
-function copyto!(A::AbstractArray, B::Adjoint{T, <: GPUArray}) where T
+function Base.copyto!(A::AbstractArray, B::Adjoint{T, <: GPUArray}) where T
     copyto!(A, Adjoint(Array(B.parent)))
 end
-function copyto!(A::GPUArray, B::Adjoint{T, <: GPUArray}) where T
+function Base.copyto!(A::GPUArray, B::Adjoint{T, <: GPUArray}) where T
     transpose!(A, B.parent)
 end