use memmove in Array grow and delete

this allows them to work on undefined references

allow pointer(a, i) to work on all arrays

Author: JeffBezanson

base/abstractarray.jl

@@ -12,6 +12,7 @@ eltype{T,n}(::AbstractArray{T,n}) = T
 eltype{T,n}(::Type{AbstractArray{T,n}}) = T
 eltype{T<:AbstractArray}(::Type{T}) = eltype(super(T))
 iseltype(x,T) = eltype(x) <: T
+elsize{T}(::AbstractArray{T}) = sizeof(T)
 isinteger(x::AbstractArray) = all(isinteger,x)
 isinteger{T<:Integer,n}(x::AbstractArray{T,n}) = true
 isreal(x::AbstractArray) = all(isreal,x)

base/array.jl

@@ -19,9 +19,8 @@ size(a::Array) = arraysize(a)
 size(a::Array, d) = arraysize(a, d)
 size(a::Matrix) = (arraysize(a,1), arraysize(a,2))
 length(a::Array) = arraylen(a)
-function sizeof{T}(a::Array{T})
-    (isbits(T) ? sizeof(eltype(a)) : sizeof(Ptr)) * length(a)
-end
+elsize{T}(a::Array{T}) = isbits(T) ? sizeof(T) : sizeof(Ptr)
+sizeof(a::Array) = elsize(a) * length(a)
 
 strides{T}(a::Array{T,1}) = (1,)
 strides{T}(a::Array{T,2}) = (1, size(a,1))
@@ -396,17 +395,19 @@ end
 
 function _growat_beg!(a::Vector, i::Integer, delta::Integer)
     ccall(:jl_array_grow_beg, Void, (Any, Uint), a, delta)
-    @inbounds for k = 1:i-1
-        a[k] = a[k+delta]
+    if i > 1
+        ccall(:memmove, Ptr{Void}, (Ptr{Void}, Ptr{Void}, Csize_t),
+              pointer(a, 1), pointer(a, 1+delta), (i-1)*elsize(a))
     end
     return a
 end
 
 function _growat_end!(a::Vector, i::Integer, delta::Integer)
     ccall(:jl_array_grow_end, Void, (Any, Uint), a, delta)
     n = length(a)
-    @inbounds for k = n:-1:(i+delta)
-        a[k] = a[k-delta]
+    if n >= i+delta
+        ccall(:memmove, Ptr{Void}, (Ptr{Void}, Ptr{Void}, Csize_t),
+              pointer(a, i+delta), pointer(a, i), (n-i-delta+1)*elsize(a))
     end
     return a
 end
@@ -425,17 +426,19 @@ function _deleteat!(a::Vector, i::Integer, delta::Integer)
 end
 
 function _deleteat_beg!(a::Vector, i::Integer, delta::Integer)
-    @inbounds for k = i+delta-1:-1:1+delta
-        a[k] = a[k-delta]
+    if i > 1
+        ccall(:memmove, Ptr{Void}, (Ptr{Void}, Ptr{Void}, Csize_t),
+              pointer(a, 1+delta), pointer(a, 1), (i-1)*elsize(a))
     end
     ccall(:jl_array_del_beg, Void, (Any, Uint), a, delta)
     return a
 end
 
 function _deleteat_end!(a::Vector, i::Integer, delta::Integer)
     n = length(a)
-    @inbounds for k = i:n-delta
-        a[k] = a[k+delta]
+    if n >= i+delta
+        ccall(:memmove, Ptr{Void}, (Ptr{Void}, Ptr{Void}, Csize_t),
+              pointer(a, i), pointer(a, i+delta), (n-i-delta+1)*elsize(a))
     end
     ccall(:jl_array_del_end, Void, (Any, Uint), a, delta)
     return a

base/darray.jl

@@ -231,10 +231,10 @@ function getindex(r::RemoteRef, args...)
     end
 end
 
-getindex(d::DArray, i::Int) = getindex(d, ind2sub(size(d), i))
-getindex(d::DArray, i::Int...) = getindex(d, sub2ind(size(d), i...))
+getindex(d::DArray, i::Int) = getindex_tuple(d, ind2sub(size(d), i))
+getindex(d::DArray, i::Int...) = getindex_tuple(d, i)
 
-function getindex{T}(d::DArray{T}, I::(Int...))
+function getindex_tuple{T}(d::DArray{T}, I::(Int...))
     chidx = locate(d, I...)
     chunk = d.chunks[chidx...]
     idxs = d.indexes[chidx...]

base/iobuffer.jl

@@ -16,7 +16,7 @@ end
 
 function copy(b::IOBuffer) 
     ret = IOBuffer(b.writable?copy(b.data):b.data,
-            b.readable,b.writable,b.seekable,b.append,b.maxsize)
+                   b.readable,b.writable,b.seekable,b.append,b.maxsize)
     ret.size = b.size
     ret.ptr  = b.ptr
     ret

base/pointer.jl

@@ -28,7 +28,7 @@ pointer{T}(::Type{T}, x::Ptr) = convert(Ptr{T}, x)
 # pointer. they just map the array element type to the pointer type for
 # convenience in cases that work.
 pointer{T}(x::AbstractArray{T}) = convert(Ptr{T},x)
-pointer{T}(x::AbstractArray{T}, i::Integer) = convert(Ptr{T},x)+(i-1)*sizeof(T)
+pointer{T}(x::AbstractArray{T}, i::Integer) = convert(Ptr{T},x) + (i-1)*elsize(x)
 
 # unsafe pointer to array conversions
 pointer_to_array(p, d::Integer, own=false) = pointer_to_array(p, (d,), own)

base/sparse/sparsematrix.jl

@@ -712,8 +712,7 @@ prod{T}(A::SparseMatrixCSC{T}, region) = reducedim(*,A,region,one(T))
 #sum(A::SparseMatrixCSC{Bool}) = countnz(A)
 
 ## getindex
-getindex(A::SparseMatrixCSC, i::Integer) = getindex(A, ind2sub(size(A),i))
-getindex(A::SparseMatrixCSC, I::(Integer,Integer)) = getindex(A, I[1], I[2])
+getindex(A::SparseMatrixCSC, i::Integer) = getindex(A, ind2sub(size(A),i)...)
 
 function getindex{T}(A::SparseMatrixCSC{T}, i0::Integer, i1::Integer)
     if !(1 <= i0 <= A.m && 1 <= i1 <= A.n); throw(BoundsError()); end