Integers

Numerals versus Numbers

Every number N can be represented as a sum of products of the form:

N = B_n * Bⁿ + ... + B₀ * B⁰

where B is the base and B_i < B

The base-B numeral representing N is the sequence [N]_B = B_n...B₀

In Computer Science the most common choices for B are:

B = 2 (binary representatio)
B = 8 (octal representation)
B = 10 (decimal representation)
B = 16 (hexadecimal notation

Example: The secret to life, the universe, and everything is ...

[42]₁₀ = 42

[42]₈ = 52 = 052

[42]₁₆ = 2a = 0x2a

[42]₂ = 101010

Binary Unsigned Integers

[N]₂ -> [N]₁₀ (Converting from base 2 to base 10)

The Idea

[101010]₂ =

1 * 2⁵ + 0 * 2⁴ + 1 * 2³ + 0 * 2² + 1 * 2¹ + 0 * 2⁰ =

0 + 2 * (1 + 2 * (0 + 2 * (1 + 2 * (0 + 2 * 1)))) = 42

The algorithm:

[N]₁₀ = 0;
while ([N]₂ has more bits) {
[N]₁₀ = 2 * [N]₁₀;
[N]₁₀ = [N]₁₀ + next bit
}

Example

Let's convert

[N]₂ = 101010

to base 10.

Starting from the left, multiply the first digit by 2:

[N]₁₀ = 1 * 2 = 2

Add the next digit

[N]₁₀ = 2 + 0 = 2

Multiply by 2

[N]₁₀ = 2 * 2 = 4

Add the next digit:

[N]₁₀ = 4 + 1 = 5

Multiply by 2:

[N]₁₀ = 2 * 5 = 10

Add the next digit:

[N]₁₀ = = 10 + 0 = 10

Multiply by 2:

[N]₁₀ = 10 * 2 = 20

Add the next digit:

[N]₁₀ = 20 + 1 = 21

Multiply by 2:

[N]₁₀ = 2 * 21 = 42

Add the last digit:

[N]₁₀ = 42 + 0 = 42

Converting from base 2 to base 10

To go the other way, binary to decimal, repeatedly divide by 2. Record the remainders to get the bits in reverse order.

The algorithm

while (N > 0) {
bit[i++] = N % 2;
N = N / 2;
}

Some examples

7/2 = 3 r 1
3/2 = 1 r 1
1/2 = 0 r 1

8/2 = 4 r 0
4/2 = 2 r 0
2/2 = 1 r 0
1/2 = 0 r 1

42/2 = 21 r 0
21/2 = 10 r 1
10/2 = 5 r 0
5/2 = 2 r 1
2/2 = 1 r 0
1/2 = 0 r 1

There are many calculators on the web that will convert between base 2 and base 10. For example:

http://mistupid.com/computers/binaryconv.htm

Converting between base 2 and base 16

The best way to do this is to memorize the binary representations of each hex digit:

0 = 0000
1 = 0001
2 = 0010
3 = 0011
4 = 0100
5 = 0101
6 = 0110
7 = 0111
8 = 1000
9 = 1001
a = 1010
b = 1011
c = 1100
d = 1101
e = 1110
f = 1111

Example:

101010 = 0010|1010 = 2a

Problem

Finish this definition, then write a test harness for it:

class BaseConverter {
// bDigits = a string of binary digits (0, 1)
public static int b2d(String bDigits) {
int result = 0;
// implement the binary to decimal algorithm here
return result;
}
// oDigits = a string of octal digits (0 – 7)
public static int o2d(String hDigits) {
int result = 0;
// implement a modification of the b2d algorithm here
return result;
}
// hDigits = a string of hex digits (0 – 9, a – f)
public static int h2d(String hDigits) {
int result = 0;
// implement a modification of the b2d algorithm here
return result;
}
public static String d2b(int n) {
String bits = "";
// implement the decimal to binary algorithm here
return result;
}
// more later
}

public class TestBaseConverter {
public static void main(String[] args) {
// test code goes here
}
}

Arithmetic

We can add binary numbers the same way we add decimal numbers. We just have to remember that 1 + 1 = 0 carry 1:

101010 (42)
+ 111 (+7)
------
110001 (49)

The algorithms for multiplication, subtraction, and division work, too.

N-Bit Binary Signed Integers

In the Java virtual machine there are four integer types:

byte, short, int, long

A byte is a signed 8-bit integer ranging from -2⁷ (= -128) up to 2⁷-1 (= 127)

A short is a signed 16-bit integer ranging from -2¹⁵ (= -32,768) up to 2¹⁵ – 1 (= 32,767)

An int is a signed 32-bit integer ranging from -2³¹ (= -2,147,483,648) up to 2³¹ – 1 (= 2,147,483,647 )

An long is a signed 64-bit integer ranging from -2⁶³ (=-9,223,372,036,854,775,808) up to 2⁶³ – 1 (= 9,223,372,036,854,775,807 )

Sign-Magnitude System

The sign-magnitude scheme for representing N-bit signed integers is to simply reserve the left-most bit for the sign, 0 for positive, 1 for negative.

The problem with this scheme is that there are two representations of 0:

-0 = 1000
+0 = 0000

Ones Complement System

In the Ones-complement System, the negative of a number is its ones-complement:

-x = ~x

The ones complement is the result of inverting each bit. For example:

0101 = 5
1010 = -5

Note that the left-most bit indicates the sign.

The problem with this system is that we have two representations for 0:

0000 = 0
1111 = -0 = 0

Twos Complement System

Most machines prefer the twos complement system.

In the N-bit Twos complement system the negative of x is 2^N – x % 2^N

For example, for N = 4:

5 = 0101

-5 = 16 – 5 % 16 = 11 % 16 = 11 = 1011

-(-5) = 16 – (-5) % 16 = 16 + 5 % 16 = 21 % 16 = 5 = 0101

Note that –x = ~x + 1

The problem with this system is that the smallest number has no negative. For example:

- (-8) = 16 – (-8) % 16 = 24 % 16 = 8 = 1111

4 Bit Signed Numbers

N SM 1C 2C
-8 ???? ???? 1000
-7 1111 1000 1001
-6 1110 1001 1010
-5 1101 1010 1011
-4 1100 1011 1110
-3 1011 1100 1101
-2 1010 1101 1110
-1 1001 1110 1111
0 0000/1000 0000/1111 0000
1 0001 0001 0001
2 0010 0010 0010
3 0011 0011 0011
4 0100 0100 0100
5 0101 0101 0101
6 0110 0110 0110
7 0111 0111 0111