# Numbers

Document Sample

Numbers

14-Mar-13
Bits and bytes
   A bit is a single two-valued quantity: yes or no, true or
false, on or off, high or low, good or bad
   One bit can distinguish between two cases:
T, F
   Two bits can distinguish between four cases:
TT, TF, FT, FF
   Three bits can distinguish between eight cases:
TTT, TTF, TFT, TFF, FTT, FTF, FFT, FFF
   In general, n bits can distinguish between 2n cases
   A byte is 8 bits, therefore 28 = 256 cases

2
Number systems
   The binary (base 2) number system uses two “binary
digits, ” (abbreviation: bits) -- 0 and 1
   The octal (base 8) number system uses eight digits:
0, 1, 2, 3, 4, 5, 6, 7
   The decimal (base 10) number system uses ten digits:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
   The hexadecimal, or “hex” (base 16) number system
uses sixteen digits:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F

3
Everything is a number?

   Everything in the computer is stored as a pattern of bits
   Binary distinctions are easy for hardware to work with
   Numbers are stored as a pattern of bits
   Computers use the binary number system
   Characters are stored as a pattern of bits
   One byte (8 bits) can represent one of 256 characters
   So, is everything in the computer stored as a number?
 No it isn’t, it’s stored as a bit pattern

   There are many ways to interpret a bit pattern

4
Counting

   To count up in any number system,
   add 1 to the rightmost digit
   if the result is higher than the largest digit,
   set that digit to zero and carry to the next place
   repeat addition of 1 and carrying as many times as necessary
   Example: In hex, F is the largest digit
   Hence, 4A6FF + 1 = 4A700

5
Counting in three systems
   Dec     Bin   Hex        Dec    Bin    Hex
    0        0    0         11     1011    B
    1        1    1         12     1100    C
    2       10    2         13     1101    D
    3       11    3
   14     1110    E
    4      100    4
   15     1111    F
    5      101    5
    6      110    6
   16    10000   10
    7      111    7         17    10001   11
    8     1000    8         18    10010   12
    9     1001    9         19    10011   13
   10     1010    A         20    10100   14

6
Computers use binary numbers
   People like to use decimal numbers
   Computers use binary numbers
   Java translates decimal numbers into binary
   The computer does all its arithmetic in binary
   Java translates binary results back into decimal
   You occasionally have to use numbers in other
number systems
   In Java, you can write numbers as octal, decimal, or
   Colors are usually specified in hexadecimal notation:
#FF0000, #669966,

7
Using octal and hex numbers
   Computers use binary, but the numbers are too long and
confusing for people--it’s easy to lose your place
   Octal or hex is better for people
   Translation between binary and octal or hex is easy
 One octal digit equals three binary digits

101101011100101000001011
5 5 3 4 5 0 1 3
 One hexadecimal digit equals four binary digits

101101011100101000001011
B     5     C      A     0     B

8
Writing octal and hex integers
   Integers are usually written in decimal notation:
7, 532, -28
   To write a number in octal, just start with a zero:
02, 0657, -077
   ...but don’t use the digits 8 or 9 !
0xA, 0X43AB5, -0xFFFF
   The “digits” A through F can be upper or lower case
   Uppercase is usually preferred
   Lowercase is more readable for long numbers

9
Integer types
   There are four integer types
   byte – occupies one byte (surprise!)
   Can hold numbers in range –128 to 127
   short – occupies two bytes
   Can hold numbers in range –32768 to 32767
   int – occupies four bytes
   Can hold numbers up to + or – 2 billion
   long – occupies eight bytes
   Can hold numbers up to about 19 digits
   Literals are written with an L suffix: 123456789L
   A lowercase L can be used, but it’s a bad idea: 123456789l

10
Floating-point literals
   Floating-point literals are written with a decimal point:
8.5 -7.923 5.000
   Floating-point numbers may also be written in
“scientific notation”– times a power of 10
   We use E to represent “times 10 to the”
   Example: 4.32E5 means 4.32 x 105, that is, 432000
   Example: 4.32E-5 means 4.32 x 10-5, that is,
0.0000432

11
Floating point types
   There are two floating-point types
   float – occupies four bytes
   Can hold numbers in the range 3.4E38 to 1.4E-45
   Accuracy is about nine digits
   float literals must be written with an F suffix
   Examples: 8.5F -7.923F 5.000F 4.32E5F

   double – occupies eight bytes
   Can hold numbers in the range 1.7E308 to 4.9E-324
   Accuracy is seventeen or eighteen digits
   Examples: 8.5 -7.923 5.000 4.32E5

12
Number “width”

   Numeric types are considered wider or narrower
than other numeric types
   This is based partly on number of bytes occupied
   Also based on how large a number it can hold
   Java doesn’t mind if you assign a narrow value to a
wide variable: int n = 3;
   Java is not happy if you assign a wide value to a
narrow variable: byte b = 7139946; // illegal

13
Widening and narrowing
   You can always widen
(assign a narrower type to a
byte
wider type):
short           double wide;
int            int narrow;
long
wide = narrow;
   But if you want to narrow
float
(assign a wider type to a
double       narrower type), you have to
cast it:
narrow = (int)wide;

14
Casts

   You can convert (cast) one numeric type to another
   When you widen, no explicit cast is necessary
   But it doesn’t hurt
   When you narrow, an explicit cast is required
   This requirement is made to help avoid accidental loss of
precision
   Casting tells Java that the value in the wider type
will fit in the narrower type
   Java checks to make sure that the cast works, and
gives you an error if it didn’t

15
Example casts
short s = 0;        i = (int) d;   // legal
int i = 0;          s = (short) d; // legal
double d = 0.0;     s = (short) i; // legal
d = i; // legal     d = 3.7E20;
d = s; // legal     i = 50000;
i = s; //legal      // The following give
i = d; // illegal   // runtime errors:
s = d; // illegal   s = (short) i;
s = i; // illegal   i = (int) d;

16
The fifth integer type
   The primitive type char refers to a single, two-byte Unicode
character
   There is no good reason this should be a numeric type...
   ...but characters were numbers in C
   You can use characters in arithmetic (they will automatically be
converted to int)
   char ch = 'A';
char ch2 = (char) (ch + 1); // cast result back to char
System.out.println(ch + " " + ch2 + " " + (ch + 1));
   A B 66
   To assign a char to a byte, or a byte to a char, you must use a
cast

17
Mixed types
   If you mix numeric types, the narrower type is
automatically promoted (widened) to the wider type
   int narrow = 5;
double wide;
double anotherWide = wide + narrow;
   Integer division is when you divide one integer type by
another
   The fractional part is discarded
   Example: narrow = 19 / 5; // result is 3
   Example: narrow = -19 / 5; // result is -3

18
Math methods
   Converting a double to an int just discards the fractional part:
(int)17.93 is 17
(int) –17.93 is -17
   double Math.floor(double)
   Given a double, returns (as a double) the largest integral value not
greater than the argument
Math.floor(17.93) returns 17.0
Math.floor(-17.93) returns –18.0
   double Math.ceil(double)
   Given a double, returns (as a double) the smallest integral value not
smaller than the argument
Math.ceil(17.93) returns 18.0
Math.ceil(-17.93) returns –17.0

19
Method parameters
   When you send a message to an object with a numeric
parameter, and the object needs to promote the
parameter in order to use a method, it will do so
   Example:
 double twice(double n) { return 2.0 * n; }

 twice(5) returns 10.0

   This promotion will only occur if necessary
   Example 2:
 double half(double n) { return n / 2; }

 int half(int n) { return n / 2; }

 half(25) returns 12

20
The End

“There are 10 kinds of people in the world:
those who understand binary, and those who don’t.”
--Anon.

“Real Programmers always confuse Christmas
and Halloween because Oct31 == Dec25”
--Andrew Rutherford

21

DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
 views: 0 posted: 3/14/2013 language: Unknown pages: 21