Java's Primitive Types Revisited

Table of Contents

1. Random Access Memory
2. Binary Counting
3. Binary Addition
4. The Convenience of Types
• The boolean type
• The char type
5. The Integer Types
6. The Floating-Point Types
• The Sign Bit
• The Exponent
• The Mantissa
• Combining Sign Bit, Exponent, and Mantissa
• Special Cases
7. The Analysis of Floating-Point Types
8. Exercises

Random Access Memory

Figure 1: A RAM module. Your computer likely contains two or three of these. The width of this module is 13cm. (Photograph courtesy of freepctech.com.)

RAM is constructed of a great many bit devices, each capable of "remembering" from one moment to the next whether it is "on" – represented by a 1 – or "off" – represented by a 0. ("Bit" is a contraction of "binary digit, meaning a 0 or a 1.) For reasons of efficiency, these bit devices are grouped into collections of, typically, 32-bit words, and each word is uniquely identified by a hard-wired numeric address. These addresses are sequentially assigned: The lowest address is 0, and the highest n - 1, where n is the number of bit devices divided by the word size for your computer. A PC with 512 megabytes (MB) of RAM has memory addresses 0 through 134217727 available to it. (A byte is 8 bits; 1MB is 10242 bytes.) A device called a memory controller acts as an intermediary between RAM and other devices in your computer, notably the central processing unit (CPU), which is responsible for executing program code. The memory controller stores (writes) and retrieves (reads) data to and from RAM in response to requests from these other devices. The memory controller can gain access to any word in RAM directly by way of its address. The term "random access" is meant to imply that, given any two words selected at random, access times for both are the same.
Back to Contents

Binary Counting

Binary Addition

The Convenience of Types

However, a programmer ignores computer architecture at her or his peril: Understanding the limitations of a type definition can often help us to understand what might otherwise seem to be inexplicable behaviour in a program. The sections below describe the internal representations used for data items of Java's primitive types: The boolean type, the char type, the integer types, and the floating-point types. Of these, we have only made (and will continue to make) consistent use of the boolean, int, and double types. The others are described here for completeness. These notes also also introduce a fictional floating-point type as an illustrative model.
Back to Contents

The boolean Type

The char Type

A char value occupies 16 bits. It represents an unsigned integer value that is meant to be used as an index into a table of viewable characters. Java conforms to the internationally-recognized Unicode standard for character representations. It must be understood that the value stored in RAM for a given character bears no resemblance to the form of the character on the screen or in print. The fact that sending the char value 'A' to the display with a System.out.println() statement (usually) results in a letter "A" of some font appearing for the user is thanks to a combination of your computer's operating system working in concert with your video hardware. By the way, in Unicode, 'A' is represented internally by 65, and 'B' by 66, which might help to explain the output from the third program statement given above. To learn more about Unicode, visit www.unicode.org.
Back to Contents

The Integer Types

It should be clear by now that whatever interpretation one puts on a collection of 8 bit values, there can never be more than 28, or 256 of them. So, if a byte is to use half of these bit patterns to represent negative values (those less than 0), and the other half to represent positive values (those greater than or equal to 0), then the largest set of integers it can represent is {-128 .. 127}. Bit patterns are mapped to values according to a scheme called two's complement, already widely in use among programming languages when Java was created. All of Java's integer types use two's complement. For a byte, the bit patterns are as follows:

• The value of the most significant (left-most) bit is 1 for negative values, and 0 for positive values. This bit position is often called the sign bit for this reason.
• 127 + 1 == -128. You may confirm this by using the binary addition technique described above. In fact, any pair of byte addends that should give a sum greater than 127 will, in a byte representation, give a negative sum. This is a special form of overflow condition in which the sign bit is changed inappropriately. Java does not treat this as an error, which has serious implications for programmers. Consider for example the following:

 

System.out.println ("Byte values:");

for (byte i = -128; i <= 127; i++)

    System.out.println (i);

It might seem that this should print out all the elements in the set of byte, and then get on with something else, but in fact the for is an infinite loop. To see why that's so, consider the while loop equivalent:
 

{

    byte i = -128;

    while (i <= 127)

    {

        System.out.println (i);

        i++;

    }

}

Note that when i reaches 127, the while loop's statement block executes for the 256th time, which means that after the System.out.println (i) occurs, so does the i++, and the bits in i "roll over" to the pattern for -128. (This is true in the for version of the loop as well.) When the boolean expression, i <= 127, is evaluated immediately afterwards, it is still true, since -128 is less than or equal to 127. As a consequence, the looping starts all over again.

The Floating-Point Types

As an aid to understanding the 32-bit float and the 64-bit double types, these notes introduce a model floating-point type called minifloat. It is meant to be what the IEEE would have proposed for Standard 754, had it felt the need for an 8-bit type.

The minifloat consists of three arbitrary fields of bits, as shown here:

The Sign Bit

The Exponent

The reason for greying-out the 000 and 111 bit patterns in the table above, is that they are reserved for special cases, as you shall see. This means that the exponent field has an effective range of only -2 .. 3. The implied base for the exponent is, perhaps not surprisingly, 2.
Back to Contents

The Mantissa

We can list all possible values of the mantissa (and their decimal equivalents) as follows:

Combining the Sign Bit, the Exponent, and the Mantissa

-1signBit × mantissa × 2exponent

which, as you can probably tell, is a binary form of scientific notation. Consider, for example, the following bit pattern as the representation of a minifloat:

-11 × 1.25 × 2-1 == -0.625
Back to Contents

Special Cases

• Zero


The most obvious weakness of the floating-point structure as described above, with its hidden bit always assumed to be 1, is its inability to represent 0.0. This is solved by decreeing that a floating-point number with an all-0s exponent field and an all-0s mantissa field has the value 0.0. This introduces a new potential source of confusion, as the sign bit is free to be either 0 or 1, giving

 

0

0

0

0

0

0

0

0

0.0

1

0

0

0

0

0

0

0

-0.0

According to the rules laid out by the IEEE for floating-point formats, -0.0 == 0.0 must be true. They are distinct values, however, as can be demonstrated using Java output:

double x = 0.0; // Zero

double y = -0.0; // Negative zero

if (x == y)

    System.out.println (x + " and " + y

        + " are equal, but different.");

else

    System.out.println (x + " and " + y

        + " are not equal.");

The existence of "negative zero" in IEEE Standard 754 suggests that it is no great cause for concern, though it highlights for us the arbitrariness of number representation in computers.
• Denormalized numbers


Most floating point numbers are normalized, which is to say the mantissa has a one-digit integer portion, that being the hidden bit, which is always considered to have the value 1. However, if the exponent bits are all 0, and the mantissa non-zero, then the mantissa is considered to be a denormalized fractional number. There is no hidden bit implied in a denormalized number, and the values of the columns are chosen so that the largest denormalized number, by magnitude (i.e., ignoring the value of the sign bit), is just smaller than the smallest normalized number. For a minifloat, the smallest normalized number, by magnitude, is

 

0

0

1

0

0

0

0

0.25

The mantissa column values for a denormalized minifloat are arbitrarily reassigned as follows:
 

2-3	2-4	2-5	2-6

So that the largest denormalized value, by magnitude, is:
 

1	1	1	1	0.234375
2-3	2-4	2-5	2-6

This is, indeed, just smaller than 0.25. The range of denormalized numbers, excluding ±0.0 (which are special cases of denormalized numbers) for a minifloat is

±0.015625 .. ±0.234375

It is important to bear in mind, when considering this range, that it contains only 16 positive and 16 negative values. The increment between those values is exactly 1/(2-6), or 1/64. Since denormalized numbers have the smallest non-zero values, by magnitude, of all the floating-point numbers, any value smaller than the smallest is considered to have value 0.0 (or -0.0).

• Infinity


If the exponent bits of a floating-point number are all 1s and the mantissa bits all 0s then the value is deemed to be an infinity. The value of the sign bit distinguishes positive (0) from negative (1) infinity. Infinity is the result of any operation on a floating-point number that exceeds its maximum or minimum values. For a minifloat, the maximum value is 15.5, and the minimum value is -15.5.

• NaN


If the exponent bits of a floating-point number are all 1s and one or more mantissa bits are also 1 (excluding the hidden bit), then the value is deemed to be Not a Number (NaN). A NaN value is an indicator that a floating-point operation failed. For example:

double d = Math.sqrt (-1.0);

On execution of this statement, the variable d would have the value NaN.

There are, according to IEEE Standard 754, two categories of NaN (called QNaN and SNaN), distinguishable from one another by the value of the most-significant mantissa bit. However, Java only uses one internal representation for NaN. The sign bit has no apparent significance for a NaN.

Analysis of Floating-Point Numbers

As you can see, the assignment of bit patterns to floating-point values is not linear (although segments of the chart are linear). In fact, although the minifloat representation can approximate real values from -15.5 .. 15.5, most have a value in the range -2.0 .. 2.0. The gaps between representable values increase with magnitude, so the ability to represent large numbers, in addition to small numbers, comes at the expense of precision. On the other hand, if the programming task at hand has us working with very large numbers, chances are we won't worry that the machine doesn't necessarily distinguish between very large value n and slightly larger value n + 1. Where precision does matter, as with financial applications, it is probably best to work with integer representations (e.g., counting pennies instead of dollars).

Gaps between small values can also be problematic. Note, for example, that the value 0.1 decimal (i.e., one-tenth) has no binary floating-point representation. The reason for this is that no sum of fractional powers of two add up to 0.1 decimal. To see that this is so, place the following code in the context of a Java program:

double sum = 0.0;

System.out.println ("Counting up to 1 in tenths:");

while (sum != 1.0)

{

    sum = sum + 0.1;

    System.out.println (sum);

    if (sum > 1.0)

    {

        System.out.println ("Whoops! Missed it!");

        break;

    }

}

Exercises

Two's Complement: Give solutions in 16-bit binary and in decimal

1. What are the maximum and minimum values that can be assigned to a Java variable of type short (a 16-bit two's complement number)?
2. What is the result of adding 1 to a short of maximum value? (Give the value, don't just write, "Overflow").
3. What is the result of subtracting 1 from a short of minimum value? (Give the value. If you can't work out for yourself how subtraction might be done on binaries, just try adding the bit pattern for -1).

1. The machine epsilon of a floating-point representation is a measure of its ability to distinguish between numbers of close but different values. It is the smallest positive value, e, such that 1 + e > 1. For the floating-point numbering systems in Java (and for the minifloat), it is defined as 21 - n, where n is the number of mantissa bits, including the hidden bit. Find the machine epsilon values for the following types. Give your answers as a power of 2. The first is done for you.
1. minifloat: Machine epsilon is 21 - 5 == 2-4
2. float
3. double
2. Write a Java program that finds and prints machine epsilon for a double. This can be done as follows:
• Set epsCandidate to 1.0
• Set eps to 0.0
• Loop
• Exit when 1.0 + epsCandidate is equal to 1.0
• Set eps to epsCandidate
• Divide epsCandidate by 2.0
• Send eps to output (i.e., the display)
Keeners should note that if a count variable (initially set to 0) is incremented in the loop, the number of mantissa bits, including the hidden bit, can also be determined this way.
3. Explain the output of this Java program:

public class ImportanceOfOperandOrdering

{

    public static void main (String[] args)

    {

        System.out.println (1.0 + 1.0 + 1.0e17 - 1.0e17);

        System.out.println (1.0e17 - 1.0e17 + 1.0 + 1.0);

    }

}