zero-dimensional tensor behavior

[StefanKarpinski]

This is not at all what should happen for a zero-dimensional tensor:

julia> a = Array{Int32,0}(())
Array(Int32,())

julia> a[] = 1
error: stack overflow

julia> a[]
Array(Int32,())

Instead, a[] = 1 should assign the unique value contained in the zero-tensor and a[] should retrieve it.

[JeffBezanson]

I was just trying to remember why our Scalars aren't 0-Tensors any more. Do you remember?

Maybe making a 0-dimensional array should be an error.

I noticed that a[:,1] gives something 2-dimensional. I recall we wanted the rank of the result to be the sum of the ranks of the indexes, but I guess we changed that because the type system can't express it?

[StefanKarpinski]

There were all sorts of nasty type issues with having Float64 and Tensor{Float64,0} be identified types.

I'm not really sure what we should do here. Clearly having t[1,2,3] return a zero-dimensional tensor object is stupid unless that's the same thing as a scalar. Having T = Tensor{T,0} caused all sorts of problems with method declarations, but it is strangely compelling.

[StefanKarpinski]

I'm making this not a v1.0 issue. This isn't causing immediate problems and can be resolved later. Still reasonable to discuss it now though.

[JeffBezanson]

Ah, ok, I guess we decided that being a container is not directly related to tensor rank. If it were, it would be hard to justify a[] doing a rank-reducing operation (i.e. taking an element out of a container).

I can fix this with a 3-line change:

diff --git a/j/array.j b/j/array.j
index 017862a..483ce2b 100644
--- a/j/array.j
+++ b/j/array.j
@@ -58,6 +58,7 @@ float64{T,n}(x::Array{T,n}) = convert(Array{Float64,n}, x)
 ## Indexing: ref ##

 ref(a::Array, i::Index) = arrayref(a,i)
+ref{T}(a::Array{T,0}) = arrayref(a,1)
 ref{T}(a::Array{T,1}, i::Index) = arrayref(a,i)
 ref(a::Array{Any,1}, i::Index) = arrayref(a,i)
 ref{T}(a::Array{T,2}, i::Index, j::Index) = arrayref(a, (j-1)*arraysize(a,1)+i)
@@ -68,6 +69,7 @@ assign(A::Array{Any}, x::Tensor, i::Index) = arrayset(A,i,x)
 assign(A::Array{Any}, x::ANY, i::Index) = arrayset(A,i,x)
 assign{T}(A::Array{T}, x::Tensor, i::Index) = arrayset(A,i,convert(T, x))
 assign{T}(A::Array{T}, x, i::Index) = arrayset(A,i,convert(T, x))
+assign{T}(A::Array{T,0}, x) = arrayset(A,1,convert(T, x))

 ## Dequeue functionality ##

diff --git a/src/array.c b/src/array.c
index 1f8feb2..a24bb9f 100644
--- a/src/array.c
+++ b/src/array.c
@@ -42,7 +42,6 @@ static jl_array_t *_new_array(jl_type_t *atype, jl_tuple_t *dimst,
     void *data;
     jl_array_t *a;

-    if (ndims == 0) nel = 0;
     for(i=0; i < ndims; i++) {
         nel *= dims[i];
     }

So should I just push this?