CMPT 295

Unit - Data Representation

Lecture 4 – Representing integral numbers in memory – Arithmetic operations

Warm up question

• What is the value of …
  • TMin (in hex) for signed char in C: _________________
  • TMax (in hex) for signed int in C: _________________
  • TMin (in hex) for signed short in C: ________________

Last Lecture

• Interpretation of bit pattern B into either unsigned value U or signed value T
  • B2U(X) and U2B(X) encoding schemes (conversion)
  • B2T(X) and T2B(X) encoding schemes (conversion)
    • Signed value expressed as two’s complement => T
• Conversions from unsigned <-> signed values
  • U2T(X) and T2U(X) => adding or subtracting 2w
• Implication in C: when converting (implicitly via promotion and explicitly via casting):
  • Sign:
    • Unsigned <-> signed (of same size) -> Both have same bit pattern, however, this bit pattern may be interpreted differently
      • Can have unexpected effects -> producing a different value
  • Size:
    • Small -> large (for signed, e.g., short to int and for unsigned, e.g., unsigned short to unsigned int)
      • sign extension: For unsigned -> zeros extension, for signed -> sign bit extension
      • Both yield expected result –> resulting value unchanged
    • Large -> small (for signed, e.g., int to short and for unsigned, e.g., unsigned int to unsigned short)
      • truncation: Unsigned/signed -> most significant bits are truncated (discarded)
      • May not yield expected results -> original value may be altered
  • Both (sign and size): 1) size conversion is first done then 2) sign conversion is done

Today’s Menu

• Representing data in memory – Most of this is review
  • “Under the Hood” - Von Neumann architecture
  • Bits and bytes in memory
    • How to diagram memory -> Used in this course and other references
    • How to represent series of bits -> In binary, in hexadecimal (conversion)
    • What kind of information (data) do series of bits represent -> Encoding scheme
    • Order of bytes in memory -> Endian
  • Bit manipulation – bitwise operations
    • Boolean algebra + Shifting
• Representing integral numbers in memory
  • Unsigned and signed
  • Converting, expanding and truncating
  • Arithmetic operations
• Representing real numbers in memory
  • IEEE floating point representation
  • Floating point in C – casting, rounding, addition, …

Let’s first illustrate what we covered last lecture with a demo!

Demo – Looking at size and sign conversions in C

• What does the demo illustrate?
  • Size conversion:
    • Converting to a larger (wider) data type -> Converting short to int
    • Converting to a smaller (narrower) data type -> Converting short to char
  • Sign conversion:
    • Converting from signed to unsigned -> Converting short to unsigned short
    • Converting from unsigned to signed -> Converting unsigned short to short
  • Size and Sign conversion:
    • Converting from signed to unsigned larger (wider) data type -> Converting short to unsigned int
    • Converting from signed to unsigned smaller (narrower) data type -> Converting short to unsigned char
• This demo (code and results) posted on our course web site

Integer addition (unlimited space)

• What happens when we add two decimal numbers? (Highlights show carring the one to complete the equation) $\text{107}_{10} + \text{938}_{10} = \text{1045}_{10}$

• Same thing happens when we add two binary numbers:

$\text{101100}_{2} + \text{101110}_{2} = \text{1011010}_{2}$

Unsigned addition (limited space, i.e., fixed size in memory)

What happens when we add two unsigned values?

$$w=8$$

a)

Binary:

$\text{00111011}_{2} + \text{01011010}_{2} = ?$

Decimal:

$\text{59}_{10} + \text{90}_{10} = \text{149}_{10}$

b)

Binary:

$\text{10101110}_{2} + \text{11001011}_{2} = ?$

Decimal:

$\text{174}_{10} + \text{203}_{10} = \text{377}_{10}$

Unsigned addition ($+^{u}_{w}$) and overflow

• True/expected sum is the result of integer addition with unlimited space.
• Actual sum is the result of unsigned addition with limited space. Discarding the carry out bit.
• Discarding carry out bit has same effect as applying modular arithmetic

$s = U +^{u}_{w}v = (u + v) \mod{2^{w}}$

• Operands: w bits
• True Sum: w+1 bits

Closer look at unsigned addition overflow

• w = 8 -> [0..255]
• $$\text{255}_{10} = \text{11111111}_{2}$$
• $$\text{90}_{10} = \text{01011010}_{2}$$
• $$\text{45}_{10} = \text{00101101}_{2}$$

Example 1:

Decimal (carry out the 1 in 135):

$\text{90}_{10} + \text{45}_{10} = \text{135}_{10}$

Binary (carry out the 1 in $\text{10000111}_{2}$):

$\text{01011010}_{2} + \text{00101101}_{2} = \text{10000111}_{2}$

• True sum, w=8: $\text{10000111}_{2}$
• Actual (overflowed) sum, w=8: $\text{10000111}_{2} = \text{135}_{10}$

Example 2:

Decimal (carry 1 to the 3 in 300):

$\text{255}_{10} + \text{45}_{10} = \text{300}_{10}$

Binary (carry the 1 at the beginning of the result):

$\text{11111111}_{2} + \text{00101101}_{2} = \text{100101100}_{2}$

• True sum, w=9: $\text{100101100}_{2} = \text{300}_{10}$
• Actual (overflowed) sum, w=8: $\text{00101100}_{2} = \text{44}_{10}$

Comparing integer addition with Overflow: Effect of unsigned addition (w = 4)

Annotation: with unlimited space:

A 3d chart showing two numbers being added. a and b on the z and x axies, the sum on the y axis. y goes to a maximum height of 32 (a = 15) + (b = 15) = (y = 30) Annotation: With limited space (fixed-size memory):

A 3d chart showing two numbers being added. a and b on the z and x axies, the sum on the y axis. y goes to a maximum height of 15 (a = 15) + (b = 15) = (y = 14)

An overflow occurs when there is a carry out

For example: 15 ($\text{1111}_{2}$) + 15 ($\text{1111}_{2}$) = 30 ($\text{11110}_{2}$) as a true sum, and 14 ($\text{11110}_{2}$) as an actual sum.

Signed addition (limited space, i.e., fixed size in memory)

What happens when we add two signed values:

w=8

a)

Binary: $\text{00111011}_{2} + \text{01011010}_{2} = ?$

Decimal: $\text{59}_{10} + \text{90}_{10} = \text{149}_{10}$

b)

Binary: $\text{10101110}_{2} + \text{11001011}_{2} = ?$

Decimal: $\text{-82}_{10} + \text{-53}_{10} = \text{-135}_{10}$

Observation: Unsigned and signed additions have identical behavior @ the bit level, i.e., their sum have the same bit-level representation, but their interpretation differs

Signed addition ($+^{t}_{w}$) and overflow

True sum would be the result of integer addition with unlimited space: Actual sum is the result of signed addition with limited space:

Operands: w bits True Sum: w+1 bits

After discarduing carry out bit: w bits (overflow)

• Discarding carry out bit has same effect as applying modular arithmetic

$s = u +^{t}_{w} v = \text{U2T}_{w}[(u + v) \mod 2^{w}]$

Negative overflow and positive overflows are possible. Diagram showing negative overflows becoming positive, and positive overflows becoming negative.

Closer look at signed addition overflow

• w = 8 -> [-128..127]
• $$\text{90}_{10} = \text{01011010}_{2}$$
• $$\text{45}_{10} = \text{00101101}_{2}$$
• $$\text{-45}_{10} = \text{11010011}_{2}$$
• $$\text{-90}_{10} = \text{10100110}_{2}$$

Example 1:

Decimal: $\text{90}_{10} + \text{45}_{10} = \text{135}_{10}$

Binary: $\text{01011010}_{2} + \text{00101101}_{2} = \text{010000111}_{2}$

The binary result is -121

Example 2:

Decimal: $\text{-90}_{10} + \text{-45}_{10} = \text{-135}_{10}$

Binary: $\text{10100110}_{2} + \text{11010011}_{2} = \text{101111001}_{2}$

Binary result is 121

Example 3:

Decimal: $\text{-90}_{10} + \text{45}_{10} = \text{-45}_{10}$

Binary: $\text{10100110}_{2} + \text{00101101}_{2} = \text{011010011}_{2}$

Example 4:

Decimal: $\text{90}_{10} + \text{-45}_{10} = \text{45}_{10}$

Binary: $\text{01011010}_{2} + \text{11010011}_{2} = \text{100101101}_{2}$

A chart showing the relationship between true sum and actual (overflowed) sum. Actual sum has a possible value between 127 to -128. A true sum, however has a range between 255 and -256. As your true sum goes further down from -128, its actual sum becomes lower as well. Starting at -129 = 127. As you true sum goes futher up from 127, the actual sum also rises, satrting with 128 = -128.

Visualizing signed addition overflow (w = 4)

A 3D chart which has its x axis go from -8 to +7, its z axis go from -8 to +6, and a y axis which goes from :wq

Positive Overflow

For example: 7 ($\text{0111}_{2}$) + 1 ($\text{0001}_{2}$) = 8 ($\text{1000}_{2}$) is the true sum and = -8 ($\text{1000}_{2}$) is the actual sum

What about subtraction? -> Addition

x + (-x) = 0

• Subtracting a number is equivalent to adding its additive inverse
  • Instead of subtracting a positive number, we could add its negative version:

$107 - 118 = -11$

becomes:

$107 + (-118) = -18$

• Let‘s try:

Decimal:

$$\text{107}_{10} - \text{118}_{10} = -11$$

Binary:

$$\text{01101011}_{2} - \text{01110110}_{2} =$$

Binary subtraction by addition:

$$\text{01101011}_{2} + \text{10001010}_{2} = \text{11110101}_{2}$$

Binary subtraction by addition is equal to -11

Check: $-128 + 64 + 32 + 16 + 4 + 1 = \text{-11}_{10}$

T2B(X) conversion:

1. $$(~(\text{U2B}(|X|)))+1$$
2. $$(~(\text{U2B}(|-118|)))+1$$
3. $$(~(\text{U2B}(118)))+1$$
4. $$(\sim(01110110_{2}))+1$$
5. $$(\text{10001001}_{2})+1$$
6. $$\text{10001010}_{2}$$

Multiplication ($*^{u}_{w}, *^{t}_{w}$) and overflow

True product would be the result of integer multiplication with unlimited space: expected product Actual product is the result of multiplication with limited space.

• Operands: w bits
• True Product: 2w bits $u \times v$

• Discard: w bits

• Discarding high order w bits has same effect as applying modular arithmetic

$$p = u *^{u}_{w}v = (u \times v) \mod 2^{w}$$ $$p = u *^{t}_{w}v = \text{U2T}_{w}[(u \times v) \mod 2^{w}]$$

• Example: w = 4

Decimal:

$$5_{10} \times 5_{10} = \text{25}_{10}$$

Binary:

$$\text{0101}_{2} \times \text{0101}_{2} = \sout{001}\text{1001}_{2}$$

Multiplication with power-of-2 versus shifting

• If $x \times y$ where $y = 2^{k}$ then x << k
  • For both signed and unsigned
• Example:
  • $x \times 8 = x \times 2^{3}$ = x << 3
  • $x \times 24 = (x \times 25) – (x \times 23) = (x \times 32) – (x \times 8)$ = (x « 5) – (x « 3) (decompose 24 in powers of 2 => 32 – 8)
• Most machines shift and add faster than multiply
  • We’ll soon see that compiler generates this code automatically 17

Summary

• Demo of size and sign conversion in C: code and results posted!
• Addition:
  • Unsigned/signed:
    • Behave the same way at the bit level
    • Interpretation of resulting bit vector (sum) may differ
  • Unsigned addition -> may overflow, i.e., (w+1)th bit is set
    • If so, then actual sum obtained => $(x + y) \mod 2^{w}$
  • Signed addition -> may overflow, i.e., (w+1)th bit is set
    • If so, then true sum may be too +ve -> positive overflow OR too -ve -> negative overflow
    • Then actual sum obtained => $\text{U2T}_{w}[(x + y) \mod 2^{w}]$
• Subtraction
  • Becomes an addition where negative operands are transformed into their additive inverse (in two’s complement)
• Multiplication:
  • Unsigned: actual product obtained -> $(x \times y) \mod 2^{w}$
  • Signed: actual product obtained -> $$\text{U2T}_{w}[(x \times y) \mod 2^{w}]
  • Can be replaced by additions and shifts

Next lecture

• Representing data in memory – Most of this is review
  • “Under the Hood” - Von Neumann architecture
  • Bits and bytes in memory
    • How to diagram memory -> Used in this course and other references
    • How to represent series of bits -> In binary, in hexadecimal (conversion)
    • What kind of information (data) do series of bits represent -> Encoding scheme
    • Order of bytes in memory -> Endian
  • Bit manipulation – bitwise operations
    • Boolean algebra + Shifting
• Representing integral numbers in memory
  • Unsigned and signed
  • Converting, expanding and truncating
  • Arithmetic operations
• Representing real numbers in memory
  • IEEE floating point representation
  • Floating point in C – casting, rounding, addition, …

We’ll illustrate what we covered today by having a demo!