1. The Arithmetic and Logic Unit

Figure 1

2. Integer Representation

3. Integer Arithmetic

3.1 Negation

In sign-magnitude representation, the rule for forming the negation of an integer is simple: Invert the sign bit.

In twos complement representation, the negation of an integer can he formed with the following rules:

1. Take the Boolean complement of each bit of the integer (including the sign bit). That is. set each 1 to 0 and each 0 to 1.

2. Treating the result as an unsigned binary integer, add 1.

This two-step process is referred to as the twos complement operation, or the taking of the twos complement of an integer

Example:

Figure 2

Negation Special Case 1:

0 = 00000000

Bitwise not 11111111

Add 1 to LSB +1

Result 1 00000000

Overflow is ignored, so: - 0 = 0

Negation Special Case 2:

-128 = 10000000

bitwise not 01111111

Add 1 to LSB +1

Result 10000000

So: -(-128) = -128.

Because 128 is out of the range of signed 8bits numbers.

3.2 Addition and Subtraction:

Addition and Subtraction is done using following steps:

• Normal binary addition
• Monitor sign bit for overflow
• Take twos compliment of subtrahend and add to minuend ,i.e. a - b = a + (-b)

Hardware for Addition and Subtraction:

Figure 3

3.3 Multiplying positive numbers:

The multiplying is done using following steps:

• Work out partial product for each digit
• Take care with place value (column)
• Add partial products

Figure 4

Hardware Implementation of Unsigned Binary Multiplication:

Figure 5

Execution of Example:

Figure 6

Flowchart for Unsigned Binary Multiplication:

Figure 7

3.4 Multiplying Negative Numbers

Solution 1:

• Convert to positive if required
• Multiply as above
• If signs were different, negate answer

Solution 2:

• Booth’s algorithm:

Figure 8

Example of Booth’s Algorithm:

Figure 9

4. Floating-Point Representation

4.1 Principles

We can represent a real number in the form

± S × B ± E ± S × B ± E size 12{ +- S times B rSup { size 8{ +- E} } } {}

This number can be stored in a binary word with three fields:

Figure 10

• Sign: plus or minus
• Significant: S
• Exponent: E.

(A fixed value, called the bias, is subtracted from the biased exponent field to get the true exponent value (E). Typically, the bias equal 2k−1−12k−1−1 size 12{2 rSup { size 8{k - 1} } - 1} {}, where k is the number of bits in the binary exponent)

• The base B is implicit and need not be stored because it is the same for all numbers.

4.2 IEEE Standard for Binary Floating-Point Representation

The most important floating-point representation is defined in IEEE Standard 754 [EEE8]. This standard was developed to facilitate the portability of programs from one processor to another and to encourage the development of sophisticated, numerically oriented programs. The standard has been widely adopted and is used on virtually all contemporary processors and arithmetic coprocessors.

The IEEE standard defines both a 32-bit (Single-precision) and a 64-bit (Double-precision) double format with 8-bit and 11-bit exponents, respectively. Binary floating-point numbers are stored in a form where the MSB is the sign bit, exponent is the biased exponent, and "fraction" is the significand. The implied base (B) is 2.

Figure 11

Not all bit patterns in the IEEE formats are interpreted in die usual way; instead, some bit patterns are used to represent special values. Three special cases arise:

1. if exponent is 0 and fraction is 0, the number is ±0 (depending on the sign bit)
2. if exponent = 2e2e size 12{2 rSup { size 8{e} } } {}-1 and fraction is 0, the number is ±infinity (again depending on the sign bit), and
3. if exponent = 2e2e size 12{2 rSup { size 8{e} } } {}-1 and fraction is not 0, the number being represented is not a number (NaN).

This can be summarized as:

Figure 12

Single-precision 32 bit

A single-precision binary floating-point number is stored in 32 bits.

The number has value v:

v = s × 2e2e size 12{2 rSup { size 8{e} } } {}× m

Where

s = +1 (positive numbers) when the sign bit is 0

s = −1 (negative numbers) when the sign bit is 1

e = Exp − 127 (in other words the exponent is stored with 127 added to it, also called "biased with 127")

m = 1.fraction in binary (that is, the significand is the binary number 1 followed by the radix point followed by the binary bits of the fraction). Therefore, 1 ≤ m < 2.

Figure 13

In the example shown above:

S=1

E= 011111100(2) -127 = -3

M=1.01 (in binary, which is 1.25 in decimal).

The represented number is: +1.25 × 2−3 = +0.15625.

5. Floating-Point Arithmetic

• X1±X2=(M1∗RE1−E2)RE2X1±X2=(M1∗RE1−E2)RE2 size 12{X1 +- X2= \( M1*R rSup { size 8{E1 - E2} } \) R rSup { size 8{E2} } } {} (assume E1 size 12{ <= {}} {}E2)
• X1 ∗ X2 = ( M1 ∗ M2 ) R E1 + E2 X1 ∗ X2 = ( M1 ∗ M2 ) R E1 + E2 size 12{X1*X2= \( M1*M2 \) R rSup { size 8{E1+E2} } } {}
• X1 / X2 = ( M1 / M2 ) R E1 − E2 X1 / X2 = ( M1 / M2 ) R E1 − E2 size 12{X1/X2= \( M1/M2 \) R rSup { size 8{E1 - E2} } } {}

• Exponent overflow: A positive exponent exceeds the maximum possible expo­nent value. In some systems, this may be designated as
• Exponent underflow: A negative exponent is less than the minimum possible exponent value (e.g.. -200 is less than -127). This means that the number is too small to be represented, and it may be reported as 0.
• Significand underflow: In the process of aligning significands, digits may flow off the right end of the significand. Some form of rounding is required.
• Significand overflow: The addition of two significands of the same sign may result in a carry out of the most significant bit. This can be fixed by realign­ment.