Page History

Incautious use of integer arithmetic to calculate a value for assignment to a floating-point variable can lead to loss of information. Recall, for example, that integer arithmetic always produces integral results, discarding information about any possible fractional remainder. Furthermore, there can be loss of precision when converting integers to floating-point values. See rule "NUM13-J. Avoid loss of precision when converting primitive integers to floating-point" for additional information. Correct programming of expressions that mix integer and floating-point operations or values requires careful consideration.

...

In this noncompliant code example, the division and multiplication operations are performed on integral values; the results of these operations are then converted to floating - point. The results of the integral operations are truncated to the nearest integer , and can also overflow. As a result, the floating-point variables d, e, and f are initialized incorrectly because the truncation and overflow take place before the conversion to floating point.

...

Note that the calculation for c violates rule " NUM00-J. Detect or prevent integer overflow."

Compliant Solution (Floating-Point Literal)

This compliant solution performs the multiplication and division operations on floating-point values, avoiding both the truncation and the overflow seen in the noncompliant code example. In every operation, at least one of the operands is of a floating-point type, thereby forcing floating-point multiplication and division , and avoiding truncation and overflow.

...

Note that the original value of c cannot be represented exactly as a double. The representation of type double has only 48 mantissa bits, but a precise representation of the value of c would require 56 mantissa bits. Consequently, the value of c is rounded to the nearest value that can be represented by type double, and the computed value of f (9.328764743180247E18) differs from the exact mathematical result (9328564743180246912). This loss of precision is one of many reasons why correct programming of expressions that mix integer and floating-point operations or values requires careful consideration. Even with this loss of precision, the computed value of f is nevertheless far more accurate than that produced in the noncompliant example above.

Compliant Solution

This compliant solution eliminates the truncation and overflow errors by storing the integers in the floating-point variables before performing the arithmetic operations. As abovein the previous compliant solution, this ensures that at least one of the operands of each operation is a floating-point number. Consequently, the operations are performed on floating-point values.

short a = 533;
int b = 6789;
long c = 4664382371590123456L;

float d = a;
double e = b;
double f = c;

d /= 7;  // d is 76.14286
e /= 30; // e is 226.3
f *= 2;  // f is 9.328764743180247E18

As in the previous first compliant example, the value of c cannot be represented exactly as a double. Consequently, the value of f is not precise before or after the multiplication. The explanation and consequences are identical to those stated abovepreviously.

Exceptions

NUM13-EX0: It is acceptable to perform operations using a mix of integer and floating-point values when deliberately exploiting the properties of integer arithmetic before conversion to floating point. For example, using integer arithmetic eliminates the need to use the floor() method. Any such code must be clearly documented to help future maintainers understand that this behavior is intentional.

...

...