Well how about that! It turns out if you just type 1/0 it returns Infinity! On ghci: Prelude> 1/0 Infinity Prelude> :t 1/0 1/0 :: (Fractional t) => t Prelude> let inf=1/0 Prelude> filter (>=inf) [1..] and then of course it runs forever, never finding a number bigger than infinity. (But see ephemient’s comments below … Read more
I found some evidence about this here (original content in Chinese); the basic idea is that 0x7fffffff is problematic since it’s already “the top” of the range of 4-byte signed ints; so, adding anything to it results in negative numbers; 0x3f3f3f3f, instead: is still quite big (same order of magnitude of 0x7fffffff); has a lot … Read more
If you don’t need the full range of integer values, you can use the int.MaxValue and int.MinValue constants to represent infinities. However, if the full range of values is required, I’d suggest either creating a wrapper class or simply going for doubles.
Java floating point is based on the IEEE 754 binary floating point standard Floating Point Standard, the first version of which was issued in about 1985, so it is much older than Java. Given widespread hardware implementation of IEEE 754 by the time Java was being defined, the Java creators had little choice. Each IEEE … Read more
For Visual Studio I would use _isnan and _finite, or perhaps _fpclass. But if you have access to a C++11-able standard library and compiler you could use std::isnan and std::isinf.
You can test if your implementation has it: #include <math.h> #ifdef NAN /* NAN is supported */ #endif #ifdef INFINITY /* INFINITY is supported */ #endif The existence of INFINITY is guaranteed by C99 (or the latest draft at least), and “expands to a constant expression of type float representing positive or unsigned infinity, if … Read more
Java specifies that floating point numbers follow the IEEE 754 standard. This is how it’s stored: bit 0 : sign bit bits 1 to 11 : exponent bits 12 to 63 : fraction Now, I have executed below method with different double values: public static void print(double d){ System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d))); } I executed with these values: … Read more
The “pythonic” way is to go with what’s readable and maintainable. That said, x == float(“inf”) and x == float(“-inf”) are slightly more readable to me, and I’d prefer them. math.isinf(x) and x > 0 is faster, but only on the order of about 40 nanoseconds per call. So unless you’re checking a whole lot … Read more
There is in C99, but not in previous standards AFAIK. In C99, you’ll have NAN and INFINITY macros. From “Mathematics <math.h>“ (§7.12) section The macro INFINITY expands to a constant expression of type float representing positive or unsigned infinity, if available; … If you’re stuck with ANSI C89, you’re out of luck. See C-FAQ 14.9.
Since python integers are unbounded, you have to do this with a custom class: import functools @functools.total_ordering class NeverSmaller(object): def __le__(self, other): return False class ReallyMaxInt(NeverSmaller, int): def __repr__(self): return ‘ReallyMaxInt()’ Here I’ve used a mix-in class NeverSmaller rather than direct decoration of ReallyMaxInt, because on Python 3 the action of functools.total_ordering would have been … Read more