Integer and Floating-Point Representation

How to use this guide

Try each question cold before reading the worked explanation. Rebuild the rule, then solve interleaved problems so you practise choosing a method.

1. Day 0: Recall §3.1–§3.5 and work the odd practice problems 1–23.
2. Day 1: Rebuild §4.1–§4.3 and work the even practice problems 2–24.
3. Day 3: Recall §4.4–§4.5 and work practice 25–36.
4. About day 7: Rebuild §5.1–§5.2 and work practice 37–59.
5. About day 14: Complete all five exam-style problems without notes.
6. Before the exam: Tick only skills you can demonstrate cold and revisit missed-answer references.

When stuck: write down the representation, width, and assumptions first. Then show each conversion or arithmetic step and check the result against its range or error bound.

How the chapters fit together

Integer representation explains exact bit-level meaning. Floating point extends this to a wide range of approximate real values. Numerical analysis then asks how representation and operation order affect the final answer.

3.1 Number systems and positional notation

A numeral is a compact way to write a sum of place values. Binary, octal, decimal, and hexadecimal use the same positional rule with different bases.

In plain words: a numeral is shorthand for a sum: each digit is multiplied by a power of the base, set by its position. In decimal, 352 means 3 · 100 + 5 · 10 + 2 · 1; in binary the place values are 1, 2, 4, 8, … instead. Octal and hexadecimal are short ways to write long binary strings, because one octal digit is exactly 3 bits and one hexadecimal digit exactly 4.

Expand and convert

In base b, each digit d_i contributes d_ibⁱ, where the rightmost digit has i=0. Binary digits are 0 or 1. Decimal-to-binary repeated division records remainders; read them from last to first.

Octal and hexadecimal

Because 8=2³, each octal digit corresponds to three binary digits. Because 16=2⁴, each hexadecimal digit corresponds to four bits. Group binary digits from the right and pad the leftmost group with zeroes if needed. In hexadecimal, A–F mean 10–15.

Trap: do not read a binary string as an ordinary decimal integer. Attach its base, expand it, and only then compare values.

Near miss: 10₂ looks like ten, but in binary it is 1 · 2 + 0 · 1 = 2. Read the base before the digits.

Convert a base and interpret its fixed-width pattern in the lab

3.2 Integer representations

A computer stores a fixed number of bits, not a plus or minus sign unless the encoding defines one. The same pattern can mean different values under different encodings.

In plain words: a computer stores only a row of bits; whether the row means a positive number, a negative number or something else depends on the agreed encoding. Unsigned uses every bit for size. The signed encodings give part of the range to negatives, and two’s complement, the one computers use, gives the top bit a negative weight.

Unsigned and signed ranges

An unsigned n-bit pattern represents 0 through 2ⁿ−1. Signed encodings trade positive range for negative values. The source compares sign-and-magnitude, one’s complement, two’s complement, excess (biased) notation, and binary-coded decimal (BCD). The lecture judges a signed encoding by four wishes: one zero, a balanced range, simple fast addition hardware, and no gaps in the number line.

Why the older encodings lost

Sign-and-magnitude has two zeros, and its adder must compare signs and then choose whether to add or subtract magnitudes. One’s complement still has two zeros, and its addition needs an end-around carry: a carry out of the top bit is added back into the lowest bit. For example, 0101 (+5) + 1110 (−1) gives 1 0011; adding the carry back gives 0100 (+4). Two’s complement has one zero and needs no such correction, at the price of a range that is not quite balanced.

Two’s complement and bias

To form −x in n-bit two’s complement, invert all n bits of x and add 1; discard a carry beyond the width. The minimum value −2ⁿ⁻¹ is the exception: its positive counterpart is outside the signed range, so fixed-width negation leaves the same pattern and overflows. Why inverting and adding one works: inverting x gives (2ⁿ−1)−x, because each bit becomes 1 minus itself. Adding 1 gives 2ⁿ−x, which is exactly the pattern for −x modulo 2ⁿ. Equivalently, interpret a pattern with top bit 1 by subtracting 2ⁿ from its unsigned value. In excess-B notation, actual value = stored unsigned value − B. The lecture’s three-bit excess-4 example therefore maps 000 to −4 and 111 to 3. Bias has a practical reason: the order of the true values matches the unsigned order of the stored patterns, so comparing two excess values is a plain unsigned comparison.

BCD stores decimal digits separately

In four-bit BCD, each decimal digit has its own four-bit code. For example, decimal 59 is 0101 1001 in BCD, while the ordinary binary value 59 is 00111011. BCD uses more bits but keeps each decimal digit directly readable.

Trap: do not convert all BCD bits as one binary number. Decode each four-bit group as a decimal digit.

Near miss: +8 in four-bit two’s complement looks as if it should be 1000, but 1000 is −8: the range stops at +7, so +8 cannot be stored in four bits.

Compare integer encodings in the lab

3.3 Character data

Numbers are not the only data stored as bits. A character encoding assigns numeric codes to letters, digits, punctuation, and control characters.

In plain words: text is stored as numbers too: a character encoding is a table that gives every letter, digit and symbol a numeric code. 7-bit ASCII has 128 codes, enough for basic English; Unicode extends the table to the world’s scripts, and a byte encoding says how each code is written as bytes.

ASCII and Unicode

ASCII uses seven bits, giving 128 code values. The lecture describes eight-bit extensions that use the additional 128 patterns, but those upper values depend on the particular extension. Unicode assigns code points to characters across many writing systems; its first 128 code points match ASCII. A code point and its byte encoding are related but are not the same concept.

Trap: an encoding is a mapping, not a property of the bit pattern by itself. Identify the character set and any byte encoding before decoding text.

Near miss: the character '7' looks like the number 7, but its ASCII code is 55. Arithmetic on character codes goes wrong unless you subtract the code of '0', which is 48, first.

3.4 Unsigned binary arithmetic

Binary arithmetic follows the same place-value logic as decimal arithmetic. Carries and borrows move between columns, while the fixed bit width limits which values can be stored.

In plain words: binary arithmetic works column by column like the decimal method from school, only the columns are worth 1, 2, 4, 8, …. 1 + 1 makes 2, which is written 0 with 1 carried. The difference is that a computer has a fixed number of columns, so a carry out of the last column is lost.

Add and subtract

Add each column and carry 1 when a column totals 2. For subtraction, borrow from a higher column when the current minuend bit is too small; a borrowed binary 1 is worth 2 in the current column. Subtraction can also be checked by adding the difference to the subtrahend.

Multiply and divide

Binary multiplication uses partial products, like decimal long multiplication, but each multiplier bit is only 0 or 1. Binary division uses quotient and remainder. For divisor d≠0, dividend = quotient×divisor + remainder, where 0≤remainder<divisor.

Memory hook: in binary addition, 1+1 writes 0 and carries 1. In subtraction, a borrow makes the current column worth 2 before subtracting.

Near miss: in four bits, 1100 + 0101 gives the correct sum 10001, but only four bits are kept: 0001. The column arithmetic was right; the result just does not fit.

Trace unsigned arithmetic in the lab

3.5 Two’s-complement arithmetic and overflow

Two’s complement lets the same adder perform signed addition and subtraction. Correct bit operations still need a range check: a fixed-width result can wrap to a pattern with a different signed value.

In plain words: two’s complement lets one adder handle both signs: to subtract, add the negation. The catch is the fixed range. Adding two positive numbers can go past the largest value and wrap round to a pattern that reads as negative. That is overflow, and it is not the same thing as a carry out of the top bit.

Addition, subtraction, and overflow

Add the bit patterns and discard any carry beyond the most significant bit. For subtraction, negate the subtrahend and add it to the minuend. Signed overflow occurs when the exact mathematical result lies outside the representation’s range. For addition, it occurs when two operands with the same sign produce a result with the opposite sign; operands of unlike signs cannot overflow.

Multiplication and division

The lecture notes that ordinary unsigned multiplication cannot simply be applied to signed two’s-complement patterns and read at the original width. A full product may require up to twice as many bits as the operands; retain a sufficient width and interpret the result consistently. For a simple signed multiplication, multiply magnitudes and make the result negative exactly when the operand signs differ, then check the available width. The supplied slides introduce this idea but do not give a complete signed division algorithm.

Overflow also matters for safety. The lecture warns that an integer overflow in a memory-size calculation can become a security hole, such as a buffer overflow, because too little memory gets allocated.

Sign check: do not treat discarded carry as overflow. Decode the fixed-width result and compare it with the exact mathematical result and allowed range.

Near miss: in four bits, 0111 + 0001 = 1000 has no carry out of the top bit, yet it is wrong: 7 + 1 = 8 is out of range, and 1000 reads as −8. Overflow is judged by the signs, not by the carry.

Check two’s-complement overflow in the lab

4.1 The floating-point model

Fixed-width integers from §3.5 cannot hold fractions or very large and very small values. Floating point uses a sign, a significand, and an exponent to cover those magnitudes, at the cost of exactness.

In plain words: a floating-point number is scientific notation in binary: a sign, a short run of significant digits (the significand) and an exponent that slides the point left or right. A fixed number of bits holds only so many significant digits, so most real numbers are stored as the nearest value the format can hold, and the gaps between neighbouring values grow as the numbers get larger.

Range and precision

For base β, a normalised number has the form sign × significand × β^exponent. The exponent controls scale and therefore the approximate range. The number of significand bits controls precision, or how finely nearby values can be distinguished.

Floating-point values are finite in number, and their spacing changes with magnitude.

Trap: moving the radix point changes the exponent in the opposite direction if the represented value is to stay the same.

Near miss: 12.5 × 10⁰ and 1.25 × 10¹ are the same number, but only the second is normalised, with one non-zero digit before the point. A format that allowed both would spend bit patterns on duplicate values.

Explore floating-point spacing in the lab

4.2 Binary fractions

The significand from §4.1 is a binary fraction, so its place values explain both conversion and approximation.

In plain words: binary fractions work like decimal ones with halves instead of tenths: after the binary point the places are worth 1/2, 1/4, 1/8, …. Some fractions that are short in decimal never end in binary, just as 1/3 never ends in decimal.

The first bit after the binary point has weight 2⁻¹, and each following bit has half the previous weight.

Convert binary fractions to decimal

Convert decimal fractions to binary

Repeatedly multiply the fractional part by 2.

At each step, the integer part is the next binary digit, and the new fractional part is carried into the next step.

Some fractions, such as 0.1 in decimal, repeat in binary.

A finite significand stores only an approximation of a repeating expansion.

Trap: a decimal fraction that looks short is not necessarily exact in binary.

Near miss: 0.1 has a single digit in decimal, but in binary it is 0.000110011… with the block 0011 repeating forever, so a computer can only store an approximation. 0.5 = 0.1₂, by contrast, is exact.

Convert binary fractions in the lab

4.3 Floating-point arithmetic and error

The exponent and significand must be managed during each operation.

In plain words: to multiply two floating-point numbers, multiply the significands and add the exponents. To add them, first shift the one with the smaller exponent until the exponents match, then add. Either way the result is normalised and rounded, and that rounding is where small errors creep in.

After the exact operation, the result may need normalisation and rounding to fit the available precision.

Multiplication

Addition

Before adding, express both numbers with the same exponent.

Shift the significand of the value with the smaller exponent to the right by the exponent difference.

This alignment can discard low-order digits before the addition is even performed.

Rounding, overflow, and comparison

Truncation drops extra digits and tends to bias results in one direction.

Rounding chooses a nearby representable value and usually gives a better approximation.

Exponent overflow occurs when the result is too large for the format.

Exponent underflow occurs when the result is too small for the normalised range.

The slides describe infinity or an exception for overflow, and zero or an exception for underflow in their simplified model.

IEEE formats also provide subnormal numbers near zero.

For approximate comparisons, choose a tolerance ε that fits the scale and precision of the problem.

Sign check: estimate the order of magnitude before accepting a rounded result.

Near miss: 0.1 + 0.2 looks as if it should equal 0.3, but in double precision the computed sum is 0.30000000000000004, so the test 0.1 + 0.2 == 0.3 is false. Compare floating-point results with a tolerance instead.

Explore rounding and cancellation in the lab

4.4 IEEE 754 binary formats

A shared format defines how floating-point fields are stored and how arithmetic behaves.

In plain words: IEEE 754 is the shared recipe for storing a floating-point number: one sign bit, an exponent field stored with an offset (the bias) so it needs no sign of its own, and the fraction bits after the binary point. A normalised number always starts with 1., so that 1 is not stored at all: it is the hidden bit.

The slides introduce IEEE 754 as a widely adopted standard for predictable binary floating-point arithmetic.

Single and double precision

For a normalised binary value, the leading significand bit is 1 and is omitted from the stored fraction field.

The exponent field stores a biased exponent rather than a two’s-complement exponent. Stored order then matches true order, so hardware can compare two exponents as plain unsigned integers.

Convert decimal to single precision

Decode single precision

Trap: restore the hidden leading 1 when decoding a normalised value, but do not apply that rule to a subnormal value.

Near miss: the single-precision exponent field 10000000 looks like a large exponent, but it means 128 − 127 = 1. Subtract the bias before reading the exponent.

Decode IEEE single-precision fields in the lab

4.5 Zero, subnormal numbers, infinity, and NaN

Reserved exponent patterns extend useful behaviour beyond normalised values.

In plain words: some exponent patterns are kept for special cases. An exponent of all zeros means zero or a tiny subnormal number that fills the gap just above zero; an exponent of all ones means infinity when the fraction is zero, and NaN, “not a number”, for results such as 0/0.

In single precision, exponent field zero and exponent field all ones have special interpretations.

Subnormal values fill the gap between the smallest normal value and zero, so underflow is gradual. They also keep the property x−y==0 exactly when x==y, even for very small numbers.

They can be slow: many CPUs handle them through a microcode assist or a software trap, which the lecture calls orders of magnitude slower. Flush-to-zero (FTZ) is a non-compliant mode that treats subnormals as zero. It is faster but gives up that correctness, and high-performance programs often enable it.

Infinity represents overflow results and some divisions by zero. NaN represents an operation without a real-number result, such as 0/0, √−1 or infinity−infinity.

Before IEEE 754, such operations could trap and end the program. With these values the computation continues, and the status propagates to be checked later.

Operations on infinity and NaN follow format rules, not ordinary real-number algebra in every case.

Special arithmetic examples

The sign of the infinity in signed cases depends on the operand signs. An invalid operation normally returns a quiet NaN; a trap may be enabled instead.

Trap: an all-ones exponent does not always mean infinity; inspect the fraction field to distinguish infinity from NaN.

Numerical stability and cancellation

Cancellation occurs when subtracting close stored values. The subtraction may itself be exact, yet earlier rounding in the operands can dominate the small difference. A stable method avoids needlessly creating that sensitive subtraction.

Machine epsilon and relative error

Machine epsilon is the gap from 1 to the next larger representable value. For radix β and p significant digits, ε_mach=β^1−p. Here p counts the full significand digits, including the hidden leading bit in a normalised IEEE value.

The slides bound the error by ε; under round-to-nearest the tight bound is ε/2 (= u). Both statements are true; use the slide form if the exam asks for it.

Sterbenz lemma

If x and y are positive finite floating-point values in the same radix and precision, and y/2≤x≤2y, then x−y is exactly representable when gradual underflow is supported. For example, 1.5 and 1.0 meet the condition, and their difference 0.5 is exact. This does not undo rounding that happened while x or y was computed; cancellation can expose that earlier error.

Stable quadratic roots

For ax²+bx+c=0, require a≠0 and D=b²−4ac≥0. The usual formula can subtract nearly equal quantities for one root. For D>0, choose the branch that adds magnitudes: if b≥0, set q=−½(b+√D); if b<0, set q=−½(b−√D). Then the roots are q/a and c/q. This branch also handles b=0. For D=0, use the repeated root −b/(2a), since q may be zero. These steps avoid cancellation while respecting the degenerate cases.

The notes write the same method as x₁=(−b−sgn(b)√D)/(2a) and x₂=c/(a x₁). Since q=a·x₁, c/q is the slide’s c/(a x₁). The second form comes from expanding a(x−x₁)(x−x₂): matching the constant term gives x₁x₂=c/a, which is Vieta’s relation, so x₂ needs no subtraction.

Trap: mathematical equivalence does not guarantee equal numerical accuracy. Look for subtraction of nearly equal values and avoid rounding intermediate results unnecessarily.

Fused multiply-add

A fused multiply-add evaluates a×b+c with one final rounding. Separate multiplication and addition can round the product first, then round again after addition. FMA can therefore preserve more information; its speed benefit depends on hardware. The lecture names dot products, matrix multiplication and polynomial evaluation as algorithms that gain from it.

Near miss: +0 and −0 have different bit patterns and compare as equal, yet they are not interchangeable: 1/(+0) gives +∞ while 1/(−0) gives −∞. The sign bit still matters at zero.

Explore cancellation and stable formulas in the lab

5.1 C memory and pointers

Everything so far gave meaning to bit patterns. C also lets you handle where those patterns live, because an address is itself a number you can store. That gives direct control and direct ways to fail.

In plain words: every variable lives at an address in memory, and in C that address is a value you can store: a pointer. & gives the address of a variable, and * follows an address to the value stored there. That gives direct control over memory, and direct ways to break it.

Addresses, & and *

C treats memory as a contiguous line of bytes, each with a numerical address, usually written in hexadecimal. A pointer is a variable that stores an address. The operator & gives the address of a variable, and * reads or writes the value at an address.

Pointer arithmetic and arrays

Adding n to a pointer moves n elements, not n bytes. In most expressions an array name decays to a pointer to its first element, and subscripting is defined through that pointer.

A function that receives an array actually receives a copy of the pointer to its first element. That is why arrays appear to be passed by reference.

Double pointers and function pointers

C passes every argument by value, so a function given a pointer gets a copy and cannot change the caller’s pointer. To let it do so, as an allocating function must, pass the address of the pointer. A pointer to a pointer adds one level of indirection: with int **p2 = &p1; *p2 is p1 and **p2 is the int.

Pitfalls

Trap: setting p to NULL after free only protects that one pointer. Any other copy of the address still dangles.

Near miss: after int *p = malloc(sizeof(int)); free(p); the pointer p still holds the old address, and *p may even still show the old value, but reading it is undefined behaviour: that memory no longer belongs to you.

5.2 The Python memory model

Python keeps the reference idea from §5.1 but hides the addresses and the freeing. Knowing the model tells you when a change through one name shows up through another.

In plain words: in Python a variable is a name tag tied to an object, not a box that holds a value. b = a ties a second tag to the same object. If the object can change, as a list can, a change made through one name shows up through the other; if it cannot, as a number or a string cannot, “changing” it really ties the name to a new object.

Names, objects and rebinding

A C variable is a typed box that holds a value. A Python variable is a name bound to an object that lives elsewhere, and all data, including integers and functions, are objects. The built-in id() gives an object’s identifier, which in CPython is its memory address, so you can see when two names share an object. In C, x = 20 overwrites the box. In Python, x = 20 rebinds the name to another object and leaves the old object unchanged.

Mutability and function arguments

Immutable objects (int, float, str, tuple) cannot change after creation, so operations make new objects. Mutable objects (list, dict, set) can change in place, and the change is visible through every name that refers to them.

A function receives a reference to the object, which is called pass-by-object-reference. It cannot change what the caller’s name refers to, but it can change a mutable object’s contents. With data = [1, 2, 3], a function calling some_list.append(4) leaves data as [1, 2, 3, 4].

Automatic memory management

Reference counting is the main mechanism: each object counts the references to it, and when the count reaches zero it is freed at once. These references include list slots and other containers, not only names. A generational garbage collector runs periodically to find reference cycles, such as two objects that refer to each other, which counting alone cannot free.

Trap: b = a never copies a list. To get a separate list you must ask for one, for example with list(a).

Trap: id() is unique only among objects alive at the same time, so a freed object’s identifier can come back.

Near miss: a = [1, 2]; b = a; a = a + [3] leaves b as [1, 2], but a = [1, 2]; b = a; a += [3] makes b [1, 2, 3] too. For lists, + builds a new list, while += changes the existing one in place.

Formula map

Derive it cold

Cover the explanations and rebuild each result on blank paper.

1. Base conversion: expand a binary numeral into powers of 2. §3.1
2. Binary to octal/hex: derive why groups of 3/4 bits match one digit. §3.1
3. Two’s-complement negation: show why invert-and-add-one gives 2ⁿ−x. §3.2
4. Signed range: determine the lowest and highest n-bit two’s-complement values. §3.2
5. Unsigned division: verify a quotient by reconstructing the dividend. §3.4
6. Addition overflow: explain why same-sign inputs can produce an invalid opposite-sign result. §3.5
7. Subtraction: replace A−B with A+(−B) and show the bit width at every step. §3.5
8. Binary fractions: derive each bit’s place value as a negative power of 2. §4.2
9. Decimal fraction conversion: use repeated multiplication by 2 and track the fractional remainder. §4.2
10. Multiplication: use exponent laws, then normalise. §4.3
11. Addition: align exponents, combine significands, and round. §4.3
12. Single-precision decoding: recover the sign, unbiased exponent, and hidden bit. §4.4
13. Special values: derive the classification from exponent and fraction fields. §4.5
14. Cancellation and stable roots: explain how input error is amplified and derive the product relation for the second quadratic root. §4.5
15. One-rounding FMA: compare fused evaluation with separately rounded multiply and add. §4.5
16. Machine epsilon: derive the gap near 1 from radix and significand precision. §4.5
17. Sterbenz lemma: check the ratio condition and distinguish exact subtraction from prior input rounding. §4.5
18. Pointer scaling: derive the address of a[i] from the base address and sizeof. §5.1
19. Reference trace: draw names and objects for a shared list, then a rebinding. §5.2

Explain it

Answer each why or when aloud before opening the model response.

1. Why does the rightmost binary digit have weight 1?
2. Why are octal and hexadecimal convenient ways to write binary?
3. Why do sign-and-magnitude and one’s complement have two zero patterns?
4. Why does two’s complement have one extra negative value?
5. When is carry-out discarded, and why is that not enough to detect signed overflow?
6. Why can BCD be easier for decimal display but less space-efficient?
7. Why does increasing the exponent change range more than precision?
8. Why can two nearby real values have different spacing when stored at different magnitudes?
9. Why does 0.1 decimal not have a finite binary fraction?
10. Why must exponents be aligned before adding two floating-point values?
11. Why can rounding during addition lose a small addend?
12. Why is the leading 1 omitted for normalised binary significands?
13. When would a subnormal number be used?
14. Why should an approximate comparison use a tolerance chosen for the problem?
15. Why is machine epsilon a relative-precision scale rather than one fixed absolute error for every number?
16. When can Sterbenz’s lemma say the subtraction itself is exact, and what error can still remain?
17. Why do floating-point formats store the exponent in excess notation?
18. Why can a C function not change the caller’s pointer when it is given that pointer?
19. Why does appending inside a Python function affect the caller’s list, while assigning to the parameter does not?
20. Why does Python need a cycle collector as well as reference counts?

Mixed practice

Try all 59 problems before opening the worked answers. Interleaving makes you choose the representation or method each time.

1. Convert 37₁₀ to binary and check by place value.
2. Convert 0.1101₂ to decimal.
3. Decode 1110 as a four-bit two’s-complement number.
4. How many bits of significand precision does normalised IEEE single precision provide?
5. How many bits represent one hexadecimal digit?
6. Normalise 0.000101₂ as M×2^E with 1≤M<2.
7. Encode decimal 73 in four-bit BCD.
8. Convert 0.375 decimal to binary.
9. How many values are available in seven-bit ASCII?
10. In a floating-point format, which field chiefly determines range?
11. Add 1101₂ and 0111₂ as unsigned values.
12. Multiply (3×10²)(2×10⁻⁴) and give a normalised result.
13. What is the four-bit two’s-complement range?
14. Align 7.2×10⁵ to exponent 7.
15. Convert 101101₂ to octal.
16. How many stored fraction bits does double precision have?
17. In excess-4, what value does the three-bit pattern 110 represent?
18. Classify single-precision fields S=1, E=all ones, F=0.
19. For 47÷6, give quotient and remainder and verify the division identity.
20. Convert 0.10011₂ to decimal.
21. Negate 0011 in four-bit two’s complement.
22. Use two significant decimal digits to round 8.46×10³ + 2.1×10².
23. Convert 11101010₂ to hexadecimal.
24. What is the single-precision exponent bias?
25. Why does two’s-complement addition discard a carry-out?
26. Convert decimal 0.625 to binary.
27. Write decimal 59 in BCD and ordinary binary.
28. For normalised single precision with exponent field E=130, what is the unbiased exponent?
29. Compute 7−(−6) using four-bit two’s complement. State the exact result and whether it fits.
30. State one reason truncation can be less desirable than rounding.
31. What do the first 128 Unicode code points have in common with ASCII?
32. Classify single-precision fields E=0 and F non-zero.
33. Multiply 101₂ by 11₂ as unsigned values.
34. For 1.25×2³, give the decimal value.
35. In four-bit two’s complement, add 0110 and 0011. Does it overflow?
36. How many total bits are used in double precision?
37. What is the decoded value of pattern 0111 in four-bit excess-8?
38. Give an absolute-tolerance test for a value a to be close to b using ε.
39. What is one reason BCD can be useful despite its extra storage?
40. Convert 1.101₂ to decimal.
41. Why is 1.25×2³ an exact binary value?
42. What do ±non-zero ÷ 0 and ±0 ÷ ±0 produce?
43. What happens to the exponent when multiplying two floating-point values?
44. When the exponent field is all ones and the fraction is zero, what is the value when S=0?
45. For binary single precision with 24 significand bits, give machine epsilon and unit roundoff.
46. Convert 86₁₀ to binary and verify it by place value.
47. Check Sterbenz’s condition for x=3.0 and y=2.0, then state their exact difference.
48. Does 0.2 terminate in binary? Why or why not?
49. An int pointer p holds 0x2000 and sizeof(int) is 4. What address is p+5?
50. In Python, after a = [1, 2]; b = a; b.append(3), what does print(a) show?
51. Rewrite a[2] using pointer arithmetic.
52. In Python, after x = 10; y = x; x = 20, what is y? Why?
53. Take x=100 with δ_x=+0.001 and y=99 with δ_y=−0.001. Find the relative error of x−y.
54. A C function is void clear(int *q) { q = NULL; }. Does the caller’s pointer change? What signature would change it?
55. In Python, def f(s): s = s + [1]. After t = [0]; f(t), what is t?
56. What is wrong with int *p = malloc(sizeof(int)); free(p); *p = 1;?
57. Two Python objects refer only to each other, and no name reaches them. Does reference counting free them? What does?
58. Add 0110 and 1101 in four-bit one’s complement, using the end-around carry. Decode the result.
59. A single-precision result is 2⁻¹²⁷. What is it with gradual underflow, and what under flush-to-zero?

Exam-style problems

Allow about 20 minutes for each problem. Attempt each part before opening its worked answer.

Problem 1 · Compare encodings

Encode −5 in four-bit sign-and-magnitude, one’s complement and two’s complement.

1. Write the four-bit pattern in each encoding.
2. State the range and number of zero patterns for each representation.
3. Explain why two’s complement is useful for arithmetic despite its asymmetric range.

Problem 2 · Convert, calculate, and check

In four-bit two’s complement, compute −5 + 3.

1. Write both input patterns and add them, showing any carry-out.
2. Decode the retained four-bit result and compare it with the exact sum.
3. State whether overflow occurred and explain why carry-out is not the test.

Problem 3 · Encode and decode single precision

Store 13.25 in IEEE single precision.

1. Convert 13.25 to binary.
2. Normalise it and identify sign, exponent, and stored fraction.
3. Give the exponent field and verify by decoding.

Problem 4 · Align, add, and assess precision

Add 3.4×10⁴ and 5.6×10² using two significant decimal digits.

1. Align both values to exponent 4.
2. Add the significands and round to two significant digits.
3. Compare the rounded result with the exact decimal sum and explain the source of the difference.
4. Find the relative error and compare it with the unit roundoff of this two-digit decimal format.

Problem 5 · From addresses to names

In C, int a[4] starts at 0x2000 and sizeof(int) is 4, with int *p = a;. In Python, def f(s): s.append(1); s = [] is called as t = [0]; f(t).

1. Give the address p+3 in hexadecimal, and two other ways to write the element there.
2. A C function sets its int * parameter to NULL. Does p change? Give the signature that would change it.
3. State what print(t) shows and which line of f affects it.
4. Compare how the C and Python functions reach the caller’s data.

Slips in the notes

Entries were checked against the slides, some only as extracted text, so confirm any entry against the slide itself before relying on it. “Slide” means a slide of “APDR lecture 2 extended” unless stated. Where the guide differs from the notes, this list says so; items marked as notation or simplification are not errors of value.

• Chapter 3 slide 24: the four-bit Excess-8 row for 0111 is printed as 1; stored value 7 minus bias 8 gives −1. §3.2
• Slide 3 against slide 5 (uneven claim): a balanced range is listed as desirable and only the older encodings are said to fail. Two’s complement also misses it, as slide 5 itself shows. §3.2
• Slide 6: the C example says assigning 127+1 to signed char wraps to −128. That is not guaranteed by C: integer promotion computes 128 as int, then converting an out-of-range value to signed char has an implementation-defined result or signal. Do not generalise this example as signed integer overflow being defined wraparound. See clauses 6.3.1.1 and 6.3.1.3 of the WG14 C standard draft N1570. §3.5
• Slide 17 (simplification): the performance cost of subnormals depends on the CPU and its mode. The guide reports it as the lecture’s statement. §4.5
• Slides 18–19: ε is called the upper bound on relative rounding error. That holds, but under round-to-nearest the tight bound is ε/2, which the guide calls u. Slide 19’s “any real number x that can be represented” means any x within range. §4.5
• Slide 21: Sterbenz’s lemma is stated without its conditions. The guide adds positive values of the same format, and gradual underflow. §4.5
• Slide 22: x₁ with sgn(b) breaks at b=0 if sgn(0)=0, because it gives x₁=0 and then c/(a·0). The slide also leaves a≠0 and D≥0 unstated. The guide’s branch treats b=0 as b≥0 and requires both. §4.5
• Slide 26: “int arr;” declares one int, yet the text calls it an array and labels p+1 and p+3 both “address of arr”. The brackets were probably lost; the guide reads int a[10], a[1] and a[3]. §5.1
• Slide 27: “int int_array;” and “struct Point pt_array;” have probably lost their sizes in the same way. “sizeof(Point)” needs “struct Point” in C, and the sizes 4 and 16 assume a platform. §5.1
• Slide 28: “array is equivalent to array” is a tautology. It reads as if it should be array equivalent to &array[0]. §5.1
• Slide 32: dereferencing NULL is said to cause a crash always. It is undefined behaviour; a crash is only typical. The fix printed as “p = some ariable” should be p = &some_variable. §5.1
• Slides 35 and 38: “a =”, “data =” and the printed outputs have lost their list literals. The guide supplies [1, 2, 3], which is an assumption, chosen to fit the append(4). §5.2
• Slide 39 (simplification): the count is described as names that refer to an object. It counts all references, including list slots. §5.2

Self-check

Tick a skill only in a later session, at least one day after studying, when you can demonstrate it without notes.

• Expand numbers by powers of their base and convert binary groups to octal and hexadecimal. (1, 5, 15, 23, 46)
• State signed and unsigned ranges from a bit width, and decode patterns in each signed encoding, including excess-B. (3, 13, 17, 37)
• Negate a two’s-complement value at fixed width, and subtract by negating and adding. (21, 29)
• Write and read decimal digits in BCD, and relate ASCII and Unicode code points. (7, 9, 27, 31, 39)
• Add binary values with correct carries, and verify a quotient and remainder. (11, 19, 33)
• Add signed values and detect overflow. (25, 35, 58)
• Explain how significand and exponent set precision and range, and normalise a value without changing its magnitude. (6, 10)
• Convert fractions between binary and decimal, and explain why some decimal fractions repeat in binary. (2, 8, 20, 26, 40, 48)
• Multiply floating-point numbers, align exponents before adding, and round to a stated precision. (12, 14, 22, 30)
• State an approximate comparison using a tolerance. (38)
• State the single-precision field sizes and bias, and encode and decode a normalised value. (4, 24, 28, exam 3)
• Classify subnormal and special-value patterns and predict basic infinity and NaN arithmetic. (18, 32, 42, 44, 59)
• Calculate machine epsilon and unit roundoff, and apply Sterbenz’s condition. (45, 47)
• Trace pointers, scaled addresses and common C memory errors. (49, 51, 54, 56, exam 5)
• Trace Python names, rebinding, mutability and reclamation. (50, 52, 55, 57, exam 5)
• Rebuild the derivations from the formula list.
• Complete exam problems 1 to 5 with checks.