min_value = np.iinfo(im.dtype).min
max_value = np.iinfo(im.dtype).max

docs:

• np.iinfo (machine limits for integer types)
• np.finfo (machine limits for floating point types)

Quoting from a numpy discussion list:

That information is available via numpy.finfo() and numpy.iinfo():

In [12]: finfo('d').max
Out[12]: 1.7976931348623157e+308

In [13]: iinfo('i').max
Out[13]: 2147483647

In [14]: iinfo('uint8').max
Out[14]: 255

Link here.

You can use a decorator:

import sys
def noInf(f):
  def wrapped(*args, **kwargs):
    res = f(*args, **kwargs)
    if res == float('inf'):
      return sys.float_info.max
    return res
  return wrapped

@noInf
def myMult(x, y):
  return x*y

print(myMult(sys.float_info.max, 2)) # prints 1.79769313486e+308

Upd: it was originally wrong, now this is just the essence of the the previous correct answer:

a = np.array([[0.0543275 , 0.51249827, 0.43317423],
              [0.07144389, 0.51152126, 0.41703486], 
              [0.0776112 , 0.48593384, 0.43645496]])

b = np.zeros_like(a)

b[np.arange(a.shape[0]), np.argmax(a, axis=1)] = 1

Since np.argmax() gives us indices of the max elements, we just use them for indexing directly. Now b contains desired output:

array([[0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.]])

you can also do: b.astype(int) to turn to integers.

Can you rework the calculation so it works with the logarithms of the numbers instead?

That's pretty much how the built-in floats work in any case...

You would only convert the number back to linear for display, at which point you'd separate the integer and fractional parts; the fractional part gets exponentiated as normal to give the 8 digits of precision, and the integer part goes into the "×10ⁿ" or "×eⁿ" or "×2ⁿ" part of the output (depending on what base logarithm you use).

numpy.max is the same thing as numpy.amax:

>>> import numpy
>>> numpy.max # Notice it says 'amax' in the output
<function amax at 0x0228B5D0>
>>> numpy.max is numpy.amax
True
>>>

Or, more specifically, max is an alias for the amax function.

The purpose of this function is listed in the docs link you gave, but it seems that it is mainly used to find the maximum value inside a numpy.array regardless of how many nested levels it has. You can mimic this behavior with a simple function to flatten a list:

def flatten(lst):
    for item in lst:
        if isinstance(item, list):
            # Use 'yield from flatten(item)' in Python 3.3 or greater
            for sub_item in flatten(item):
                yield sub_item
        else:
            yield item

and the built-in max function:

max(flatten(my_list))

See a demonstration below:

>>> def flatten(lst):
...     for item in lst:
...         if isinstance(item, list):
...             for sub_item in flatten(item):
...                 yield sub_item
...         else:
...             yield item
...
>>> array = [[1, 2, 3], [4, 5, 6]]
>>> max(flatten(array))
6
>>>