lecture 7

Question 1

signed integer arithmetic overflow

Answer 1

when two signed integers are added and the result is either:
- exceeds the max value
- less than the min value
that can be represented by the number of bits (N)

Question 2

arithmetic overflow for signed integers in 2s complement

Answer 2

*two integers in 2s comp:
1) pos int + pos int = negative int
2) neg int + neg int = positive int

easy to detect in 2s

Question 3

0 1 1 1
+ 0 1 1 1
————–
1 1 1 0

= 7
+ 7
———–
- 2
what is happening here?

Answer 3

arithmetic overflow

2 positive integers (msb = 0) in 2s comp are added and equal a negative value
- 7 + 7 = -2 –> doesnt make sense

Question 4

1 0 0 0
+ 1 0 0 1
————–
0 0 0 1

= - 8
+ - 7
———–
1
what is happening here?

Answer 4

arithmetic overflow

2 negative integers (msb = 1) in 2s comp are added and equal a positive value
- 8 + - 7 = 1 –> doesnt make sense

**msb carry-out bit = 1 –> another sign of arithmetic overflow

Question 5

arithmetic overflow for unsigned integers

Answer 5

*unsigned –> only positive integers or zero (no negatives)

1) unsigned int + unsigned int = result
- result is greater than the max
value that can be represented
for that number of bits

Question 6

what happens with the msb during arithmetic overflow?

Answer 6

if the msb carry-out bit = 1 –> arithmetic overflow

Question 7

1 1^1 1 0 0
+ 0 1 0 0
—————-
0 0 0 0

what is happening here?

Answer 7

arithmetic overflow

the msb carry-out bit = 1 which means there is arithmetic overflow happening

Question 8

what is the msb carry-out bit if there is no arithmetic overflow happening?

Answer 8

0
*what we want

Question 9

int i = 10;
unsigned int j = (unsigned int) i;

what is happening here?

Answer 9

integer casting from signed to unsigned

int i is declared as a signed integer
- signed (pos, neg, zero)
unsigned int j declared as unsigned integer
- unsigned (pos and zero ONLY)
- assigning int j to the unsigned
version of int i
** casting i as an unsigned int
set as j

Question 10

short a = -1;
unsigned short b = (unsigned short)a;
printf(“b = %u\n”, b);

what is happening here?

Answer 10

short a –> signed short (pos, neg, zero)
- set to -1
unsigned short b = (unsigned short)a
- casting signed short to unsigned
short and puts that result into b
b –> expects -1 to be printed, but since it’s casted as unsigned (no neg):
65535 is printed

why? –> 0xFFFF = -1 in 2s comp

F       F         F         F  1111  1111  1111   1111
   = 65535  bc no longer represents a negative number --> becomes the largest value for unsigned ints with 16 bits

Question 11

1 0 1 1
- (8) + 2 + 1
= -5

*after casted as unsigned:
1 0 1 1
= ?

Answer 11

8 + 2 + 1 = 11

changes -8 to 8 since it is now unsigned (cannot be negative)

*msb = 1 –> not negative in this instance bc unsigned cannot represent a negative integer

Question 12

what is integer casting good for with signed data types?

Answer 12

absolute value

use when data type is signed (pos, neg, and zero)
**converts negative to positive without changing the value

Question 13

x &laquo_space;y

Answer 13

left shift
shifts x to the left by y positions

Question 14

is bitwise left shift logical, arithmetic, or both?

Answer 14

logical ONLY

Question 15

x &laquo_space;y

what are the 3 steps for bitwise left shift?

Answer 15

1) shift x to the left by y positions
2) throw away the excess bits on the left
“shifted out”
3) pad the right with 0s until full

Question 16

x : 0 1 1 0 0 0 1 0
x &laquo_space;3:

what is the final binary number?

Answer 16

0 1 1 0 0 0 1 0
0 0 0 1 0 0 0 0

= 00010000

• shifted x to the left by 3 positions starting at the LSB
  - 0 0 0 1 0
• extra bits to the left get thrown away
  - 0 1 1
• padded the open positions with 0s
  - 0 0 0

Question 17

x&raquo_space; y

Answer 17

bitwise right shift
shifts x to the right by y positions

Question 18

is bitwise right shift logical, arithmetic, or both?

Answer 18

both
logical shift –> only if x is unsigned
arithmetic shift –> only if x is signed

Question 19

what data type gets logically right shifted?

Answer 19

unsigned (pos, zero)

Question 20

what data type gets arithmetically right shifted?

Answer 20

signed (neg, pos, zero)

Question 21

x : 1 0 1 0 0 0 1 0
x&raquo_space; 2:

what is the final binary number after a logical right shift?

Answer 21

logical shift:

0 0 1 0 1 0 0 0
shift the bits to the right by 2
positions starting at the msb
- 1 0 1 0 0 0
throw away the leftover bits to the
right
- 1 0
pad the open positions with 0s
- 0 0

Question 22

x : 1 0 1 0 0 0 1 0
x&raquo_space; 2:

what is the final binary number after an arithmetic right shift?

Answer 22

arithmetic shift:

1 1 1 0 1 0 0 0
shift the bits to the right by 2
positions starting at the msb
- 1 0 1 0 0 0
throw away the leftover bits to the
right
- 1 0
pad the open positions with 1s to
preserve the sign
- 1 1

Question 23

bitwise multiplication

Answer 23

u &laquo_space;k
= u* 2^k

u &laquo_space;3
= u * 2^3

Question 24

bitwise division

Answer 24

u&raquo_space; k
= u / 2^k
*floor function –> round up

u&raquo_space; 3
= u / 2^3

Question 25

A & B

Answer 25

bitwise “and”

Question 26

A | B

Answer 26

bitwise “or”

Question 27

~A

Answer 27

bitwise “not”

Question 28

A ^ B

Answer 28

bitwise “xor”

Question 29

A & B = 1
when A = ? and B = ?

Answer 29

when both A AND B = 1

Question 30

A | B = 1
when A = ? and B = ?

Answer 30

when A = 1 or B = 1 or both = 1

Question 31

A = 1
~A = ?

Answer 31

A = 0, complement:
1 –> 0
0 –> 1

Question 32

A ^ B = 1
when A = ? and B = ?

Answer 32

when A = 1 or B = 1

• NOT BOTH –> ONLY ONE OR THE OTHER

Question 33

what is the useful application for ANDing?

Answer 33

masking certain bits and clearing certain bits

**can select certain bits to change/keep by using &

Question 34

what is the useful application for ORing?

Answer 34

setting certain bits

Question 35

what is the useful application for XORing?

Answer 35

complementing certain bits