REAL NUMBERS

Any real number can be normalized to get
±0.XXXX^.B^±EXP
or
±X.XXX^.B^±EXP
Now XXXX and EXP are just two integers.  Unfortunately, which B is used, which normalization is used, how many bits used to store XXXX (mantissa)  and EXP (exponent) varies from machine to machine.  The IEEE has set a standard to solidify this mess.  Typical sizes used to store real numbers 32 bits (single precision), 64 bits (double precision) and 128 bits (quadruple precision).
 
 

IBM mainframe

Normalize to 0.XXXX in base 16.  Store:
1 bit for sign. (0 is + and 1 is -).
7 bits in exponent (in excess-64).
24 bits (6 hex digits) mantissa.

Examples

-65.2(base 10)  is stored as C2413333

+0.04296875(base 10) is stored as 3FB00000

C31A0F00 represents -416.9375(base 10)

 

IEEE Format

Used in 68000 and SPARC.  Normalize to ±1.XXX^.2^±exp  Store:
1 bit for sign (0 is +)
8/11/15 bit for exponent (Excess-2^N-1-1)
23/52/112 bits for mantissa
leading 1 is not stored anywhere.

Examples

-65.2 in single precision  is stored as C2826666.

+0.04296875 in s.p. is stored as 3D300000

C2328000 represents -44.625

How are the integer 7 and the real 7.0 stored in 4 bytes.

How are the integer -7 and the real -7.0 stored in 4 bytes.

Special Cases in IEEE floating point

When exponent = 0000000 it means -2^N-1 -2 (not -2^N-1-1   as it normally would ) and a leading 0 not 1 is assumed for the exponent 0000000.  They do this to allow for some even tinier numbers.
0  0000010  000..00 is 1.0*2^-125
0  0000001  000...00 is 1.0* 2^-126.
0  0000000  000...00 is 0
0  0000000  100...00 is 0.1*2^-126= 1*2^-127.
0  0000000  010...00 is 0.01*2^-126= 1*2^-128.
0  0000000  000...01 is 0.0..01*2^-126= 1*2^-149.
When exponent is 1111...1
+¥  is                              0  11111111  000...0
-¥ is                               1  11111111  000...0
Not a number = NaN is  X 11111111  XXX...X   One of right-most X's not 0.
 
 

Comparison (32 bits)

                          Mainframe                               IEEE

range                  bigger                                      smaller

precision             less                                         more
 

Note 0 is always hard to normalize as there is no non-0 digit to lead with.  So it is always a special case.
 

CHARACTERS

Three Standards

• ACSII- American Standard Code for Information Interchange-
  1. N=7, 8th bit for parity bit
  2. most common now
  3. Internet standard
  4. 0-9, A-Z and a-z are grouped.
  5. 00-1F are control characters eg. 00=null, 07=bell,0D=return
• EBCDIC - Extended Binary Coded Decimal Interchange Code-
  1. N=8
  2. based on old decimal (BCD) machine
  3. great for cards
  4. 0-9 OK, A_Z has gaps, a-z has gaps, but relationship between them
  5. control characters (00-3F) eg. 2F bell,0D return
• UNICODE-
  1. new one
  2. N=16 bits
  3. room for many alphabets for international use
  4. JAVA uses this one

Other Data Types

• Boolean or Logical - no hardware support - many possible conventions: eg. 0-0 is false, 1-1 is true, ow - maybe 0-0 is false ow is true
• Addresses/pointers use Unsigned integers
• Arrays/Records combinations of more fundamental types