Python's standard float type is a C double: http://docs.python.org/2/library/stdtypes.html#typesnumeric
NumPy's standard numpy.float is the same, and is also the same as numpy.float64.
Python's standard float type is a C double: http://docs.python.org/2/library/stdtypes.html#typesnumeric
NumPy's standard numpy.float is the same, and is also the same as numpy.float64.
Data type-wise numpy floats and built-in Python floats are the same, however boolean operations on numpy floats return np.bool_ objects, which always return False for val is True. Example below:
In [1]: import numpy as np
...: an_np_float = np.float32(0.3)
...: a_normal_float = 0.3
...: print(a_normal_float, an_np_float)
...: print(type(a_normal_float), type(an_np_float))
0.3 0.3
<class 'float'> <class 'numpy.float32'>
Numpy floats can arise from scalar output of array operations. If you weren't checking the data type, it is easy to confuse numpy floats for native floats.
In [2]: criterion_fn = lambda x: x <= 0.5
...: criterion_fn(a_normal_float), criterion_fn(an_np_float)
Out[2]: (True, True)
Even boolean operations look correct. However the result of the numpy float isn't a native boolean datatype, and thus can't be truthy.
In [3]: criterion_fn(a_normal_float) is True, criterion_fn(an_np_float) is True
Out[3]: (True, False)
In [4]: type(criterion_fn(a_normal_float)), type(criterion_fn(an_np_float))
Out[4]: (bool, numpy.bool_)
According to this github thread, criterion_fn(an_np_float) == True will evaluate properly, but that goes against the PEP8 style guide.
Instead, extract the native float from the result of numpy operations. You can do an_np_float.item() to do it explicitly (ref: this SO post) or simply pass values through float().
Not that I am aware of. You either need to specify the dtype explicitly when you call the constructor for any array, or cast an array to float32 (use the ndarray.astype method) before passing it to your GPU code (I take it this is what the question pertains to?). If it is the GPU case you are really worried about, I favor the latter - it can become very annoying to try and keep everything in single precision without an extremely thorough understanding of the numpy broadcasting rules and very carefully designed code.
Another alternative might be to create your own methods which overload the standard numpy constructors (so numpy.zeros, numpy.ones, numpy.empty). That should go pretty close to keeping everything in float32.
This question showed up on the NumPy issue tracker. The answer is:
There isn't, sorry. And I'm afraid we're unlikely to add such a thing[.]
The numbers are (most likely) the same, it's just a matter of how the objects are formatted as strings.
>>> numpy.array([75.09], dtype="float32")[0] == numpy.float32(75.09)
True
The problem (as you may already know) is that 75.09 seems to require a lot of precision, maybe even infinite (I didn't do the math, more about it here).
If you want to have consistent text output just use your own string formatting.
>>> a = numpy.array([75.09], dtype="float32")
>>> b = numpy.float32(75.09)
>>> print 'a: [', ','.join('{:.6f}'.format(ai) for ai in a), '] b:','{:.6f}'.format(b)
a: [ 75.089996 ] b: 75.089996
>>> print 'a: [', ','.join('{:.8f}'.format(ai) for ai in a), '] b:','{:.8f}'.format(b)
a: [ 75.08999634 ] b: 75.08999634
The display of the numbers is different because they are printed as a NumPy array (1) and and float (2). Try to print the first array member numpy.array([75.09], dtype="float32")[0].
Comments about the finite precision of floating point numbers are also to take into account :-) Almost never will you find equality in floating point numerics.