adding empty(a) to use instead of []

adding localize(SubDArray)

Author: JeffBezanson

j/abstractarray.j

@@ -43,6 +43,8 @@ similar{T}(a::AbstractArray{T}, dims::Dims)          = similar(a, T, dims)
 similar{T}(a::AbstractArray{T}, dims::Size...)       = similar(a, T, dims)
 similar   (a::AbstractArray, T::Type, dims::Size...) = similar(a, T, dims)
 
+empty(a::AbstractArray) = similar(a, 0)
+
 reshape(a::AbstractArray, dims::Dims) = (b = similar(a, dims);
                                   for i=1:numel(a); b[i] = a[i]; end;
                                   b)
@@ -569,7 +571,7 @@ end
 
 ## Concatenation ##
 
-cat(catdim::Int) = similar([], None, 0)
+cat(catdim::Int) = Array(None, 0)
 
 vcat() = Array(None, 0)
 hcat() = Array(None, 0)

j/array.j

@@ -63,6 +63,8 @@ similar{T}(a::Array{T,2}) = Array(T, size(a,1), size(a,2))
 similar{T}(a::Array{T,1}, S::Type) = Array(S, size(a,1))
 similar{T}(a::Array{T,2}, S::Type) = Array(S, size(a,1), size(a,2))
 
+empty(T::Type) = Array(T, 0)
+
 zeros{T}(::Type{T}, dims::Dims) = fill(Array(T, dims), zero(T))
 zeros(T::Type, dims::Size...) = zeros(T, dims)
 zeros(dims::Dims) = zeros(Float64, dims)

j/darray.j

@@ -48,6 +48,9 @@ type DArray{T,N,distdim} <: AbstractArray{T,N}
     end
 end
 
+typealias SubDArray{T,N}   SubArray{T,N,DArray{T}}
+typealias SubOrDArray{T,N} Union(DArray{T,N}, SubDArray{T,N})
+
 size(d::DArray) = d.dims
 
 function serialize{T,N,dd}(s, d::DArray{T,N,dd})
@@ -76,7 +79,41 @@ end
 
 # when we actually need the data, wait for it
 localize(r::RemoteRef) = localize(fetch(r))
-localize{T,N}(d::DArray{T,N}) = d.locl
+localize(d::DArray) = d.locl
+
+function localize(s::SubDArray)
+    d = s.parent
+    lo = d.dist[d.localpiece]
+    hi = d.dist[d.localpiece+1]-1
+    sdi = s.indexes[d.distdim]
+    l = localize(d)
+    if isa(sdi,Int)
+        if lo <= sdi <= hi
+            return l[ntuple(ndims(l), i->(i==d.distdim ? sdi-lo+1 :
+                                          1:size(l,i)))...]
+        else
+            return Array(eltype(l), ntuple(ndims(l),
+                                           i->(i==d.distdim ? 0 :
+                                               size(l,i))))
+        end
+    else
+        sta = start(sdi)
+        ste = step(sdi)
+        sto = sdi[end]
+        i0 = sta + ste*div((lo-sta), ste)
+        i1 = sta + ste*div((hi-sta), ste)
+        i0 = max(i0,sta)
+        i1 = min(i1,sto)
+        if i0 > sto || i1 < sta
+            return Array(eltype(l), ntuple(ndims(l),
+                                           i->(i==d.distdim ? 0 :
+                                               size(l,i))))
+        else
+            return l[ntuple(ndims(l), i->(i==d.distdim ? i0:ste:i1 :
+                                          1:size(l,i)))...]
+        end
+    end
+end
 
 # find which piece holds index i in the distributed dimension
 function locate(d::DArray, i::Index)
@@ -132,6 +169,7 @@ function locate(d::DArray, I::AbstractVector{Index})
     end
     return (pmap, dist, perm)
 end
+
 ## Constructors ##
 
 function maxdim(dims)

j/fft.j

@@ -247,7 +247,7 @@ function fftw_transpose(X::Matrix{Complex128})
     (n1, n2) = size(X)
     plan = ccall(dlsym(libfftw, :fftw_plan_guru_dft), Ptr{Void},
                  (Int32, Ptr{Int32}, Int32, Ptr{Int32}, Ptr{Complex128}, Ptr{Complex128}, Int32, Uint32),
-                 int32(0), int32([]),int32(2),int32([n1,n2,1,n2,1,n1]), X, P, FFTW_FORWARD, FFTW_PATIENT)
+                 int32(0), C_NULL, int32(2),int32([n1,n2,1,n2,1,n1]), X, P, FFTW_FORWARD, FFTW_PATIENT)
     jl_fftw_execute(Complex128, plan)
     jl_fftw_destroy_plan(Complex128, plan)
     return P
@@ -258,7 +258,7 @@ function fftw_transpose(X::Matrix{Complex64})
     (n1, n2) = size(X)
     plan = ccall(dlsym(libfftwf, :fftwf_plan_guru_dft), Ptr{Void},
                  (Int32, Ptr{Int32}, Int32, Ptr{Int32}, Ptr{Complex64}, Ptr{Complex64}, Int32, Uint32),
-                 int32(0), int32([]),int32(2),int32([n1,n2,1,n2,1,n1]), X, P, FFTW_FORWARD, FFTW_PATIENT)
+                 int32(0), C_NULL, int32(2),int32([n1,n2,1,n2,1,n1]), X, P, FFTW_FORWARD, FFTW_PATIENT)
     jl_fftw_execute(Complex64, plan)
     jl_fftw_destroy_plan(Complex64, plan)
     return P