Download Numbers - CIS @ UPenn

Numbers
6-Jul-17
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


Numbers are stored as a pattern of bits


Computers use the binary number system
Characters are stored as a pattern of bits


Binary distinctions are easy for hardware to work with
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

0
1
2
3
4
5
6
7
8
9
10










Bin
0
1
10
11
100
101
110
111
1000
1001
1010
Hex
0
1
2
3
4
5
6
7
8
9
A

Dec
Bin
Hex

11
12
13
14
15
16
17
18
19
20
1011
1100
1101
1110
1111
10000
10001
10010
10011
10100
B
C
D
E
F
10
11
12
13
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
hexadecimal (but not binary)
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 !
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
9
Integer types

There are four integer types

byte – occupies one byte (surprise!)


short – occupies two bytes


Can hold numbers in range –32768 to 32767
int – occupies four bytes


Can hold numbers in range –128 to 127
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

byte
short
int
long
float
double

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;
14
Casts


You can convert (cast) one numeric type to another
When you widen, no explicit cast is necessary


When you narrow, an explicit cast is required



But it doesn’t hurt
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;
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;
16
The fifth integer type

The primitive type char refers to a single, two-byte Unicode
character



You can use characters in arithmetic (they will automatically be
converted to int)



There is no good reason this should be a numeric type...
...but characters were numbers in C
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.
21