What do we mean by slicing in DiscreteLp spaces?

[kohr-h]

Discrete arrays

In the case of a muti-dimensional array (and tensors as in #861) slicing should clearly follow Numpy style:

>>> x = np.ones((2, 3, 4))
>>> x[:, 0, :].shape
(2, 4)

In other words, axes indexed by integers should be collapsed since it means "select this element along this axis".
This is a convention and does not throw away any information since the alternative can easily be reconstructed by inserting an empty axis for each collapsed one.

Discretized functions

When dealing with discretized functions, things are not so clear cut since the continuous picture can conflict with the discrete interpretation. Fixing the index to i in an axis k can mean one of the following:

• Give me the lower-dimensional discretized function where the coordinate in the k-th axis is fixed to the i-th grid point.
• Give me the function with the original number of dimensions, where all cells in axis k are thrown away, except for cell i.

So the difference is whether we mean the i-th grid point or the i-th partition cell.
And this time it's not only convention because collapsing actually discards information, namely the cell size in axis k.

Suggestion

My personal view on this is that the Numpy convention is a very strong one and should not easily be overruled here. Further, indexing is a discrete operation, so it should behave "in a discrete way".

So I would plead for indexing implemented as in the discrete case, and implementing a separate function for slicing (as a bonus, it can also be generalized to slices not parallel to coordinate planes).

[adler-j]

I agree with the suggestion. For the slicing you end up having some interesting boundary problems etc, so I'd put that of for now. We also need to clearly document that stuff like this will happen:

inner = 0
for sub_vec1, sub_vec2 in zip(discr_vec1, discr_vec2):
    inner += sub_vec1.inner(sub_vec2)

assert inner != discr_vec1.inner(discr_vec2)