Divide by zero is valid for floating point numbers. 1/0 yields Infinity. (-1)/0 yields -Infinity. 0/0 yields NaN. These “numbers” are properly defined in IEEE 754. Integer division by zero, on the other hand, throws because one cannot represent infinity as an int.
There is no way to do that with the normal / and /= operators. The best way to do what you want is with guards: function notZero(n) { n = +n; // Coerce to number. if (!n) { // Matches +0, -0, NaN throw new Error(‘Invalid dividend ‘ + n); } return n; } and … Read more
C++ standard does not force the IEEE 754 standard, because that depends mostly on hardware architecture. If the hardware/compiler implement correctly the IEEE 754 standard, the division will provide the expected INF, -INF and NaN, otherwise… it depends. Undefined means, the compiler implementation decides, and there are many variables to that like the hardware architecture, … Read more
I don’t see any contradiction. Division by zero is undefined, period. There is no mention of “… unless INFINITY is defined” anywhere in the quoted text. Note that nowhere in mathematics it is defined that 1 / 0 = infinity. One might interpret it that way, but it is a personal, “shortcut” style interpretation, rather … Read more
Does integer division actually use the FPU under the hood? No, Linux just generates SIGFPE in this case too (it’s a legacy name whose usage has now been extended). Indeed, the Single Unix Specification defines SIGFPE as “Erroneous arithmetic operation“.
For IEEE floats, division of a finite nonzero float by 0 is well-defined and results in +infinity (if the value was >zero) or -infinity (if the value was less than zero). The result of 0.0/0.0 is NaN. If you use integers, the behaviour is undefined.
Is 1/0 actually a legal Java expression that should compile anytime anywhere? Yes. What does JLS say about it? Nothing specific … apart from saying that division by zero will result in a runtime exception. However, the JLS acknowledges that possibility of runtime exceptions in the following definition: “A compile-time constant expression is an expression … Read more
In a nutshell: the double type defines a value for infinity while the int type doesn’t. So in the double case, the result of the calculation is a value that you can actually express in the given type since it’s defined. In the int case, there is no value for infinity and thus no way … Read more
SQL is a declarative language; you write a query that logically describes the result you want, but it is up to the optimizer to produce a physical plan. This physical plan may not bear much relation to the written form of the query, because the optimizer does not simply reorder ‘steps’ derived from the textual … Read more
It seems that your configuration is using the print option for numpy.seterr: >>> import numpy as np >>> np.array([1])/0 #’warn’ mode __main__:1: RuntimeWarning: divide by zero encountered in divide array([0]) >>> np.seterr(all=”print”) {‘over’: ‘warn’, ‘divide’: ‘warn’, ‘invalid’: ‘warn’, ‘under’: ‘ignore’} >>> np.array([1])/0 #’print’ mode Warning: divide by zero encountered in divide array([0]) This means that … Read more