# Week 5 Quiz: Integers, Floats, Doubles, and IEEE 754 ## Instructions Choose the best answer for each question. There is only one correct answer per question. --- ## Questions ### Question 1 What is the valid value range of `int8_t` (a signed 8-bit integer)? A) 0 to 255 B) 0 to 127 C) -128 to 127 D) -256 to 255 > 📖 **Reference:** Week 5, Part 1 – "Signed vs Unsigned Integers" (table: `int8_t` range is -128 to 127) **Correct Answer: C** --- ### Question 2 How is the value `-42` stored in a single byte using two's complement? A) `0x2A` — the sign is tracked separately by the CPU B) `0xD6` — the CPU flips all bits of `42` (`0x2A`) and adds `1` C) `0xAA` — negative values always have the pattern `1010...` in binary D) `0x42` — the value is stored identically to positive `42` > 📖 **Reference:** Week 5, Part 1 – "The Integer Variables" (two's complement: flip bits of `0x2A` and add 1 = `0xD6`) **Correct Answer: B** --- ### Question 3 In IEEE 754 single-precision (32-bit float), how are the 32 bits divided among sign, exponent, and mantissa? A) 1 sign bit, 11 exponent bits, 20 mantissa bits B) 1 sign bit, 8 exponent bits, 23 mantissa bits C) 2 sign bits, 8 exponent bits, 22 mantissa bits D) 1 sign bit, 10 exponent bits, 21 mantissa bits > 📖 **Reference:** Week 5, Part 2 – "What is a Float?" (IEEE 754 Single-Precision diagram: 1 sign, 8 exponent, 23 mantissa) **Correct Answer: B** --- ### Question 4 Why does `printf` receive a 64-bit `double` even when the source code declares a `float` variable? A) The Pico 2's ARM Cortex-M33 does not have a floating-point unit B) Ghidra automatically converts floats to doubles during analysis C) The C standard requires `float` arguments to variadic functions like `printf` to be promoted to `double` D) The `%f` format specifier forces the compiler to use 64-bit precision > 📖 **Reference:** Week 5, Part 2.7, Step 14 – "Understand the Float Encoding" (C standard requires float arguments to variadic functions are promoted to double) **Correct Answer: C** --- ### Question 5 What is the exponent bias for IEEE 754 double-precision, and why is it 1023? A) 127 — because the exponent field is 8 bits and $(2^8 / 2) - 1 = 127$ B) 1023 — because the exponent field is 11 bits and $(2^{11} / 2) - 1 = 1023$ C) 1024 — because $2^{10} = 1024$ and the exponent uses 10 bits D) 2047 — because $2^{11} - 1 = 2047$ is the maximum 11-bit value > 📖 **Reference:** Week 5, Part 2.7, Step 15 – "Why 1023?" callout (exponent is 11 bits, $2^{11} = 2048$, midpoint = $(2048 / 2) - 1 = 1023$) **Correct Answer: B** --- ### Question 6 On the ARM Cortex-M33, how is a 64-bit double passed to a function like `printf`? A) In a single 64-bit register `r0` B) On the stack as an 8-byte value C) In two 32-bit registers: `r2` (low 32 bits) and `r3` (high 32 bits) D) In the floating-point register `d0` > 📖 **Reference:** Week 5, Part 2.7, Step 14 – "A 64-bit double is passed in two 32-bit registers" (table: r2 = low, r3 = high) **Correct Answer: C** --- ### Question 7 What does the `mcrr p0, #4, r4, r5, c0` instruction do on the RP2350? A) It reads the current GPIO pin state into registers r4 and r5 B) It writes to the GPIO coprocessor to set a pin's output value (r4 = pin, r5 = value) C) It configures the GPIO function select register for SIO mode D) It copies data between two ARM general-purpose registers > 📖 **Reference:** Week 5, Part 1 – "The Blink Loop with Inline Assembly" (coprocessor register `c0` controls output value, r5 = 1 drives HIGH, r5 = 0 drives LOW) **Correct Answer: B** --- ### Question 8 When configuring a GPIO pin with inline assembly, what value is written to the FUNCSEL field to select SIO (Single-cycle I/O) mode? A) `0` — default reset value B) `3` — UART function C) `5` — SIO function D) `31` — null function (disabled) > 📖 **Reference:** Week 5, Part 1 – "GPIO Initialization with Inline Assembly" (Step 2: clears FUNCSEL bits and sets to `5` for SIO) **Correct Answer: C** --- ### Question 9 What is the key difference between a `float` (32-bit) and a `double` (64-bit) in terms of decimal precision? A) A float has ~15 digits precision; a double has ~7 digits precision B) A float has ~7 digits precision; a double has ~15 digits precision C) Both have the same precision; doubles just have a larger range D) A float has exact precision; a double introduces rounding errors > 📖 **Reference:** Week 5, Part 3 – "Float vs Double - Key Differences" (table: float ~7 decimal digits, double ~15 decimal digits) **Correct Answer: B** --- ### Question 10 When patching the double `42.5` to `99.0` in Ghidra, only the high word (`r3`) needed to change. When patching `42.52525` to `99.99`, **both** words needed to change. Why? A) The value `99.99` is larger than `99.0`, so it needs more bits to store B) The value `99.0` has a clean fractional part (`.0`) so the low word is all zeros, but `99.99` has a repeating binary fraction that requires non-zero bits in the low 32 bits C) Ghidra encodes doubles differently depending on the number of decimal places D) The compiler uses a different instruction format for values with more decimal digits > 📖 **Reference:** Week 5, Part 3.95 – "Key takeaway" (clean values like 42.5 only need one patch; messy fractions like 42.52525 need two) **Correct Answer: B** --- ## Answer Key 1. C - `int8_t` is a signed 8-bit integer with range -128 to 127 2. B - Two's complement: flip all bits of `0x2A` (42) and add 1 → `0xD6` 3. B - IEEE 754 single-precision: 1 sign bit, 8 exponent bits, 23 mantissa bits 4. C - The C standard requires `float` arguments to variadic functions (`printf`) to be promoted to `double` 5. B - The 11-bit exponent gives 2048 values; the midpoint $(2^{11} / 2) - 1 = 1023$ is the bias 6. C - 64-bit doubles are split across `r2` (low 32 bits) and `r3` (high 32 bits) on ARM Cortex-M33 7. B - `mcrr p0, #4, r4, r5, c0` writes to the GPIO coprocessor's output register (c0), setting pin r4 to value r5 8. C - FUNCSEL = 5 selects SIO mode for software-controlled GPIO 9. B - Float has ~7 decimal digits precision; double has ~15 decimal digits precision 10. B - Clean fractions (like `.0`) produce a zero low word; repeating binary fractions (like `.99`) need all 52 mantissa bits, making both words non-zero --- ## Scoring Guide - **10 correct**: Excellent! You have a strong grasp of Week 5 concepts - **8-9 correct**: Very good! Review the topics you missed - **6-7 correct**: Good start. Go back and review the key concepts - **5 or fewer**: Review the Week 5 material again and try the practice exercises --- ## Topics Covered This quiz tests your understanding of: - Signed vs unsigned integers: `uint8_t` and `int8_t` ranges - Two's complement encoding of negative numbers - IEEE 754 single-precision (32-bit) field layout - Float-to-double promotion in C variadic functions - IEEE 754 double-precision exponent bias (1023) and its derivation - ARM Cortex-M33 register pairs (`r2:r3`) for 64-bit doubles - GPIO coprocessor instruction `mcrr` for pin output control - FUNCSEL field and SIO mode selection - Float vs double precision differences - Patching strategy: clean fractions (one word) vs repeating fractions (two words)