Bits, Bytes, and Integers

• Integers
  • Representation: unsigned and signed (CS241L)
  • Conversion, casting
  • Expanding and truncating
  • Addition, negation, multiplication, shifting
  • Summary
• Representations in memory, pointers, strings

Unsigned and Signed Numeric Values

Mapping Between Signed and Unsigned

• Mappings between unsigned and two’s complement numbers:
  • Keep bit representations and reinterpret

Mapping Signed to Unsigned

Relation Between Signed and Unsigned

Conversion Visualized

Signed vs Unsigned in C

• Constants
  • By default are considered to be signed integers
  • Unsigned if have “U” as suffix
    • 0U, 4294967259U

Signed vs Unsigned in C

• Casting

  • Explicit casting between signed & unsigned same as U2T and T2U

    int tx, ty;
    unsigned ux, uy;
    tx = (int) ux;
    uy = (unsigned) ty;

• Implicit casting also occurs via assignments and procedure calls

  tx = ux;
  uy = ty;

Casting Surprises

• Expression Evaluation
  • If there is a mix of unsigned and signed in single expression, signed values implicitly cast to unsigned
  • Including comparison operations <, >, ==, <=, >=
  • Examples for W = 32:
    • TMIN = -2,147,483,648
    • TMAX = 2,147,483,647
• Note: signed means two’s complement

Casting Surprises Cont.

• On your own, justify each *

Summary: Casting Signed <–> Unsigned

• Bit pattern is maintained but reinterpreted
• Can have unexpected effects: adding or subtracting 2^w (2⁴ in examples with 4 bits)
• Expression containing signed and unsigned int: int is cast to unsigned!!

Bits, Bytes, and Integers

• Integers
  • Representation: unsigned and signed (CS241L)
  • Conversion, casting
  • Expanding and truncating
  • Addition, negation, multiplication, shifting
  • Summary
• Representations in memory, pointers, strings

Expanding and Truncating: Sign Extension

• Task:
  • Given w-bit signed integer x
  • Convert it to w+k-bit integer with same value
• Rule:
  • Make k copies of sign bit: X′ = x_w–1, …, x_w–1, x_w–1, x_w–2, …, x₀

Sign Extension Example

short int x =  15213;
int      ix = (int) x; 
short int y = -15213;
int      iy = (int) y;

• Converting from smaller to larger integer data type
• C automatically performs sign extension

Practice Problem 2.22

• Show that each of the following bit vectors is, a two’s-complement representation of -5 by applying Equation 2.3 (conv. B2T)
  1. 1011
  2. 11011
  3. 111011

Truncation: Unsigned

• Say you have an unsigned variable, x
• Truncating x to k bits is the same as x mod  2^k
• For example:
  • x = 248 = 11111000
  • Truncating to 4 bits: x = 1000 = 8
  • 248 mod  2⁴ = 8

Truncation: Signed

• Say you have a signed variable, x
• Truncating x to k bits is the same as U2T_k(x mod  2^k)
• For example:
  • x = 248 = 11111000
  • Truncating to 4 bits: x = 1000 = −8
  • U2T₄(248 mod  2⁴) = −8

Practice Problem: 2.24

• Truncate from 4 to 3 bits

Practice Problem: 2.24

Summary: Expanding and Truncating

• Expanding (e.g., short int to int)
  • Unsigned: zeros added
  • Signed: sign extension
  • Both yield expected result
• Truncating (e.g., unsigned to unsigned short)
  • Unsigned/signed: bits are truncated
  • Result reinterpreted
  • Unsigned: mod operation
  • Signed: similar to mod
  • For small numbers yields expected behavior

Bits, Bytes, and Integers

• Integers
  • Representation: unsigned and signed (CS241L)
  • Conversion, casting
  • Expanding and truncating
  • Addition, negation, multiplication, shifting
  • Summary
• Representations in memory, pointers, strings

Arithmetic: Basic Rules

• Most PL support “fixed-size arithmetic” (~= integers)
• Addition:
  • Unsigned/signed: Normal addition followed by truncate,
  • same operation on bit level
  • Unsigned: addition mod 2^w
  • Mathematical addition + possible subtraction of 2^w (on overflow)
  • Signed: modified addition mod 2^w (result in proper range)
  • Mathematical addition + possible addition or subtraction of 2^w

Arithmetic: Basic Rules

• Multiplication:
  • Unsigned/signed: Normal multiplication followed by truncate, same operation on bit level
  • Unsigned: multiplication mod 2^w
  • Signed: modified multiplication mod 2^w (result in proper range)

Unsigned Addition

• Standard Addition Function
  • Ignores carry output
• Implements Modular Arithmetic
  • s = UAdd_w(u, v) = u + v mod  2^w
• Detecting overflow occurred: check if s < u or s < v

Unsigned Addition: Example

• Wraps Around
  • If true sum  ≥ 2^w
  • At most once
• For example: with w = 4, lets add 9 + 21:

Two’s Complement Addition

• TAdd and UAdd have Identical Bit-Level Behavior
• Signed vs. unsigned addition in C:
  • int s, t, u, v;
  • s = (int) ((unsigned) u + (unsigned) v);
  • t = u + v
• Will give s =  = t

TAdd Overflow

Overflow Examples

Study and Practice on your Own

• In all arithmetic operations, for unsigned and signed, there are principles used to compute the operations and their derivation. Follow and study the derivations on your own. (Derivations start p. 72 (2.5) to p. 106
• Problem 2.29, p. 93 (understand 2’s comp +)
• Problem 2.33, p. 95

Example: Problem 2.29, First Row

Unsigned Multiplication

• Standard Multiplication Function
  • Ignores high order w bits
• Implements Modular Arithmetic
  • UMult_w(u, v) = u * v mod  2^w

Two’s Complement Multiplication

• Standard Multiplication Function
  • Ignores high order w bits
  • Lower bits are the same
  • TMult_w(u, v) = U2T_w(u * v mod  2^w)

More Practice

• Problem 2.34, p. 98
• Problem 2.35, p. 99