Bit Representation - Revision history

Brodriguez: Correct links

2020-02-04T15:01:49Z

Correct links

← Older revision		Revision as of 15:01, 4 February 2020
Line 137:		Line 137:
	* <code>E = exp - bias</code>		* <code>E = exp - bias</code>

	For examples of decimal to float representation, see https://www.youtube.com/watch?v=~~LXF~~-~~wcoeT0o~~ <br>		For examples of decimal to float representation, see https://www.youtube.com/watch?v=8afbTaA-gOQ <br>
	For examples of float to decimal representation, see https://www.youtube.com/watch?v=~~8afbTaA~~-~~gOQ~~		For examples of float to decimal representation, see https://www.youtube.com/watch?v=LXF-wcoeT0o

	=== Denormalized Values ===		=== Denormalized Values ===

Brodriguez: Formatting

2020-02-04T15:01:00Z

Formatting

← Older revision		Revision as of 15:01, 4 February 2020
Line 137:		Line 137:
	* <code>E = exp - bias</code>		* <code>E = exp - bias</code>

	For examples of decimal to float representation, see https://www.youtube.com/watch?v=LXF-wcoeT0o		For examples of decimal to float representation, see https://www.youtube.com/watch?v=LXF-wcoeT0o <br>
	For examples of float to decimal representation, see https://www.youtube.com/watch?v=8afbTaA-gOQ		For examples of float to decimal representation, see https://www.youtube.com/watch?v=8afbTaA-gOQ

Brodriguez: Update floating point examples

2020-02-04T15:00:45Z

Update floating point examples

← Older revision		Revision as of 15:00, 4 February 2020
Line 137:		Line 137:
	* <code>E = exp - bias</code>		* <code>E = exp - bias</code>

	~~Example~~:		For examples of decimal to float representation, see https://www.youtube.com/watch?v=LXF-wcoeT0o
	~~<code>s = 0, exp = 1000 1100, frac = 1101 1011 0110 1000 0000 000<~~/~~code>~~		For examples of float to decimal representation, see https://www.youtube.com/watch?v=8afbTaA-gOQ
	~~Aka~~
	~~<code>s = 0, exp = 140, frac = 15213<~~/~~code>~~

	~~This is single precision so <code>bias~~ = ~~127</code>.~~

	~~Thus~~, ~~we can calculate~~:~~<br>~~
	~~<code>E = exp - bias<~~/~~code><br>~~
	~~<code>E = 140 - 127<~~/~~code><br>~~
	~~<code>E~~ = ~~13</code>~~

	~~This gives us <code>(~~-~~1)^0 15213 * 2^(13)</code>~~

	=== Denormalized Values ===		=== Denormalized Values ===

Brodriguez: Reorder page

2020-02-04T03:12:34Z

Reorder page

@@ Line 1: / Line 1: @@
 == Two's Compliment ==
 Also known as "signed integer" representation.
@@ Line 108: / Line 161: @@
 * If <code>frac = 000...0</code>, then float represents infinity.
 * Otherwise, float represents NaN (Not-a-Number).

Brodriguez: Create floating point section

2020-02-04T03:12:05Z

Create floating point section

@@ Line 35: / Line 35: @@
 <code>-(0 + 2 + 0) = -2</code><br>
 Our resulting value is <code>-2</code>
 == Data Type Sizes ==
@@ Line 86: / Line 159: @@
 | 8
 | 8
 |}

Brodriguez: Create data type size section

2020-02-04T02:27:58Z

Create data type size section

← Older revision		Revision as of 02:27, 4 February 2020
Line 35:		Line 35:
	<code>-(0 + 2 + 0) = -2</code><br>		<code>-(0 + 2 + 0) = -2</code><br>
	Our resulting value is <code>-2</code>		Our resulting value is <code>-2</code>

			== Data Type Sizes ==
			The following table describes how many bytes are needed to represent each data type.<br>
			Recall that 1 byte is 8 bits.

			{\| class="wikitable"
			\|-
			!
			! Standard 32-bit
			! Standard 64-bit
			! x86-64
			\|-
			! Char
			\| 1
			\| 1
			\| 1
			\|-
			! Short
			\| 2
			\| 2
			\| 2
			\|-
			! Int
			\| 4
			\| 4
			\| 4
			\|-
			! Long
			\| 4
			\| 8
			\| 8
			\|-
			! Float
			\| 8
			\| 8
			\| 8
			\|-
			! Double
			\| 8
			\| 8
			\| 8
			\|-
			! Long Double
			\| -
			\| -
			\| 10 / 16
			\|-
			! Pointer
			\| 4
			\| 8
			\| 8
			\|}

Brodriguez: Create page

2020-02-02T14:01:15Z

Create page

New page

== Two's Compliment ==
Also known as "signed integer" representation.

At the bit level, everything is computed and stored the same as unsigned. 
However, when representing the number to the user, it's handled differently.

Effectively:
* Check the largest (leftmost) bit.
** If it's 0, then compute normally, the same as unsigned.
** If it's 1, the value is negative, so proceed to the next steps.
* Drop off the largest (leftmost) bit, as we know the value is negative.
* Invert remaining bits.
* Add 1 to these inverted bit.
* Read in new value as your number, as a negative.

=== Two's Compliment Examples ===
Positive Example: 0110

We read this in normally, so we would have: 
<code>0 + 4 + 2 + 0 = 6</code> 
Our resulting value is <code>7</code>.

Negative Example: 1110

Our leftmost bit is 1, so we know it's negative. 
First, we drop this leftmost bit, giving us <code>110</code>. 
Next, we invert our bits, giving <code>001</code>. 
Now we add 1 to our inverted value: 
001
+ 1
---
010

Our final binary value is <code>010</code>. We can now read this as a negative number, giving: 
<code>-(0 + 2 + 0) = -2</code> 
Our resulting value is <code>-2</code>