1. Numbers
Mar 27, 2013

2. 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

3. 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

4. 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

5. 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, 4A6FF + 1 = 4A700

6. Counting in three systems
Dec Bin Hex A
Dec Bin Hex B C D E F

7. 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
Colors are usually specified in hexadecimal notation: #FF0000, #669966,

8. 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
One hexadecimal digit equals four binary digits
B C A B

9. 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 !
To write a number in hexadecimal, start with 0x or 0X: 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

10. 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: L
A lowercase L can be used, but it’s a bad idea: l

11. Floating-point literals
Floating-point literals are written with a decimal point:
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 x 105
float literals are written with an F suffix
Examples: 8.5F F F E5F
If you don’t have the F suffix, type double is assumed

12. 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
double – occupies eight bytes
Can hold numbers in the range 1.7E308 to 4.9E-324
Accuracy is seventeen or eighteen digits

13. 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 = ; // illegal

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

15. 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 errors
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

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

17. 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

18. Mixed types
If you mix numeric types, the narrower type is automatically promoted 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

19. 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

20. 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

21. The End