BUG: masked-array median of 1d array should be scalar - #7592

I noticed that this issue was also reported in #5969. Should move discussion to there.

2 comments:

First, about advanced indexing, you are right that there is a bug here due to the fact that numpy treats arr[[1]] and arr[[np.array(1)]] differently. The reason is that the latter case is not really legal (there is a plan in #4434 to disallow it), and numpy makes a heuristic guess that the user actually indended to write arr[(np.array(1),)], ie, a tuple, which is treated differently. That's what we want, but the heuristic fails to trigger in the 1-d case. So in this PR I think that instead of converting h and odd using np.asarray it is probably better to change the indexing operations to low = asorted[tuple(ind)], and same for high. That should give the same effect without needing asarray.

Second, I think the behavior can be further improved. The way you have it now median returns a 0-d array when called on a 1-d array, but I think it would be better to simply return a scalar. I think this might easily achieved by changing return r to return r[()] in median, since indexing with () converts 0-d arrays to scalars (properly accounting for masked in maskedarrays) but leaves other arrays alone. (But note that indexing with () has a bug that it does not work with string types, see #7267, but that does not matter here since median doesn't work for strings anyway).

Thanks for the comments.
Since we do not want to affect the performance (or correctness) of the n-dimensional case, I think it would be best to special-case the 1d case (if len(asorted.shape)==1: ) at the top of the function.
The 1d case would probably become shorter and simpler - I might even copy it directly from the old version.
p.s. from your comment, seems like the casting of ind into tuple might be required anyways, for future compatibility...

Adding a tuple call to the indexing, will not affect anything except the speed of the tuple call itself. Making sure you index with a tuple instead of a list is the clean and correct solution for all dimensions.

Be good to finish this up.

Last call for getting this fixed for 1.11.1.

sry did not manage to get to it.
others: feel free to go on if you prefer not to wait - I do not know the schedule for 1.11.1, but can't promise I'll have time for this before the weekend.

I am going to do 1.11.1 this weekend (May 15).

I have implemented an alternate fix (#7635), by explicitly checking for the 1d case.
This restores the original behavior of returning a scalar in the 1d case, and avoids any changes in the n-dimensional case.
We might still want to assure tuple indexing ( asorted[tuple(ind)] ) as suggested above, but that may be considered a separate issue than the topic of this bug.

☔ The latest upstream changes (presumably #7635) made this pull request unmergeable. Please resolve the merge conflicts.

Closing as #7635 has been merged.