CODEWITHSUNDEEP
javafloating-point
user396672
user396672

Reputation: 3166

Floating point arithmetics restricted to integers

I use doubles for a uniform implementation of some arithmetic calculations. These calculations may be actually applied to integers too, but there are no C++-like templates in Java and I don't want to duplicate the implementation code, so I simply use "double" version for ints.

Does JVM spec guarantees the correctness of integer operations such a <=,>=, +, -, *, and / (in case of remainder==0) when the operations are emulated as corresponding floating point ops?

(Any integer, of course, has reasonable size to be represented in double's mantissa)

Upvotes: 1

Views: 236

Answers (3)

user396672
user396672

Reputation: 3166

Indeed, I 've found the standard and it says "yes"

JVM spec:

The rounding operations of the Java virtual machine always use IEEE 754 round to nearest mode. Inexact results are rounded to the nearest representable value, with ties going to the value with a zero least-significant bit. This is the IEEE 754 default mode. But Java virtual machine instructions that convert values of floating-point types to values of integral types round toward zero. The Java virtual machine does not give any means to change the floating-point rounding mode.

ANSI/IEEE Std 754-1985 5. ... Except for binary <---> decimal conversion, each of the operations shall be performed as if it first produced an intermediate result correct to infinite precision and with unbounded range, and then coerced this intermediate result to fit in the destination’s format

ANSI/IEEE Std 754-1985 5.4. Conversions between floating-point integers and integer formats shall be exact unless an exception arises as specified in 7.1.

Summary

1) exact operations are always exact if the result fits the double format (and, therefore, integer result is always floating-point integer).
2) int <--> double conversions are always exact for floating point integers.

Upvotes: 1

Michael Borgwardt
Michael Borgwardt

Reputation: 346280

According to the Java Language Specification:

Operators on floating-point numbers behave as specified by IEEE 754 (with the exception of the remainder operator (§15.17.3)).

So you're guaranteed uniform behaviour, and while I don't have access to the official IEEE standard document, I'm pretty sure that it implicitly guarantees that operations on integers that can be represented exactly as a float/double work as expected.

Upvotes: 2

user467871
user467871

Reputation:

briefly yes.

double a = 3.0;
double b = 2.0;

System.out.println(a*b); // 6.0
System.out.println(a+b); // 5.0
System.out.println(a-b); // 1.0
System.out.println(a/b); // 1.5 // if you want to get 1 here you should cast it to `integer (int)`
System.out.println(a>=b); // true
System.out.println(a<=b); // false

but be careful while multiplication (*) because a*b can cause overflow while casting to integer. same situation for (+ and -)

Upvotes: 1

Related Questions