more clarification

Author: brownsarahm

notes/2023-11-21.md

@@ -259,12 +259,12 @@ and
 
 
 would represent:
-$$ (-1)*0 + \left(1 + 0\cdot 2^{-1} + 1\cdot 2^{-2} + \ldots  + 0\cdot 2^{-51} + 0\cdot 2^{-52} \times \right) 2^{1023-1023} = 0 + (1 + \frac{1}{2}) \times 2^0  = 1.5 \times 1 =  1.25 $$
+$$ (-1)*0 + \left(1 + 0\cdot 2^{-1} + 1\cdot 2^{-2} + 0\cdot 2^{-3}  + \ldots  + 0\cdot 2^{-51} + 0\cdot 2^{-52} \times \right) 2^{1023-1023} = 0 + (1 + \frac{1}{2}) \times 2^0  = 1.5 \times 1 =  1.25 $$
 <!-- #endregion -->
 
 You can see this visually using [float exposed](https://float.exposed/0x3ff4000000000000)
 
-```{important}
+```{tip}
 the URL of that link is to `float.exposed/0x3ff4000000000000`
 
 `3ff4000000000000` is the number we want to view in hex.  Since the first 12 bits of the 64bit nubme are the sign and expontend, the first 3 characters represent those then the remaining 13 characters represent the 52 bits of the fraction.  
@@ -277,12 +277,14 @@ So `3ff=011111111` and then 4000000000000=01000000000000000000000000000000000000
 To see more examples of numbers doing surprising and interesting things try [memory spy](https://memory-spy.wizardzines.com/game#)```
 ````
 
-Python can give you the float representation of 
+Python can give you the hex representation of a float:
 
 ```{code-cell}  python
 float.hex(1.25)
 ```
 
+This matches what we saw above, but it takes some re-arranging, this is a good practice. 
+
 
 
 
@@ -357,23 +359,20 @@ We want to use exactly 53 bits to represent $J$ because it needs to be represent
 
 We can use this to find what $N$ needs to be first. 
 
-we want $J \approx  \frac{2^N }{10}$ to be greater than or equal to $2^{52}$ and less than $2^{53}$, or equivalently
-
-
+we want $J \approx  \frac{2^N }{10}$ to be greater than or equal to $2^{52}$ and less than $2^{53}$, or equivalently:
 
  $$ 2^{52} <= \frac{2^N }{10} < 2^{53} $$
 
 
 
  Since $10 =8+2 =  2^3 +2^1$ then $2^3<10<2^4$
- We can also bound our quantity like this: 
+ We can change the bounds of our inequality above. 
 
  $$  \frac{2^N }{16} = \frac{2^N }{2^4} < \frac{2^N }{10} < \frac{2^N }{2^3} = \frac{2^N }{8} $$
 
 and then we can re-write the middle comparison like this: 
 
 
-
  $$ 2^{N-4} <  \frac{2^N }{10} < 2^{N-3} $$
 
 
@@ -385,9 +384,9 @@ and then we can re-write the middle comparison like this:
 
 
 
-then best $N$ is 56, but we can check it.
-
+then best $N$ is 56, because that will make the upper inequality the same as the lower one. 
 
+We can also check tha this does what we want. 
 
 ```{code-cell} python
 2**52 <= 2**56 //10 < 2**53
@@ -399,22 +398,21 @@ Now we can get the number we will use for $J$. So far, mathematically, we would
 
 $$J \approx \frac{2^{56}} {10}$$
 
-but we need to find an integer value, so we divide that out and separate the `q`uotient and `r`emainder
+but we need to find an integer value, so we divide and separate the `q`uotient and `r`emainder.
 
 ```{code-cell} python
 q,r = divmod(2**56,10)
 ```
 
 
-Then we check the remainder to decide if we should round up by 1 or not.
+Next we check the remainder to decide if we should round up by 1 or not.
 
 ```{code-cell} python
 r
 ```
 
 
-$ 6 > 5 = \frac{10}{2}$  so we round up
-
+$ 6 > 5 = \frac{10}{2}$  so we round up.  Since the remainder is more than half of the divisor it is closer to the next number up, so we increment. 
 
 
 ```{code-cell} python
@@ -424,7 +422,7 @@ J
 
 
 
-then we chan check the length in bits of that number
+then we can check the length in bits of that number
 
 Python can print it for us:
 ```{code-cell} python
@@ -440,6 +438,20 @@ len(bin(J))-2
 Which is 53 as expected! To get the actual number we represent in the fraction part we  want to drop the left most bit. 
 
 
+To actually represent our final number, we  want to drop the left most bit.  Remember, we found the number that gets represented including the additional 1 outside of the sum of the bits in the fraction. 
+
+```{code-cell} python
+significand = J-2**52
+significand
+```
+
+or in binary: 
+```{code-cell} python
+bin(significand)
+```
+
+
+
 Now, we go back to the $e$. We need $52-e+1023 = 56$ so we solve to find
 $$e = 52+1023-56$$
 
@@ -449,7 +461,19 @@ e = 52-56+1023
 e
 ```
 
+So our representation of .1 would be:
+
+```{code-cell} python
+exp_bin = bin(e)[2:]
+sig_bin = bin(significand)[2:]
+'0' + exp_bin + sig_bin
+```
+
+dropping the first two characters is because those are the 0b syntax indicator, not the actual binary. 
+
+
 
+[see on float exposed](https://float.exposed/0x3fb999999999999a)
 
 Python doesn't provide a binary reprsentation of floats, but it does provide a hex representation.