CODEWITHSUNDEEP
mathlanguage-agnosticdivide-by-zero
Apurv
Apurv

Reputation: 3753

Integer divide by Zero and Float (Real no.) divide by Zero

If I run following line of code, I get DIVIDE BY ZERO error

1. System.out.println(5/0);

which is the expected behavior.

Now I run the below line of code

2. System.out.println(5/0F);

here there is no DIVIDE BY ZERO error, rather it shows INFINITY

In the first line I am dividing two integers and in the second two real numbers.

Why does dividing by zero for integers gives DIVIDE BY ZERO error while in the case of real numbers it gives INFINITY

I am sure it is not specific to any programming language.

Upvotes: 2

Views: 1190

Answers (2)

PointedEars
PointedEars

Reputation: 14970

This is specific to one programming language or a family of languages. Not all languages allow integers and floats to be used in the same expression. Not all languages have both types (for example, ECMAScript implementations like JavaScript have no notion of an integer type externally). Not all languages have syntax like this to convert values inline.

However, there is an intrinsic difference between integer arithmetic and floating-point arithmetic. In integer arithmetic, you must define that division by zero is an error, because there are no values to represent the result. In floating-point arithmetic, specifically that defined in IEEE-754, there are additional values (combinations of sign bit, exponent and mantissa) for the mathematical concept of infinity and meta-concepts like NaN (not a number).

So we can assume that the / operator in this programming language is generic, that it performs integer division if both operands are of the language's integer type; and that it performs floating-point division if at least one of the operands is of a float type of the language, whereas the other operands would be implicitly converted to that float type for the purpose of the operation.

In real-number math, division of a number by a number close to zero is equivalent to multiplying the first number by a number whose absolute is very large (x / (1 / y) = x * y). So it is reasonable that the result of dividing by zero should be (defined as) infinity as the precision of the floating-point value would be exceeded.

Implementation details were to be found in that programming language's specification.

Upvotes: 0

Jon Skeet
Jon Skeet

Reputation: 1499760

(EDIT: The question has been changed a bit - it specifically referred to Java at one point.)

The integer types in Java don't have representations of infinity, "not a number" values etc - whereas IEEE-754 floating point types such as float and double do. It's as simple as that, really. It's not really a "real" vs "integer" difference - for example, BigDecimal represents real numbers too, but it doesn't have a representation of infinity either.

EDIT: Just to be clear, this is language/platform specific, in that you could create your own language/platform which worked differently. However, the underlying CPUs typically work the same way - so you'll find that many, many languages behave this way.

EDIT: In terms of motivation, bear in mind that for the infinity case in particular, there are ways of getting to infinity without dividing by zero - such as dividing by a very, very small floating point number. In the case of integers, there's obviously nothing between zero and one.

Also bear in mind that the cases in which integers (or decimal floating point types) are used typically don't need to concept of infinity, or "not a number" results - whereas in scientific applications (where float/double are more typically useful), "infinity" (or at least, "a number which is too large to sensibly represent") is still a potentially valid result.

Upvotes: 5

Related Questions