# CS 211 - Lecture 09 - Fixed and Floating Point Representations

Bernhard Firner

2025-09-30

---

## Review

* Stacks and loop representation of recursion
* Bit fields
* Unions

---

## Recursion to Loop Example

```C
#include <stdio.h>
#include <stdlib.h>

#include "llu_stack.h"

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("Give me the nth fibonocci number that you want to see.");
        return 0;
    }

int n = atoi(argv[1]);

Stack s = newStack(10);
    push(&s, n);

unsigned long long sum = 0;
    while (len(s) > 0) {
        unsigned long long next = pop(&s);
        if (next == 0 || next == 1) {
            sum += next;
        }
        else {
            push(&s, next - 1);
            push(&s, next - 2);
        }
    }

freeStack(s);

printf("The %i fibonocci number is %llu\n", n, sum);
    return 0;
}
```

---

## HW1 Union Version

```C
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct Bits Bits;
struct Bits {
    bool a : 1;
    bool b : 1;
    bool c : 1;
    bool d : 1;
    bool e : 1;
    bool f : 1;
    bool g : 1;
    bool h : 1;
};

typedef union LLUBits LLUBits;
union LLUBits {
    // 8 bytes to a long long
    Bits bits[8];
    long long number;
};

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("Give me a number!");
        return 1;
    }

char* endptr = argv[1];
    LLUBits value;
    value.number = strtoll(argv[1], &endptr, 10);

for (int i = sizeof(LLUBits)-1; i >= 0; --i) {
        printf("%i", value.bits[i].h);
        printf("%i", value.bits[i].g);
        printf("%i", value.bits[i].f);
        printf("%i", value.bits[i].e);
        printf("%i", value.bits[i].d);
        printf("%i", value.bits[i].c);
        printf("%i", value.bits[i].b);
        printf("%i", value.bits[i].a);
        printf(" ");
    }
    printf("\n");

return 0;
}
```

---

## Floating Point Union

```C
#include <stdio.h>
#include <stdlib.h>

typedef struct FloatBits FloatBits;
struct FloatBits {
    unsigned int significand : 23;
    unsigned int exponent : 8;
    unsigned int sign : 1;
};

typedef union FloatIntBits FloatIntBits;
union FloatIntBits {
    float the_float;
    int the_int;
    FloatBits the_bits;
};

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("Give me a float!");
        return 0;
    }

FloatIntBits fib = {.the_float = atof(argv[1])};

printf("The size of fib is %lu\n", sizeof(fib));
    printf("The size of FloatBits is %lu\n", sizeof(FloatBits));
    printf("The sign is %u, the exponent is %u, and the significand is %u\n", fib.the_bits.sign, fib.the_bits.exponent, fib.the_bits.significand);

printf("%f as an int is %i\n", fib.the_float, fib.the_int);
    return 0;
}
```

---

## Something Simpler

* Before diving into floating point numbers
  * Floats can be confusing
* We'll look at a simpler idea
  * Fixed Point values

---

## Fixed Point Values

* Let's say you had to represent values with $1/2$ steps
  * 0.5, 1, 1.5, 2, ...
* What's the easiest way?
  * Just take an int and use the smallest bit for $1/2$

```C
int value;
...
if (value & 0x1) {
    printf("Value is %i.5\n", value>>1);
}
else {
    printf("Value is %i\n", value>>1);
}
```

---

## 4 bits of fraction

* Let's make this slightly useful
  * Take a 32 bit int and dedicate 4 to the fraction
* What is the smallest increment?
  * $1 / 2^4$, of 0.0625
* other $2^{28}$ used as a regular int
  * $-2^{27}$ to $2^{27}-1$

---

## Fixed Point Type

```C
typedef struct FixedFourStorage FixedFourStorage;
struct FixedFourStorage {
    unsigned int fraction : 4;
    unsigned int value : 28;
};

// If 0x1000 is 0.5, then 0x0001 must be 0.0625
// Always print with width 4 when using printf
const unsigned int ffour_fraction = 625;

typedef union FixedFour FixedFour;
union FixedFour {
    FixedFourStorage storage;
    // Used for math
    unsigned int raw;
};
```

---

## Math

* Addition and subtraction are unchanged
* But things go wrong if we multiply or divide
  * 0.5 * 0.5 should be 0.25
  * But b1000 * b1000 won't be b0100
* Why? Because multiply treats the lowest bit as the 1s place, but it should be the 0.0625s place
* Solution? Right shift by 4 after multiplication

---

## Fixed Point Multiply

```C
// Create 10.5 and 0.5. When multiplying, rescale afterwards
FixedFour ff = {.storage.value = 10, .storage.fraction = 1};
FixedFour other = {.storage.value = 0, .storage.fraction = 0x1<<3};
ff.raw = (ff.raw * other.raw) >> 4;
```

* Division is similar, but we need to upscale first before dividing or we lose precision
  * `result.raw = ((a.raw << 4) / b.raw);`

---

## Fixed Point Math

```C
#include <stdio.h>
#include <stdlib.h>

typedef struct FixedFourStorage FixedFourStorage;
struct FixedFourStorage {
    unsigned int fraction : 4;
    unsigned int value : 28;
};

// If 0x1000 is 0.5, then 0x0001 must be 0.0625
// Always print with width 4 when using printf
const unsigned int ffour_fraction = 625;

typedef union FixedFour FixedFour;
union FixedFour {
    FixedFourStorage storage;
    // Used for math
    unsigned int raw;
};

int main(void) {
    FixedFour ff = {.storage.value = 10, .storage.fraction = 1};

// Print with %04u means pad with leading zeros to width 4
    printf("ff value is %i.%04u\n", ff.storage.value, ff.storage.fraction * ffour_fraction);

FixedFour other = {.storage.value = 10, .storage.fraction = 1};
    ff.raw = ff.raw + other.raw;
    printf("Adding with another value.\n");
    printf("ff value is %i.%04u\n", ff.storage.value, ff.storage.fraction * ffour_fraction);

printf("Tripling.\n");
    ff.raw *= 3;
    printf("ff value is %i.%04u\n", ff.storage.value, ff.storage.fraction * ffour_fraction);

printf("Dividing by 7.\n");
    ff.raw /= 7;
    printf("ff value is %i.%04u\n", ff.storage.value, ff.storage.fraction * ffour_fraction);

printf("Multiplying by the other fixed point with value 0.5, then rescaling.\n");
    other.storage.value = 0;
    other.storage.fraction = 0x1 << 3;
    ff.raw = (ff.raw * other.raw) >> 4;
    printf("ff value is %i.%04u\n", ff.storage.value, ff.storage.fraction * ffour_fraction);

printf("Multiplying by -1.\n");
    other.storage.value = -1;
    other.storage.fraction = 0;
    ff.raw = (ff.raw * other.raw) >> 4;
    printf("ff value is %i.%04u\n", ff.storage.value, ff.storage.fraction * ffour_fraction);

return 0;
}
```

---

## Output

<pre>
ff value is 10.0625
Adding with another value.
ff value is 20.1250
Tripling.
ff value is 60.3750
Dividing by 7.
ff value is 8.6250
Multiplying by the other fixed point with value 0.5, then rescaling.
ff value is 4.3125
Multiplying by -1.
ff value is 16777211.6875
</pre>

---

## Negatives

* Our math fails on negatives
* When we right shift, we always lose the upper bits
  * Obviously wrong with negative numbers
* So let's add a sign bit

---

## Negative Divisions

* Speaking of sign bits
  * When we divide, we don't want the math to use the MSB
  * It changes the number, and thus the math
  * So we have to mask it out before dividing

---

## Fixed

```C
#include <stdio.h>
#include <stdlib.h>

typedef struct FixedFourStorage FixedFourStorage;
struct FixedFourStorage {
    unsigned int fraction : 4;
    unsigned int value : 27;
    unsigned int sign : 1;
};

typedef union FixedFour FixedFour;
union FixedFour {
    FixedFourStorage storage;
    // Used for math
    unsigned int raw;
};

FixedFour FixedFourAdd(FixedFour a, FixedFour b) {
    FixedFour result;
    result.raw = a.raw + b.raw;
    return result;
}

FixedFour FixedFourMultiply(FixedFour a, FixedFour b) {
    FixedFour result;
    // Mask out the sign bit
    unsigned int mask = 0x7FFFFFFF;
    result.raw = ((a.raw&mask) * (b.raw&mask)) >> 4;
    // Use xor to get the sign. Overwrite whatever the multiply operation put there
    result.storage.sign = a.storage.sign ^ b.storage.sign;
    return result;
}

FixedFour FixedFourDivide(FixedFour a, FixedFour b) {
    FixedFour result;
    // Mask out the sign bit
    unsigned int mask = 0x7FFFFFFF;
    // We are going to lose precision, so shift before dividing
    result.raw = ((a.raw << 4) / (mask&b.raw));
    // Use xor to get the sign. Overwrite whatever the divide operation put there
    result.storage.sign = a.storage.sign ^ b.storage.sign;
    return result;
}

int getFFValue(FixedFour a) {
    if (a.storage.sign) {
        return -1 * a.storage.value;
    }
    else {
        return a.storage.value;
    }
}

int getFFFraction(FixedFour a) {
    // If 0x1000 is 0.5, then 0x0001 must be 0.0625
    // Always print with width 4 when using printf
    const unsigned int ffour_fraction = 625;
    return a.storage.fraction * ffour_fraction;
}

int main(void) {
    FixedFour ff = {.storage.value = 10, .storage.fraction = 1};

// Print with %04u means pad with leading zeros to width 4
    printf("ff value is %i.%04u\n", getFFValue(ff), getFFFraction(ff));

FixedFour other = {.storage.value = 10, .storage.fraction = 1};
    ff = FixedFourAdd(ff, other);
    printf("Adding with another value.\n");
    printf("ff value is %i.%04u\n", getFFValue(ff), getFFFraction(ff));

printf("Tripling.\n");
    other.storage.value = 3;
    other.storage.fraction = 0;
    ff = FixedFourMultiply(ff, other);
    printf("ff value is %i.%04u\n", getFFValue(ff), getFFFraction(ff));

printf("Dividing by 7.\n");
    other.storage.value = 7;
    other.storage.fraction = 0;
    ff = FixedFourDivide(ff, other);
    printf("ff value is %i.%04u\n", getFFValue(ff), getFFFraction(ff));

printf("Multiplying by -1.\n");
    other.storage.sign = 1;
    other.storage.value = 1;
    other.storage.fraction = 0;
    ff = FixedFourMultiply(ff, other);
    printf("ff value is %i.%04u\n", getFFValue(ff), getFFFraction(ff));

printf("Dividing by -0.5\n");
    other.storage.sign = 1;
    other.storage.value = 0;
    other.storage.fraction = 0x1<<3;
    ff = FixedFourDivide(ff, other);
    printf("ff value is %i.%04u\n", getFFValue(ff), getFFFraction(ff));

return 0;
}
```

---

## Outputs

```C
ff value is 10.0625
Adding with another value.
ff value is 20.1250
Tripling.
ff value is 60.3750
Dividing by 7.
ff value is 8.6250
Multiplying by -1.
ff value is -8.6250
Dividing by -0.5
ff value is 17.2500
```

---

## Good Enough?

* No
  * But okay in systems without floating point hardware
  * Operations are at the speed of int operations, with a bit of extra bit handling

---

## Disadvantages

* Poor range; less than an int
* Poor precision; gave up 4 bits for increments of 0.0625
* So we use floating point numbers instead
  * More complicated than fixed point
  * Should be easier to understand if you understand fixed points

---

## Improvements

* What if we stored two numbers
  * One will be the current scale
  * And the other will be the number of increments along that scale

---

## Floating Point Numbers

* [IEEE 754 Standard](https://en.wikipedia.org/wiki/IEEE_754)
  * Imagine the nightmare if different machines represented numbers differently?
  * The way people lived before 1980's
* Three sections
  * Sign: 0 or 1
  * Exponent
  * Significand (also called mantissa)
* 32 bit (full precision) and 64 bit (double precision) most common

<table>
<tr><td>Sign</td><td colspan="8">Exponent</td><td colspan="23">Significand</td></tr>
<tr><td>31</td><td>30</td><td colspan="6">...</td><td>23</td><td colspan="21">22</td><td>...</td><td>0</td></tr>
</table>

---

## FP Representation

* Numbers won't be as straightforward as int or fixed points
  * Other than the sign field
* Going to stick with 32 bit (full precision) for examples
  * Consistent with other precisions, just add more bits to fields
* In general, we'll represent numbers as
  * value = $(-1)^{sign} \times Significand \times 2^{exponent}$

---

## Why?

* The $2^{exponent}$ part allows us to choose the increment of the significand
* This trades off precision for range
  * As the exponent grows, we lower precision but gain range
  * So representations are more precise at lower exponents
  * Going to allow the exponent to be negative, for values between 0 and 1

---

## Special Cases

* We also want to have some "special" numbers
* Can divide floating point numbers into different types
  * Two special cases
    * NaN (not a number)
    * Infinity
  * normalized
  * subnormal
    * Including 0, when all memory is set to 0

---

## NaNs and Infinity

* Positive and negative infinity
  * Set all exponent values to 1
  * All significand values to 0

---

## Inifinities

```C
#include <stdio.h>
#include <stdlib.h>

typedef struct FloatBits FloatBits;
struct FloatBits {
    unsigned int significand : 23;
    unsigned int exponent : 8;
    unsigned int sign : 1;
};

typedef union FloatIntBits FloatIntBits;
union FloatIntBits {
    float the_float;
    int the_int;
    FloatBits the_bits;
};

int main(void) {
    FloatIntBits fib = {.the_int = 0};

printf("All 0s is %f\n", fib.the_float);

fib.the_bits.significand = 0;
    fib.the_bits.exponent = 0xFF;
    fib.the_bits.sign = 0;
    printf("Fields are 0x%x, 0x%x, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent, fib.the_bits.significand, fib.the_float);

fib.the_bits.significand = 0;
    fib.the_bits.exponent = 0xFF;
    fib.the_bits.sign = 1;
    printf("Fields are 0x%x, 0x%x, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent, fib.the_bits.significand, fib.the_float);
    return 0;

fib.the_float = 1.0 / 0.0;
    printf("Fields are 0x%x, 0x%x, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent, fib.the_bits.significand, fib.the_float);
    return 0;
}
```

---

## Output

<pre>
All 0s is 0.000000
Fields are 0x0, 0xff, 0x0; float is inf
Fields are 0x1, 0xff, 0x0; float is -inf
Fields are 0x0, 0xff, 0x0; float is inf
</pre>

---

## Not a Numbers

* All exponents bits set
  * Any significand bits set
* Why?
  * Need a way to indicate math errors
  * 0/0
  * $\sqrt{-1}$

---

## NaNs

```C
#include <stdio.h>
#include <stdlib.h>

typedef struct FloatBits FloatBits;
struct FloatBits {
    unsigned int significand : 23;
    unsigned int exponent : 8;
    unsigned int sign : 1;
};

typedef union FloatIntBits FloatIntBits;
union FloatIntBits {
    float the_float;
    int the_int;
    FloatBits the_bits;
};

int main(void) {
    FloatIntBits fib = {.the_int = 0};

printf("All 0s is %f\n", fib.the_float);

fib.the_bits.significand = 1;
    fib.the_bits.exponent = 0xFF;
    fib.the_bits.sign = 0;
    printf("Fields are 0x%x, 0x%x, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent, fib.the_bits.significand, fib.the_float);

fib.the_bits.significand = 0x7FFFFF;
    fib.the_bits.exponent = 0xFF;
    fib.the_bits.sign = 1;
    printf("Fields are 0x%x, 0x%x, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent, fib.the_bits.significand, fib.the_float);

fib.the_float = 0.0 / 0.0;
    printf("Fields are 0x%x, 0x%x, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent, fib.the_bits.significand, fib.the_float);
    return 0;
}
```

---

## Output

<pre>
All 0s is 0.000000
Fields are 0x0, 0xff, 0x1; float is nan
Fields are 0x1, 0xff, 0x7fffff; float is -nan
Fields are 0x1, 0xff, 0x400000; float is -nan
</pre>

---

## Signalling NaN

* Sometimes you may want your program to stop when you hit NaNs
* CPUs can set a flag when this happens, allowing you to stop
* For "quiet" NaNs, only set the most significant bit of the significand
  * 0x1 << 22 for 32 bit floats
* For signalling NaNs set any of the other bits
  * Any of 0x3FFFFF for 32 bit floats

---

## Checking exception registers

* We could do this in assembly
  * But C already has a library for it in <fenv.h>
  * Need to link to a new library when compiling
  * gcc program.c -lm -o program
  * -lm is for "libmath"

---

## Register Example

```C
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <fenv.h>

typedef struct FloatBits FloatBits;
struct FloatBits {
    unsigned int significand : 23;
    unsigned int exponent : 8;
    unsigned int sign : 1;
};

typedef union FloatIntBits FloatIntBits;
union FloatIntBits {
    float the_float;
    int the_int;
    FloatBits the_bits;
};

typedef struct FPStatus FPStatus;
struct FPStatus {
    bool invalid : 1;
    bool subnormal : 1;
    bool div_by_0 : 1;
    bool overflow : 1;
    bool underflow : 1;
    bool fp_inexact : 1;
};

typedef union FPStatBuffer FPStatBuffer;
union FPStatBuffer {
    // The floating point status register is 16 bits long
    unsigned short value;
    FPStatus status;
};

int main(void) {
    FloatIntBits fib = {.the_int = 0};
    fib.the_bits.significand = 0x1 << 22;
    fib.the_bits.exponent = 0xFF;
    fib.the_bits.sign = 0;

printf("%f + %f is %f\n", fib.the_float, 3.14, fib.the_float + 3.14);

// Check for floating point exception
    if (fetestexcept(FE_INVALID)) {
        printf("A floating point exception occurred.\n");
    }
    // Clear any exceptions
    feclearexcept(FE_ALL_EXCEPT);

// lower 22 bits set in significand for signalling NaN
    fib.the_bits.significand = 0x3FFFFF;
    fib.the_bits.exponent = 0xFF;
    fib.the_bits.sign = 1;

printf("%f + %f is %f\n", fib.the_float, 3.14, fib.the_float + 3.14);

// Check for floating point exception
    if (fetestexcept(FE_INVALID)) {
        printf("A floating point exception occurred.\n");
    }
    // Clear any exceptions
    feclearexcept(FE_ALL_EXCEPT);

return 0;
}
```

---

## Output

<pre>
nan + 3.140000 is nan
-nan + 3.140000 is -nan
A floating point exception occurred.
</pre>

---

## Pause

* You don't need to memorize every detail of floating point numbers
* But recognize that floating point numbers are far more complicated than integers
* The way we represent numbers (coming next!) is the important part

---

## Exponent Range

* All 0s in the exponent is already reserved
  * So, for actual numbers, the smallest exponent value is 0x1
* And we need negative exponents
* Solution: subtract a bias of $2^{k-1}$, or $2^{k-1} - 1$ if using NaN and inf values
  * Where $k$ is the number of bits in the exponent field
  * b01111111 (or 0x7F) for 32 bit floats
* So setting the exponent field to 0x7F gives an exponent value of 0
* Exponent value begins at $1 - 2^{k-1}$ and goes to $2^{k-1}$
  * -126 to 127 for 32 bit floats

---

## Subnormal Numbers

* When the exponent bits are 0, this is like a fixed point format
  * You would expect the exponent to be $0 - bias$
  * However, the equation is different than for normal numbers
* Each step in the significand is a step of the minimum increment
* value = $(-1)^{sign} \times 2^{1-bias} \times (\frac{Significand}{2^{23}})$

---

## Subnormal Example

```C
#include <stdio.h>
#include <stdlib.h>

typedef struct FloatBits FloatBits;
struct FloatBits {
    unsigned int significand : 23;
    unsigned int exponent : 8;
    unsigned int sign : 1;
};

typedef union FloatIntBits FloatIntBits;
union FloatIntBits {
    float the_float;
    int the_int;
    FloatBits the_bits;
};

int main(void) {
    FloatIntBits fib = {.the_int = 0};

// Special 0 values
    fib.the_bits.significand = 0;
    fib.the_bits.exponent = 0;
    fib.the_bits.sign = 0;
    printf("Fields are B=0x%x, E=%i, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_bits.significand = 0;
    fib.the_bits.exponent = 0;
    fib.the_bits.sign = 1;
    printf("Fields are B=0x%x, E=%i, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

// For subnormal numbers, exponent is 1 - bias, 0x7F
    fib.the_bits.significand = 0;
    fib.the_bits.exponent = 0x7F;
    fib.the_bits.sign = 0;
    printf("Fields are B=0x%x, E=%i, 0 + 0x%x; float is %.10f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_bits.significand = 1;
    printf("Fields are B=0x%x, E=%i, 0 + 0x%x; float is %.10f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

// Maximum value for a subnormal number
    fib.the_bits.significand = 0x7FFFFF;
    fib.the_bits.sign = 0;
    printf("Fields are B=0x%x, E=%i, 0 + 0x%x; float is %.10f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

return 0;
}
```

---

## Outputs

<pre>
Fields are B=0x0, E=-127, 0x0; float is 0.000000
Fields are B=0x1, E=-127, 0x0; float is -0.000000
Fields are B=0x0, E=0, 0 + 0x0/(2^23); float is 1.0000000000
Fields are B=0x0, E=0, 0 + 0x1/(2^23); float is 1.0000001192
Fields are B=0x0, E=0, 0 + 0x7fffff/(2^23); float is 1.9999998808
</pre>

* Note that I increased the printing precision
  * `%.10f` in printf

---

## Normalized Numbers

* We don't want to waste space representing anything in the subnormal range
  * Where exponent bits = 0
* So when exponent bits > 0, we are in the normal number range
  * Begin with an implied 1 in the equation
  * This makes the first normal number $\frac{1}{significand range}$ greater than the largest subnormal
  * Simplifies comparisons, too, as we'll see
  * Also efficient! The range after each increment of the exponent won't overlap with the previous range

---

## Normalized Numbers

* value = $(-1)^{sign} \times 2^{exponent - 0x7F} \times (1+\frac{Significand}{2^{23}})$

---

## Some values

```C
#include <stdio.h>
#include <stdlib.h>

typedef struct FloatBits FloatBits;
struct FloatBits {
    unsigned int significand : 23;
    unsigned int exponent : 8;
    unsigned int sign : 1;
};

typedef union FloatIntBits FloatIntBits;
union FloatIntBits {
    float the_float;
    int the_int;
    FloatBits the_bits;
};

int main(void) {
    FloatIntBits fib = {.the_int = 0};

// Powers of 2
    fib.the_bits.significand = 0;
    fib.the_bits.exponent = 1;
    fib.the_bits.sign = 0;
    printf("Fields are B=0x%x, E=%i, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 1.0;
    printf("Fields are B=0x%x, E=%i, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 2.0;
    printf("Fields are B=0x%x, E=%i, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 8.0;
    printf("Fields are B=0x%x, E=%i, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 1024.0;
    printf("Fields are B=0x%x, E=%i, 0x%x; float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

return 0;
}
```

---

## Output

<pre>
Fields are B=0x0, E=-126, 1+0x0; float is 0.000000
Fields are B=0x0, E=0, 1+0x0; float is 1.000000
Fields are B=0x0, E=1, 1+0x0; float is 2.000000
Fields are B=0x0, E=3, 1+0x0; float is 8.000000
Fields are B=0x0, E=10, 1+0x0; float is 1024.000000
</pre>

---

## Now with Significand

```C

#include <stdio.h>
#include <stdlib.h>

typedef struct FloatBits FloatBits;
struct FloatBits {
    unsigned int significand : 23;
    unsigned int exponent : 8;
    unsigned int sign : 1;
};

typedef union FloatIntBits FloatIntBits;
union FloatIntBits {
    float the_float;
    int the_int;
    FloatBits the_bits;
};

int main(void) {
    FloatIntBits fib = {.the_int = 0};

// Powers of 2
    fib.the_bits.significand = 0;
    fib.the_bits.exponent = 1;
    fib.the_bits.sign = 0;
    printf("Fields are (-1)^%u * 2^%i * 1+(%u/2^23); float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 1.0;
    printf("Fields are (-1)^%u * 2^%i * 1+(%u/2^23); float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 2.0;
    printf("Fields are (-1)^%u * 2^%i * 1+(%u/2^23); float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 8.0;
    printf("Fields are (-1)^%u * 2^%i * 1+(%u/2^23); float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 1024.0;
    printf("Fields are (-1)^%u * 2^%i * 1+(%u/2^23); float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

// Adding 1
    fib.the_float = 3.0;
    printf("Fields are (-1)^%u * 2^%i * 1+(%u/2^23); float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 9.0;
    printf("Fields are (-1)^%u * 2^%i * 1+(%u/2^23); float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

fib.the_float = 1025.0;
    printf("Fields are (-1)^%u * 2^%i * 1+(%u/2^23); float is %f\n", fib.the_bits.sign, fib.the_bits.exponent - 0x7F, fib.the_bits.significand, fib.the_float);

return 0;
}
```

---

## Output

<pre>
Fields are (-1)^0 * 2^-126 * 1+(0/2^23); float is 0.000000
Fields are (-1)^0 * 2^0 * 1+(0/2^23); float is 1.000000
Fields are (-1)^0 * 2^1 * 1+(0/2^23); float is 2.000000
Fields are (-1)^0 * 2^3 * 1+(0/2^23); float is 8.000000
Fields are (-1)^0 * 2^10 * 1+(0/2^23); float is 1024.000000
Fields are (-1)^0 * 2^1 * 1+(4194304/2^23); float is 3.000000
Fields are (-1)^0 * 2^3 * 1+(1048576/2^23); float is 9.000000
Fields are (-1)^0 * 2^10 * 1+(8192/2^23); float is 1025.000000
</pre>

---

## Summary

* This all makes sense
* We'll talk about why next lecture

---

## Review 2 Q1

Which of the following statements of the stack and heap are **false**?

a. Stack memory and heap memory grow from opposite ends of the memory space.

b. Heap memory is automatically freed.

c. Stack memory is automatically freed.

d. Variable length arrays may allocate memory on the stack or the heap.
</div>

---

```C
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char** argv) {
    int value = atoi(argv[1]);

char* numbers = malloc(value);
    for (char* iter = numbers; iter != numbers + value; ++iter) {
        *iter = iter - numbers;
    }
    printf("%i\n", numbers[0]);
    printf("%i\n", numbers[value-1]);
    return 0;
}
```

If compiled and run with the argument "10",

a. This program will not compile.

b. The second value printed will be 9

c. The second value printed will be 36

d. This program will access out of bounds memory and crash.
</div>

---

```C
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char** argv) {
    int value = atoi(argv[1]);

What is true of this code?

a. This program will not compile.

b. If no value is provided on the command line, a default of 0 will be used.

c. If the user provides a value of 10 on the command line, this program will have a memory leak.

d. This program will access out of bounds memory and will crash.
</div>

---

```C
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char** argv) {
    int value = atoi(argv[1]);

If `char* numbers` is changed to `int* numbers` and `char* iter` is changed to `int* iter`:

a. This program will not compile.

b. This program will now compile, but it didn't before.

c. The second value printed will be 36.

d. This program will access out of bounds memory and will crash.
</div>

---

```C
typedef struct nicePtr nicePtr;
struct nicePtr {
    unsigned long* memory;
    size_t elements;
};

void someFunction(nicePtr p);
```

If an instance of the nicePtr struct is passed into someFunction:

a. The values of the array pointed to by memory  will be copied automatically.

b. The value of the memory pointer will be copied, but not the elements of the array.

c. The typedef has an error and this will not compile.

d. Structs must be passed as pointers, so this will not compile.
</div>

---

Which of the following statements about recursion is **false**?

a. Some recursive functions cannot be rewritten to be tail recursive.

b. All recursive functions cause stack overflows.

c. All recursive functions can be rewritten as loops using a stack.

d. Compilers automatically optimize tail recursive functions to avoid repeated function calls.
</div>

---

Recall our stack:

```C
// For the size_t type definition
#include <stddef.h>

typedef struct Stack Stack;
struct Stack {
    char *memory;
    size_t memsize;
    size_t index;
};

Stack newStack(size_t size);

void freeStack(Stack s);

void push(Stack* s, char element);

char pop(Stack* s);

size_t len(Stack s);
```

</div>
<div class="col">

```C
Stack s = newStack(10);
for (int i = 0; i < 10; ++i) {
    for (int j = 0; j < 20; ++j) {
        push(&s, i+j);
    }
}
```

What is the next value returned by s.pop()? Or will this code fail to execute?

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_

</div>
</div>
</div>

---

```C
typedef struct Bits Bits;
struct Bits {
    bool a : 1;
    bool b : 1;
    bool c : 1;
    bool d : 1;
    bool e : 1;
    bool f : 1;
    bool g : 1;
    bool h : 1;
};

typedef union LLUBits LLUBits;
union LLUBits {
    // 8 bytes to a long long
    Bits bits[8];
    long long number;
};
```

</div>
<div class="col">

Write a function accepts an LLUBits as its argument and prints out every bit of the long long number in LLUBits, from most significant to least.

</div>
</div>

---

## Quiz Review

* Review your Hw1
  * Memory layout, MSB vs LSB
  * 2's complement number
* And Hw2
  * Or the stack lecture if you haven't finished your hw2