It's lexicographic order, similarly as in sort(). I'm not sure I agree absolute value would be less surprising.

From http://math.stackexchange.com/questions/310931/comparing-complex-numbers#310941, I think this boils down to asking whether complex numbers can be ordered at all, with the answer being that, no, generally they cannot. So, the logical consequence would be not to allow finding a minimum at all. Indeed, this is the case in python proper:

min(1+1j, 1+2j)
TypeError: unorderable types: complex() < complex()

Indeed, comparison itself is not defined in python, but defined in numpy:

1+1j < 1+2j
# TypeError: unorderable types: complex() < complex()
np.array(1+1j) < np.array(1+2j)
# True

Anyway, not something one can change lightly.

For what it's worth, Matlab uses the magnitude here. Pure-python and julia raise errors.

Yep, the sort order is lexicographic.

So my follow-up question was could we have min and max functions (or arguments to such functions that match the MATLAB behavior. As someone who works with scientist that are use to MATLAB, it is hard to sell them on Python when they find expectations like these are not met. Carrying around utility function like this on my end becomes silly and often redundant. Would it be possible to have some like this in numpy proper? I'm happy to ask this in a new issue if you would rather.

I don't think it would be too difficult to make such functions, but with different names than max/min. A PR would be welcome.

Ok, could I ask that we reopen this issue so that we can keep track of it? I don't have time for such a PR now, but would be willing to do it in the near future.

OK, I reopened with a Wish List label.

I don't know if there is still interest here. But I would be interested in such a function too.

Would it be called: np.max_abs?

Application note: In optics, it is sometimes useful to find the point of maximum intensity, but to propagate your field as a complex number.

Signed ints are a bit of a problem for abs, as the most negative values are invariant. If we stick to inexact types, no problem. Maybe always return an unsigned type, but then there are unexpected promotions. Maybe just warn when problem encountered?

For integers, maybe it should be implemented as minmax? The the check for the most negative value becomes order 1

Not sure we are on the same wavelength here. The problem is that that signed twos complement integers have more negative values than positive ones, so there is no way to represent the absolute value of the most negative value without changing types.

In [1]: abs(np.array(-128, np.int8))
Out[1]: -128

So maxabs would work, but miss 128, as does abs.

Hmm, I suppose that wouldn't be so bad if it is documented, might even be useful as the result will always be positive.

I get it. but max_abs could do something like
pseudocode

if dtype == signed int
    min, max = np.minmax(a)
    if min == -128
         warn
    else
         return maximum(abs(min), abs(max))

related: #2004