Sorry. I guess I should have made my last comment in the PR.

After using my own version of this code for the past month or so, it has occurred to me that this API probably will not support stacking arrays of with different sizes along shared arrays. For instance, I need to "stack" humidity below an altitude of 10km with temperature between 0 and 16 km. IMO, the easiest way to do this would be to change these methods into top-level functions which can take any dict or iterable of datarrays. We could leave that for a later PR of course.

@shoyer I wrote a class that does this a while ago. It is available here: data_matrix.py. It is used like this ```python

D is a dataset

the signature for DataMatrix.init is

DataMatrix(feature_dims, sample_dims, variables)

mat = DataMatrix(['z'], ['x'], ['a', 'b']) y = mat.dataset_to_mat(D) x = mat.mat_to_dataset(y) `` One of the problems I had to handle was with concatenating/stacking DataArrays with different numbers of dimensions---stackandunstackcombined withto_arraycan only handle the case where the desired feature variables all have the same dimensionality. ATM my code stacks the desired dimensions for each variable and then manually callsnp.hstack` to produce the final matrix, but I bet it would be easy to create a pandas Index object which can handle this use case.

Would you be open to a PR along these lines?

I had the chance to play around with stack and unstack, and it appears that these actually do nearly all the work needed here, so you can disregard my last comment. The only logic which is somewhat unwieldy is code which creates a DataArray from the eofs dask array. This is a complete example using the air dataset: ```python air = load_dataset("air_temperature").air

A = air.stack(features=['lat', 'lon']).chunk() A-= A.mean('features')

,,eofs = svd_compressed(A.data, 4)

wrap eofs in dataarray

dims = ['modes', 'features'] coords = {}

for i, dim in enumerate(dims): if dim in A.dims: coords[dim] = A[dim] elif dim in coords: pass else: coords[dim] = np.arange(eofs.shape[i])

eofs = xr.DataArray(eofs, dims=dims, coords=coords).unstack('features') `` This is pretty compact as is, so maybe the ugly final bit could be replaced with a convenience function likeunstack_array(eofs, dims, coords)or a method callA.unstack_array(eofs, dims, new_coords={})`.

Cool! Thanks for that link. As far as the API is concerned, I think I like the ReshapeCoder approach a little better because it does not require keeping track of a feature_dims vector list throughout the code, like my class does. It also could generalize beyond just creating a 2D array.

To produce a dataset B(samples,features) from a dataset A(x,y,z,t) how do you feel about a syntax like this: ```python rs = Reshaper(dict(samples=('t',), features=('x', 'y', 'z')), coords=A.coords)

B = rs.encode(A)

,,eofs =svd(B.data)

eofs is now a 2D dask array so we need to give

it dimension information

eof_dims = ['mode', 'features'] rs.decode(eofs, eof_dims)

to decode XArray object we don't need to pass dimension info

rs.decode(B) ```

On the other hand, it would be nice to be able to reshape data through a syntax like

A.reshape.encode(dict(...))