implement larray.sort_values(axis=)

[gdementen]

yes, the labels in that case are meaningless (should be 0..N), but it is still useful. Eg, from dynapor: take M best salary out of last N.

[alixdamman]

Sorry but I don't get it. Could you give an example using the array a given in the doctest of sort_values?

[gdementen]

For a 2D array that would be something like:

>>> arr = LArray([[0, 5, 1], [3, 2, 1]], 'a=a0,a1;b=b0..b2')
>>> arr.sort_values(axis='a')
a\b  b0  b1  b2
  0   0   2   1
  1   3   5   1
>>> arr.sort_values(axis='b')
>>> a\b  0  1  2
 a0  0  1  5
 a1  1  2  3

Here is some proof of concept code, which only handles the axis case (needs to be somehow merged with current code):

def sort(self, axis):
    axis = self.axes[axis]
    axis_idx = self.axes.index(axis)
    data = np.sort(self.data, axis_idx)
    new_axes = self.axes.replace(axis_idx, Axis(len(axis), axis.name))
    return LArray(data, new_axes)

For a 3D test case:

>>> arr3d = LArray([[[0, 2],
                     [3, 5]], 
                    [[4, 1],
                     [0, 2]]], 'a=a0,a1;b=b0,b1;c=c0,c1')
>>> arr3d
 a  b\c  c0  c1
a0   b0   0   2
a0   b1   3   5
a1   b0   4   1
a1   b1   0   2
>>> arr3d.sort_values('a')
a*  b\c  c0  c1
 0   b0   0   1
 0   b1   0   2
 1   b0   4   2
 1   b1   3   5
>>> arr3d.sort_values('b')
 a  b*\c  c0  c1
a0     0   0   2
a0     1   3   5
a1     0   0   1
a1     1   4   2
>>> arr3d.sort_values('c')
 a  b\c*  0  1
a0    b0  0  2
a0    b1  3  5
a1    b0  1  4
a1    b1  0  2

[alixdamman]

For arrays with ndim > 1 and key=None, do we flatten the array before sorting or something else?

[gdementen]

I never liked flattened arrays in numpy, so I never thought of this. Providing the option actually makes a lot of sense because in our case we keep (mostly) meaningful labels if we flatten using combine_axes.
As for the default behaviour, another option is to mimic np.sort and have axis default to -1. Unsure which is best.

[gdementen]

BTW, it might be preferable to have both a key and an axis argument (and a check that both are not given at the same time). This is because otherwise we could have a key/label which is ambiguous with an axis name or axis position.

[alixdamman]

for the "default behavior", I prefer the first option (combine_axes over all axes). That will be consistent with what we want for 1D arrays + it makes sense to get the list of labels combinations that sorts all values (to me at least).

[alixdamman]

I agree with your second comment.

[gdementen]

for the "default behavior", I prefer the first option (combine_axes over all axes).

labelsofsorted/indicesofsorted raise an exception in that case. So, we should either raise here too, or flatten/use last axis in labelsofsorted/indicesofsorted

That will be consistent with what we want for 1D arrays

All 3 options do not change anything/are consistent with 1D arrays.

[alixdamman]

Current proposal for method signature + parameters + doctests:

    def sort_values(self, key=None, axis=None, reverse=False):
        """Sorts values of the array.

        Parameters
        ----------
        key : scalar or tuple or Group
            Key along which to sort. Must have exactly one dimension less than ndim.
            Cannot be set in the same time with `axis`.
            If both `key` and `axis` are None, sort array with all axes combined. 
            Defaults to None.
        axis : str or Axis
            Axis along which to sort. Cannot be set in the same time with `key`.
            Defaults to None.
        reverse : bool, optional
            Sort values in descending order. Defaults to False (ascending order).

        Returns
        -------
        LArray
            Array with sorted values.

        Examples
        --------
        >>> sex = Axis('sex=M,F')
        >>> nat = Axis('nat=EU,FO,BE')
        >>> a = LArray([[10, 2, 4], [3, 7, 1]], [sex, nat])
        >>> a
        sex\\nat  EU  FO  BE
              M  10   2   4
              F   3   7   1
        >>> # if no argument, sort array with all axes combined
        >>> a.sort_values()
        sex_nat  F_BE  M_FO  F_EU  M_BE  F_FO  M_EU
                    1     2     3     4     7    10
        >>> a.sort_values('F')
        sex\\nat  BE  EU  FO
              M   4  10   2
              F   1   3   7
        >>> a.sort_values('F', reverse=True)
        sex\\nat  FO  EU  BE
              M   2  10   4
              F   7   3   1
        >>> a.sort_values(axis='sex')
        sex*\\nat  EU  FO  BE
               0   3   2   1
               1  10   7   4
        >>> a.sort_values(axis='nat')
        sex\\nat*  0  1   2
               M  2  4  10
               F  1  3   7
        >>> xtype = Axis('type=type1,type2')
        >>> b = LArray([[[10, 2, 4], [3, 7, 1]], [[5, 1, 6], [2, 8, 9]]],
        ...            [sex, xtype, nat])
        >>> b
        sex  type\\nat  EU  FO  BE
          M     type1  10   2   4
          M     type2   3   7   1
          F     type1   5   1   6
          F     type2   2   8   9
        >>> b.sort_values(('M', 'type2'))
        sex  type\\nat  BE  EU  FO
          M     type1   4  10   2
          M     type2   1   3   7
          F     type1   6   5   1
          F     type2   9   2   8
          """