Page History

The Java language allows platforms to use available floating-point hardware that can provide extended floating-point support with exponents that contain more bits than the standard Java primitive type double (in the absence of the strictfp modifier). Consequently, these platforms can represent a superset of the values that can be represented by the standard floating-point types. Floating-point computations on such platforms can produce different results than would be obtained if the floating-point computations were restricted to the standard representations of float and double. According to the JLS, §15.4, "FP-strict Expressions" [JLS 2005]:

...

Using the strictfp modifier leaves execution unchanged on platforms that lack platform-specific, extended floating-point support. It can have substantial impact, however, on both the efficiency and the resulting values of floating-point computations when executing on platforms that provide extended floating-point support. On these platforms, using the strictfp modifier increases the likelihood that intermediate operations will overflow or underflow because it restricts the range of intermediate values that can be represented and the precision of intermediate values; it can also reduce computational efficiency. These issues are unavoidable when portability is the main concern.

...

An expression is FP-strict when any of the containing classes, methods, or interfaces is declared to be strictfp. Constant expressions containing floating-point operations are also evaluated strictly. All compile-time constant expressions are by default strictfpFP-strict.

Strict behavior cannot be is not inherited by a subclass that extends a strictfp FP-strict superclass. An overriding method can independently choose to be strictfp FP-strict when the overridden method is not, or vice versa.

...

This noncompliant code example does not mandate strictfp FP-strict computation. Double.MAX_VALUE is multiplied by 1.1 and reduced back by dividing by 1.1, according to the evaluation order. If Double.MAX_VALUE is the maximum value permissible by the platform, the calculation will yield the result infinity.

However, if the platform provides extended floating-point support, this program might print a numeric result roughly equivalent to Double.MAX_VALUE.

The initial multiplication might overflow, but is not required to. The JVM may choose to treat this case as strictfpFP-strict; if it does so, overflow occurs. The ability to use extended exponent ranges Because the expression is not FP-strict, an implementation may use an extended exponent range to represent intermediate values is implementation-definedresults.

class Example {
  public static void main(String[] args) {
    double d = Double.MAX_VALUE;
    System.out.println("This value \"" + ((d * 1.1) / 1.1) + "\" cannot be represented as double.");
  }
}

...

strictfp class Example {
  public static void main(String[] args) {
    double d = Double.MAX_VALUE;
    System.out.println("This value \"" + ((d * 1.1d1) / 1.1d1) + "\" cannot be represented as double.");
  }
}

This compliant solution also specifies that the floating-point literals (1.1) are of type double to clarify their expected type and to maximize their precision.

Noncompliant Code Example

Some platforms provide extended floating-point support in which their native Native floating-point hardware provides greater precision range than double. On these platforms, the JIT is permitted to use floating-point registers to hold values of type float or type double (in the absence of the strictfp modifier), even though the registers support values with greater exponent range than that of the primitive types. Consequently, conversion from float to double can cause an effective loss of magnitude.

class Example {
  double d = 0.0;

  public void example() {
    float f = Float.MAX_VALUE;
    float g = Float.MAX_VALUE;
    this.d = f * g;
    System.out.println("d (" + this.d + ") might not be equal to " +
                       (f * g));
  }

  public static void main(String[] args) {
    Example ex = new Example();
    ex.example();
  }
}

...

...