Converting Between Bases

Converting from base-n

Multiply each digit by increasing powers e.g. $20 1_{3}$ (201 base 3) → $2 \times 3^{2} + 0 \times 3^{1} + 1 \times 3^{0} = 19$

Binary → Octal: group bits into groups of 3, then convert each group
- e.g. $(10111011 001. 101110)_{2} = (2731.56)_{8}$
Binary → Hexadecimal: group bits into groups of 4, then convert each group
- e.g. $(1011101 1001. 10111000)_{2} = (5 D 9. B 8)_{16}$
Octal/Hexadecimal → Binary: Directly convert each digit into binary and join everything together (just the reverse of above)

The MSB is the sign (0 for +, 1 for -), and the rest of the bits represent the number

For a number x, its negated value represented in 1s complement, $- x = 2^{n} - x - 1$
- The MSB still represents the sign, but for negative numbers, all the other bits are flipped
Alternatively, a number’s negative in 1s complement representation can be found by negating all its bits
This is so that arithmetic can be directly performed on the numbers (e.g. so that -5 + 5 = 0 can be directly calculated)
To add two numbers in 1s complement, add them normally. If there is a carry out bit, add 1 to the result
To subtract two numbers, add the 1s complement of the second number to the first number e.g. 5 - 2 = 5 + (-2)

For a number x, its negated value represented in 2s complement, $- x = 2^{n} - x$
- The MSB still represents the sign
Alternatively, a number’s negative in 2s complement representation can be found by negating all its bits, then adding 1 to the result
- Can be done manually: Starting from right to left, zeros will remain the same, the first 1 encountered will remain as 1, and everything to the left of the first 1 will be inverted
This is so that we do not waste one number representing -0
Note: to add two numbers, we can do it as per normal, but disregard the final carry bit
To convert fractional numbers to 2s complement, negate all bits and add 1, but ignore the decimal point when adding 1
Subtraction can be performed by finding the second number’s 2s complement, then adding it to the first number. Ignore the carry out bit
Note that we need to account for overflows, by checking if the sign of the output number is expected (based on the two input numbers)
- This happens when the carry out bit is not equal to the carry on the most significant bit

n-1’s complement for a base-n number
The value of $- x$ in base-r, with $n$ digits and $m$ decimal digits is $r^{n} - r^{- m} - x$
Alternatively, just “flip” every digit: for digit $d$ , $d_{r - 1 s} = ∣ r - 1 - d ∣$

Split the range of numbers into two, with one half representing negative numbers, and the other representing positive
To convert to excess-n representation, add n to the number, then convert to binary
e.g. excess-4 (4 refers to the number that 000 maps to, usually $2^{n - 1}$ for n-bit numbers) representation on 3 bit numbers:
- 000 → -4, 001 → -3, 010 → -2 … 100 → 0, 101 → 1, …
for excess-n representation in $a$ bits, there are $n$ negative numbers and $2^{a} - n - 1$ positive numbers

The number of bits allocated for the whole number part and the fractional part are fixed

Most computers use IEEE 754 representation
- Single-precision (32 bits): 1 bit sign, 8 bit exponent with bias 127 (excess-127), 23 bit mantissa
- Double-precision(64 bits): 1 bit sign, 11 bit exponent with bias 1023 (excess-1023), 52 bit mantissa
Number is stored in 3 parts: sign, exponent, mantissa
- (sign) mantissa $\times$ 2^exponent
sign
- only applies to mantissa
- 0: positive, 1: negative
mantissa
- Is normalised, and has an implicit leading bit of 1
- $110. 1_{2}$ → $1.10 1_{2} \times 2^{2}$ and $101$ is stored in the mantissa
- $0.0010 1_{2}$ → $1.0 1_{2} \times 2^{- 3}$ and $01$ is stored in the mantissa
To manually convert:
- Convert number to binary $- 6. 5_{10} = - 110. 1_{2}$
- Normalise mantissa $- 110. 1_{2} = - 1.10 1_{2} \times 2^{2}$
- Convert exponent to excess-127 (or 1023) $2 + 127 = 1129 = 1000000 1_{2}$
- Combine the parts to form the number $11000000110100000000000000000000$
NaN and Infinity
- Infinity: Exponent all 1s, Mantissa all 0
- NaN: Exponent all 1s, Mantissa non-zero