IEEE 754 floating point numbers can be used to store precisely integers of a certain ranges. For example:


binary32, implemented in C/C++ as float, provides 24 bits of precision and therefore can represent with full precision 16-bit integers, e.g. short int;
binary64, implemented in C/C++ as double, provides 53 bits of precision and can represent exactly 32-bit integers, e.g. int;
the non-standard Intel 80-bit precision, implemented as long double by some x86/x64 compilers, provides 64 significant bits and can represent 64-bit integers, e.g. long int (on LP64 systems, e.g. Unix) or long long int (on LLP64 systems, e.g. Windows); 
binary128, implemented as compiler-specific types such as __float128 (GCC) or _Quad (Intel C/C++), provides 113 bits in the mantissa and therefore can represent exactly 64-bit integers.


The fact that double fits an extended range of integers, even surpassing the range of 32-bit integers, is used in JavaScript, which doesen't have special integer numerical type and instead uses double precision floating-point to represent integers.

One quirk of floating-point numbers is that they have separate sign bit and therefore things like positive and negative zeros exist, which is not possible in the two's complement signed integer representation.

Does IEEE-754 float, double and quad guarantee exact representation of -2, -1, -0, 0, 1, 2?
I read an article stating that GPU are the future of supercomputing. I would like to know what are the programming languages used for programming on GPU's
