Featured White Papers

• Measuring Risk to Improve Java Software Quality
• Do You Really Get Classloaders?
• Pragmatic Continuous Delivery with Jenkins, Nexus, and LiveRebel
• Your Next Java Web App: Less XML, No Long Restarts, Fewer Hassles
• Coding with JRebel, Java Forever Changed
• 2012 Developer Productivity Report: Java Tools, Tech, Devs, and Data

Sponsored Links

• Graph databases are 1000x faster than relational.

  Learn More!

• Career opportunities at Harman- Careers That'll Rock Your Socks Off.

  Learn More!

• Developer-friendly Java PDF libraries by Qoppa Software

  Live Demos

• Stop blaming your app! Diagnose Java performance issues.

  Free tool >

• UrbanCode: Go From Continuous Integration to
  Continuous Delivery

  Learn More!

Sponsored Links

Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs

Floating-point arithmetic

A look at the floating-point support of the Java virtual machine

By Bill Venners, JavaWorld.com, 10/01/96

Page 4 of 5

Multiplication of floats and doubles is accomplished via the following opcodes. Each opcode causes two values of the same type to be popped off the stack and multiplied. The result, of the same type as the numbers being multiplied, is pushed back onto the stack. No exceptions are thrown.

The division experience is made available for floats and doubles by the following opcodes. The division opcodes cause the top two values of the appropriate type to be popped off the stack. The topmost value is divided by the value immediately beneath the topmost value. The result is pushed onto the stack. Floating-point division of a finite value by zero yields a positive or negative infinity. Floating-point division of zero by zero yields NaN. No exception is thrown as a result of any floating-point division.

The remainder operation is accomplished via the following opcodes on floats and doubles. The following opcodes cause the top two values to be popped from the stack. The topmost value is divided by the value just beneath it, and the remainder of that division is pushed back onto the stack. Floating-point remainder of any value divided by zero yields a NaN result. No exception is thrown as a result of any floating-point division.

The following opcodes perform arithmetic negation on floats and doubles. Negation opcodes pop the top value from the stack, negates it, and pushes the result.

Circle of squares: A JVM simulation

    class Struggle { 
    static void squareItForever() { 
        float f = 2; 
        while (true) { 
            f = f * f; 
            f = 0 - f; 
        } 
    } 
}

The actual bytecodes generated by javac for squareItForever() are shown below:

fconst_2          // Push float constant 2. 
fstore_0          // Pop to local variable 0 (float f): float f = 2; 
fload_0           // Push local variable 0 (float f). 
fload_0           // Push local variable 0 (float f). 
fmul              // Pop top two floats, multiply, push float result. 
fstore_0          // Pop to local variable 0 (float f): f = f * f; 
fconst_0          // Push float constant 0. 
fload_0           // Push local variable 0 (float f). 
fsub              // Subtract top float from next to top float: imByte = (byte) imInt; 
fstore_0          // Pop result to local variable 0 (float f): f = 0 - f; 
goto 2            // Jump back to the first fload_0 instruction: while (true) {} 

The squareItForever() method repeatedly squares a float value until it hits infinity. Each time the float is squared it is also negated. The float starts out as 2. It only takes seven iterations before infinity is reached, which isn't nearly as long as it takes in real life. The hex representation of the bits that make up the float are shown in the "hex value" column in the applet. The "value" column shows the number as humans are used to seeing it. This human-friendly value is generated by the Float.toString() method.