Skip to content

Commit

Permalink
Merge pull request JuliaLang#15367 from JuliaLang/teh/less_striding
Browse files Browse the repository at this point in the history 
StridedArray->AbstractArray in many places
  • Loading branch information
@timholy
timholy committed Mar 8, 2016
2 parents 7c4e25b + 1982118 commit dc0a038
Show file tree
Hide file tree
Showing 16 changed files with 164 additions and 151 deletions.
12 changes: 12 additions & 0 deletions base/abstractarraymath.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -163,6 +163,18 @@ function cumsum_kbn{T<:AbstractFloat}(A::AbstractArray{T}, axis::Integer=1)
return B + C
end

## Permute array dims ##

function permutedims(B::AbstractArray, perm)
dimsB = size(B)
ndimsB = length(dimsB)
(ndimsB == length(perm) && isperm(perm)) || throw(ArgumentError("no valid permutation of dimensions"))
dimsP = ntuple(i->dimsB[perm[i]], ndimsB)::typeof(dimsB)
P = similar(B, dimsP)
permutedims!(P, B, perm)
end


## ipermutedims in terms of permutedims ##

function ipermutedims(A::AbstractArray,perm)
Expand Down
9 changes: 3 additions & 6 deletions base/array.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -582,7 +582,6 @@ function lexcmp(a::Array{UInt8,1}, b::Array{UInt8,1})
c < 0 ? -1 : c > 0 ? +1 : cmp(length(a),length(b))
end

# note: probably should be StridedVector or AbstractVector
function reverse(A::AbstractVector, s=1, n=length(A))
B = similar(A)
for i = 1:s-1
Expand All @@ -598,9 +597,7 @@ function reverse(A::AbstractVector, s=1, n=length(A))
end
reverseind(a::AbstractVector, i::Integer) = length(a) + 1 - i

reverse(v::StridedVector) = (n=length(v); [ v[n-i+1] for i=1:n ])
reverse(v::StridedVector, s, n=length(v)) = reverse!(copy(v), s, n)
function reverse!(v::StridedVector, s=1, n=length(v))
function reverse!(v::AbstractVector, s=1, n=length(v))
if n <= s # empty case; ok
elseif !(1 ≤ s ≤ endof(v))
throw(BoundsError(v, s))
Expand Down Expand Up @@ -724,7 +721,7 @@ function find(testf::Function, A::AbstractArray)
I
end

function find(A::StridedArray)
function find(A::AbstractArray)
nnzA = countnz(A)
I = similar(A, Int, nnzA)
count = 1
Expand All @@ -742,7 +739,7 @@ find(testf::Function, x::Number) = !testf(x) ? Array(Int,0) : [1]

findn(A::AbstractVector) = find(A)

function findn(A::StridedMatrix)
function findn(A::AbstractMatrix)
nnzA = countnz(A)
I = similar(A, Int, nnzA)
J = similar(A, Int, nnzA)
Expand Down
119 changes: 23 additions & 96 deletions base/arraymath.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,7 +11,7 @@ end

for f in (:-, :~, :conj, :sign)
@eval begin
function ($f)(A::StridedArray)
function ($f)(A::AbstractArray)
F = similar(A)
for i in eachindex(A)
F[i] = ($f)(A[i])
Expand All @@ -21,14 +21,12 @@ for f in (:-, :~, :conj, :sign)
end
end

(-)(A::StridedArray{Bool}) = reshape([ -A[i] for i in eachindex(A) ], size(A))
(-)(A::AbstractArray{Bool}) = reshape([ -A[i] for i in eachindex(A) ], size(A))

real(A::StridedArray) = reshape([ real(x) for x in A ], size(A))
imag(A::StridedArray) = reshape([ imag(x) for x in A ], size(A))
real{T<:Real}(x::StridedArray{T}) = x
imag{T<:Real}(x::StridedArray{T}) = zero(x)
real(A::AbstractArray) = reshape([ real(x) for x in A ], size(A))
imag(A::AbstractArray) = reshape([ imag(x) for x in A ], size(A))

function !(A::StridedArray{Bool})
function !(A::AbstractArray{Bool})
F = similar(A)
for i in eachindex(A)
F[i] = !A[i]
Expand All @@ -42,6 +40,7 @@ promote_array_type{Scalar, Arry}(F, ::Type{Scalar}, ::Type{Arry}) = promote_op(F
promote_array_type{S<:Real, A<:AbstractFloat}(F, ::Type{S}, ::Type{A}) = A
promote_array_type{S<:Integer, A<:Integer}(F, ::Type{S}, ::Type{A}) = A
promote_array_type{S<:Integer}(F, ::Type{S}, ::Type{Bool}) = S
promote_array_type(F, ::Type{Bool}, ::Type{Bool}) = promote_op(F, Bool, Bool)

# Handle operations that return different types
./(x::Number, Y::AbstractArray) =
Expand Down Expand Up @@ -142,39 +141,9 @@ end
(-)(A::AbstractArray,x::Number) = A .- x
(-)(x::Number,A::AbstractArray) = x .- A

# functions that should give an Int result for Bool arrays
for f in (:.+, :.-)
@eval begin
function ($f)(A::Bool, B::StridedArray{Bool})
F = similar(B, Int, size(B))
for i in eachindex(B)
@inbounds F[i] = ($f)(A, B[i])
end
return F
end
function ($f)(A::StridedArray{Bool}, B::Bool)
F = similar(A, Int, size(A))
for i in eachindex(A)
@inbounds F[i] = ($f)(A[i], B)
end
return F
end
end
end
for f in (:+, :-)
@eval begin
function ($f)(A::StridedArray{Bool}, B::StridedArray{Bool})
F = similar(A, Int, promote_shape(size(A), size(B)))
for i in eachindex(A,B)
@inbounds F[i] = ($f)(A[i], B[i])
end
return F
end
end
end

## data movement ##

# TODO?: replace with slice?
function slicedim(A::Array, d::Integer, i::Integer)
if d < 1
throw(ArgumentError("dimension must be ≥ 1"))
Expand Down Expand Up @@ -272,23 +241,23 @@ function flipdim{T}(A::Array{T}, d::Integer)
return B
end

function rotl90(A::StridedMatrix)
function rotl90(A::AbstractMatrix)
m,n = size(A)
B = similar(A,(n,m))
for i=1:m, j=1:n
B[n-j+1,i] = A[i,j]
end
return B
end
function rotr90(A::StridedMatrix)
function rotr90(A::AbstractMatrix)
m,n = size(A)
B = similar(A,(n,m))
for i=1:m, j=1:n
B[j,m-i+1] = A[i,j]
end
return B
end
function rot180(A::StridedMatrix)
function rot180(A::AbstractMatrix)
m,n = size(A)
B = similar(A)
for i=1:m, j=1:n
Expand All @@ -308,7 +277,7 @@ rot180(A::AbstractMatrix, k::Integer) = mod(k, 2) == 1 ? rot180(A) : copy(A)

## Transpose ##
const transposebaselength=64
function transpose!(B::StridedMatrix,A::StridedMatrix)
function transpose!(B::AbstractMatrix,A::AbstractMatrix)
m, n = size(A)
size(B,1) == n && size(B,2) == m || throw(DimensionMismatch("transpose"))

Expand All @@ -325,15 +294,15 @@ function transpose!(B::StridedMatrix,A::StridedMatrix)
end
return B
end
function transpose!(B::StridedVector, A::StridedMatrix)
function transpose!(B::AbstractVector, A::AbstractMatrix)
length(B) == length(A) && size(A,1) == 1 || throw(DimensionMismatch("transpose"))
copy!(B, A)
end
function transpose!(B::StridedMatrix, A::StridedVector)
function transpose!(B::AbstractMatrix, A::AbstractVector)
length(B) == length(A) && size(B,1) == 1 || throw(DimensionMismatch("transpose"))
copy!(B, A)
end
function transposeblock!(B::StridedMatrix,A::StridedMatrix,m::Int,n::Int,offseti::Int,offsetj::Int)
function transposeblock!(B::AbstractMatrix,A::AbstractMatrix,m::Int,n::Int,offseti::Int,offsetj::Int)
if m*n<=transposebaselength
@inbounds begin
for j = offsetj+(1:n)
Expand All @@ -353,7 +322,7 @@ function transposeblock!(B::StridedMatrix,A::StridedMatrix,m::Int,n::Int,offseti
end
return B
end
function ctranspose!(B::StridedMatrix,A::StridedMatrix)
function ctranspose!(B::AbstractMatrix,A::AbstractMatrix)
m, n = size(A)
size(B,1) == n && size(B,2) == m || throw(DimensionMismatch("transpose"))

Expand All @@ -370,15 +339,15 @@ function ctranspose!(B::StridedMatrix,A::StridedMatrix)
end
return B
end
function ctranspose!(B::StridedVector, A::StridedMatrix)
function ctranspose!(B::AbstractVector, A::AbstractMatrix)
length(B) == length(A) && size(A,1) == 1 || throw(DimensionMismatch("transpose"))
ccopy!(B, A)
end
function ctranspose!(B::StridedMatrix, A::StridedVector)
function ctranspose!(B::AbstractMatrix, A::AbstractVector)
length(B) == length(A) && size(B,1) == 1 || throw(DimensionMismatch("transpose"))
ccopy!(B, A)
end
function ctransposeblock!(B::StridedMatrix,A::StridedMatrix,m::Int,n::Int,offseti::Int,offsetj::Int)
function ctransposeblock!(B::AbstractMatrix,A::AbstractMatrix,m::Int,n::Int,offseti::Int,offsetj::Int)
if m*n<=transposebaselength
@inbounds begin
for j = offsetj+(1:n)
Expand All @@ -404,18 +373,18 @@ function ccopy!(B, A)
end
end

function transpose(A::StridedMatrix)
function transpose(A::AbstractMatrix)
B = similar(A, size(A, 2), size(A, 1))
transpose!(B, A)
end
function ctranspose(A::StridedMatrix)
function ctranspose(A::AbstractMatrix)
B = similar(A, size(A, 2), size(A, 1))
ctranspose!(B, A)
end
ctranspose{T<:Real}(A::StridedVecOrMat{T}) = transpose(A)
ctranspose{T<:Real}(A::AbstractVecOrMat{T}) = transpose(A)

transpose(x::StridedVector) = [ transpose(x[j]) for i=1, j=1:size(x,1) ]
ctranspose{T}(x::StridedVector{T}) = T[ ctranspose(x[j]) for i=1, j=1:size(x,1) ]
transpose(x::AbstractVector) = [ transpose(x[j]) for i=1, j=1:size(x,1) ]
ctranspose{T}(x::AbstractVector{T}) = T[ ctranspose(x[j]) for i=1, j=1:size(x,1) ]

_cumsum_type{T<:Number}(v::AbstractArray{T}) = typeof(+zero(T))
_cumsum_type(v) = typeof(v[1]+v[1])
Expand Down Expand Up @@ -452,45 +421,3 @@ for (f, f!, fp, op) = ((:cumsum, :cumsum!, :cumsum_pairwise!, :+),
return ($f!)(c, v)
end
end

for (f, op) = ((:cummin, :min), (:cummax, :max))
@eval function ($f)(v::AbstractVector)
n = length(v)
cur_val = v[1]
res = similar(v, n)
res[1] = cur_val
for i in 2:n
cur_val = ($op)(v[i], cur_val)
res[i] = cur_val
end
return res
end

@eval function ($f)(A::StridedArray, axis::Integer)
dimsA = size(A)
ndimsA = ndims(A)
axis_size = dimsA[axis]
axis_stride = 1
for i = 1:(axis-1)
axis_stride *= size(A,i)
end

if axis_size < 1
return A
end

B = similar(A)

for i = 1:length(A)
if div(i-1, axis_stride) % axis_size == 0
B[i] = A[i]
else
B[i] = ($op)(A[i], B[i-axis_stride])
end
end

return B
end

@eval ($f)(A::AbstractArray) = ($f)(A, 1)
end
12 changes: 0 additions & 12 deletions base/bitarray.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1641,18 +1641,6 @@ end

ctranspose(B::BitArray) = transpose(B)

## Permute array dims ##

function permutedims(B::Union{BitArray,StridedArray}, perm)
dimsB = size(B)
ndimsB = length(dimsB)
(ndimsB == length(perm) && isperm(perm)) || throw(ArgumentError("no valid permutation of dimensions"))
dimsP = ntuple(i->dimsB[perm[i]], ndimsB)::typeof(dimsB)
P = similar(B, dimsP)
permutedims!(P, B, perm)
end


## Concatenation ##

function hcat(B::BitVector...)
Expand Down
4 changes: 0 additions & 4 deletions base/coreimg.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,10 +47,6 @@ const checked_sub = -

# core array operations
include("abstractarray.jl")
typealias StridedArray{T,N,A<:DenseArray,I<:Tuple{Vararg{RangeIndex}}} DenseArray{T,N}
typealias StridedVector{T,A<:DenseArray,I<:Tuple{Vararg{RangeIndex}}} DenseArray{T,1}
typealias StridedMatrix{T,A<:DenseArray,I<:Tuple{Vararg{RangeIndex}}} DenseArray{T,2}
typealias StridedVecOrMat{T} Union{StridedVector{T}, StridedMatrix{T}}
include("array.jl")

#TODO: eliminate Dict from inference
Expand Down
Loading

0 comments on commit dc0a038

Please sign in to comment.