2.2 Module 3: computer arithmetic

1. the arithmetic and logic unit

The ALU is that part of the computer that actually performs arithmetic and logical operations on data. All of the other elements of the computer system—control unit, registers, memory, I/O—are there mainly to bring data into the ALU for it to process and then to take the results back out. We have, in a sense, reached the core or essence of a computer when we consider the ALU. An ALU and, indeed, all electronic components in the computer arc based on the use of simple digital logic devices that can store binary digits and perform simple Boolean logic operations.

Figure 3.1 indicates, in general terms, how the ALU is interconnected with the rest of the processor. Data are presented to the ALU in registers, and the results of an operation are stored in registers. These registers are temporary storage locations within the processor that are connected by signal paths to the ALU. The ALU may also set flags as the result of an operation. For example, an over­flow flag is set to 1 if the result of a computation exceeds the length of the register into which it is to be stored.

Figure 3.1 ALU Input and Output

2. integer representation

In the binary number system, arbitrary numbers can be represented with just the digits zero and one, the minus sign, and the period, or radix point.

For purposes of computer storage and processing, however, we do not have the ben­efit of minus signs and periods. Only binary digits (0 and 1) may be used lo represent numbers.

2.1 unsigned integer

If we are limited to nonnegative integers, the representation is straightforward.

In general, if an n-bit sequence of binary digits $a_{n-1}{a}_{n-2}\text{.}\text{.}\text{.}{a}_1{a}_0$ is interpreted as an unsigned integer A, its value is $A=a_{n-1}{2}^{n-1}+a_{n-2}{2}^{n-2}+\text{.}\text{.}\text{.}+a_1{2}^1+a_0{2}^0$

$A=\sum _{i=0}^{n-1}{a}_i{2}^i$

2.2 signed integer

Sign-magnitude representation

There are several alternative conventions used to represent negative as well as positive integers, all of which involve treating the most significant (leftmost) bit in the word as a sign bit. If the sign bit is 0, the number is positive: if the sign bit is 1, the number is negative.

The simplest form of representation that employs a sign bit is the sign-magnitude representation. In an n-bit word, the rightmost n - 1 bits hold the mag­nitude of the integer.

In general, if an n-bit sequence of binary digits $a_{n-1}{a}_{n-2}\text{.}\text{.}\text{.}{a}_1{a}_0$ represented A, its value is

$A=\sum _{i=0}^{n-2}{a}_i{2}^i$ If $a_{n-1}=0$

$A=-\sum _{i=0}^{n-2}{a}_i{2}^i$ If $a_{n-1}=1$

For example: +18= 0 0010010

- 18=1 0010010

There are several drawbacks to sign-magnitude representation. One is that addition and subtraction require a consideration of both the signs of the numbers and their relative magnitudes to carry out the required operation. Another drawback is that there are two representations of 0 (e.g 0000 0000 and 1000 00000).

This is inconvenient, because it is slightly more difficult to test for 0 (an operation performed frequently on computers) than if there were a single representation.

Because of these drawbacks, sign-magnitude representation is rarely used in implementing the integer portion of the ALU. Instead, the most common scheme is twos complement representation.