
The first part of Chapter 2 is Sections 2.1.1 to 2.1.5
about using (positive) binary numbers to represent data
in a computer's memory.

Section 2.1.1 (page 36)
   Binary numbers (positive numbers only)
   Hexadecimal numbers
   Octal numbers
   How to convert between binary, hexadecimal, and octal
   Hexadecimal and octal literal numbers in C (C dos NOT have binary literal numbers)
   Know the powers of 2
   Convert binary to decimal
   Convert hexadecimal to decimal
   Convert decimal to binary

Section 2.1.2 (page 39)
   bytes vs. words
   32 bit vs. 64 bit "word length"
   sizes for common C data types (for both 32 and 64 bit word sizes)
   C's sizeof operator

Section 2.1.3 (page 42)
   byte ordering (big endian vs. little endian)
   the address of a data object
   C pointers
   C's addressof operator
   an
      unsigned char *
   pointer lets you "walk" through bytes of memory

Section 2.1.4 (page 49)
   ASCII code
   C strings
   text files
   use a hex dump program to look inside of files
   unicode

Section 2.1.5 (page 49)
   use the objdump program to disassemble an obj file
   you can also use a hex dump program to look inside the obj file

------------------------------------------------------------


The second part of Chapter 2 is Sections 2.1.6 to 2.1.9
about C's Boolean operators, both the "bitwise operators"
and "logical operators".

Section 2.1.6 (page 50)
   The three basic operators of "boolean algebra", and, or, not
   The "exclusive or" operator
   These operators are usually defined for the operands T and F.

Section 2.1.7 (page 54)
   C's bitwise boolean operators, &, |, ~, ^
   order of operations and precedence rules

Section 2.1.8 (page 56)
   C's logical boolean operators, &&, ||, !
   order of operations and precedence rules
   short circuiting of C's logical operators

Section 2.1.9 (page 57)
   C's shift operators, <<, >>
   logical shift vs. arithmetic shift
   Java has a >>> logical right shift operator


--------------------------------------------------------------

The third part of Chapter 2 is Section 2.2 about
binary representations of integer numbers (25 pages!).

Section 2.2.1 (page 60)
  Summary of C's (many) integer data types (there's at least 12).
  There are four sizes (8, 16, 32, and 64 bits),
  each size has signed and unsigned types,
  and many sizes have more than one name.

Section 2,2,2 (page 62)
  Unsigned representation of positive integers.
  There are two ways of thinking about unsigned integers,
     1) the clock arithmetic way,
     2) the place-value way.

Section 2.2.3 (page 64)
  Signed-magnitude representation of positive and negative integers (page 68).
  Two's-complement representation of positive and negative integers.
   There are three ways of thinking about 2's-complement integers,
     1) the clock arithmetic way,
     2) the place-value way,
     3) the formula -x = ~x + 1.

Section 2.2.4 (page 70)
  Casting between the unsigned representation and the two's-complement
  representation of integers.

Section 2.2.5 (page 74)
  Implicit casting between the unsigned representation and the two's-complement
  representation of integers.

Section 2.2.6 (page 76)
   Casting an integer representation to an integer representation
   with a larger size.

Section 2.2.7 (page 81)
   Casting an integer representation to an integer representation
   with a smaller size.

Section 2.2.8 (page 83)
   More about signed vs. unsigned integers.


--------------------------------------------------------------

The fourth part of Chapter 2 is Section 2.3 about the
addition, negation, and multiplication operations on
integer numbers (25 more pages!).

Section 2.3.1 (page 84)
   Addition of unsigned integers

Section 2.3.2 (page 90)
   Addition of two's complement integers.

Section 2.3.3 (page 95)
   Negation of two's-complement integers

Section 2.3.4 (page 96)
   Unsigned Multiplication

Section 2.3.5 (page 97)
   Signed Multiplication

Section 2.3.6 (page 101)
   Multiplication by 2 using a left shift.

Section 2.3.7
   Division by 2 using a right shift,
      logical right shift for unsigned integers,
      arithmetic right shift for two's-complement integers.


--------------------------------------------------------------

The fifth part of Chapter 2 is Section 2.4
about floating point numbers.

Section 2.4.1
   Fractional binary numbers
   Binary point (not "decimal point")
   fixed-point fractional numbers (used in older 3D graphics cards)

Section 2.4.2
   IEEE floating-point format
   see the document "floating-point-integers.html"

Section 2.4.3
   Example IEEE floating-point numbers
   try using the web site
      http://www.ajdesigner.com/fl_ieee_754_word/ieee_32_bit_word.php
   Show that 2^23 = 8388608 is the first integer that does not have
   any fractions following it (only other integers). Notice that
   2^23 pushes the decimal point in the significand all the way to
   the right hand end of the significand (23 is the biased exponent).

Section 2.4.4
   round-to-even

Section 2.4.5
   Consider addition of a few simple examples using scientific notation.
     123e1 + 123e3
     123e4 + 123e1
     floating point addition is NOT associative
     x + (y + z) NEED NOT EQUAL (x + y) + z
     (make y and z small numbers that add up to something noticeable by x)
     (or use large numbers, x = -2.7e23, y = 2.7e23, z = 1.0, and get 0=1)
