Binary & Number Systems

Positional numeral systems: formal definition

A positional numeral system with radix b represents a number as a sequence of digits d_nd_n-1...d₁d₀, where each digit d_i satisfies 0 ≤ d_i < b, and the value of the sequence is:

Value = Σ (d_i × bⁱ) for i = 0 to n

For decimal (b=10), binary (b=2), octal (b=8), and hexadecimal (b=16), this same formula applies. The choice of base is a representation convention — the underlying mathematical value is the same.

Binary arithmetic

Binary addition follows the same rules as decimal addition, with carry:

Adding 0110 (6) and 0111 (7): working right to left: 0+1=1, 1+1=10 (write 0 carry 1), 1+1+1=11 (write 1 carry 1), 0+0+1=1. Result: 1101 = 13. Correct.

Bitwise operations — AND, OR, XOR, NOT, and bit shifts — operate on individual bits and are fundamental to systems programming, cryptography, and graphics:

a = 0b1010  # 10
b = 0b1100  # 12

print(bin(a & b))   # 0b1000  (8)  — AND: both bits must be 1
print(bin(a | b))   # 0b1110  (14) — OR:  either bit is 1
print(bin(a ^ b))   # 0b0110  (6)  — XOR: bits differ
print(bin(~a))      # -0b1011 (-11) — NOT: flip all bits (two's complement)
print(bin(a << 1))  # 0b10100 (20) — left shift: multiply by 2
print(bin(a >> 1))  # 0b101   (5)  — right shift: integer divide by 2

Hexadecimal in practice

Four binary bits map exactly to one hexadecimal digit because 2⁴ = 16. This makes hexadecimal a compact human-readable representation of binary data. The correspondence:

Hexadecimal appears throughout programming: memory addresses (0x7FFD3A40), RGB colours (#FF6633), Unix file permissions, network MAC addresses, SHA256 hashes, and UUID identifiers all use hex notation.

Two's complement: negative integers

Two's complement is the universal method for representing signed integers in hardware. For an n-bit integer:

• The range is −2ⁿ⁻¹ to 2ⁿ⁻¹ − 1
• For 8 bits: −128 to 127
• For 16 bits: −32,768 to 32,767
• For 32 bits: −2,147,483,648 to 2,147,483,647
• For 64 bits: −9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

To find the two's complement representation of a negative number, take the positive value, flip all bits (one's complement), then add 1:

Find -5 in 8-bit two's complement:
  Step 1: +5 in binary:     0000 0101
  Step 2: Flip all bits:    1111 1010  (one's complement)
  Step 3: Add 1:         +         1
  Result: -5 two's comp:    1111 1011

Verify: -5 + 5 should = 0
  1111 1011
+ 0000 0101
-----------
  0000 0000  (carry discarded — correct!)

Why two's complement over simpler sign-magnitude representations? Because addition of two's complement numbers requires no special case — the same adder circuit works for both positive and positive, and positive and negative. Subtraction becomes addition of the negative. There is only one representation of zero (sign-magnitude has +0 and −0). Hardware is simpler and faster.

IEEE 754 floating-point representation

The IEEE 754 standard (IEEE Std 754-2019) defines how real numbers are approximated in binary. A 32-bit single-precision float consists of:

• 1 sign bit — 0 for positive, 1 for negative
• 8 exponent bits — stored with a bias of 127 (to represent both positive and negative exponents)
• 23 mantissa bits — the fractional part of the significand (with an implicit leading 1)

The value is: (−1)^sign × 2^{exponent − 127} × 1.mantissa

The number 0.1 in decimal cannot be represented exactly in binary because it is a repeating fraction in base 2 (just as 1/3 is a repeating decimal: 0.3333...). The closest representable 32-bit float to 0.1 is approximately 0.100000001490116119384765625. When you add 0.1 and 0.2 in a computer, the rounding errors in both representations accumulate, and the result is not exactly 0.3.

print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)   # False

# For exact decimal arithmetic, use Python's Decimal module
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2'))          # 0.3
print(Decimal('0.1') + Decimal('0.2') == Decimal('0.3'))  # True

# IEEE 754 special values
import math
print(float('inf'))   # inf
print(float('nan'))   # nan
print(math.isnan(float('nan')))  # True

IEEE 754 also defines special values: positive and negative infinity (produced by dividing by zero for non-zero values), Not a Number (NaN, produced by 0/0 or sqrt(−1)), and positive and negative zero. NaN is the only value not equal to itself: float('nan') == float('nan') is False in every IEEE 754-compliant language.

IEEE 754-2019: formal specification

The IEEE Standard for Floating-Point Arithmetic (IEEE Std 754-2019, revision of the 1985 original) defines five basic formats: binary16, binary32, binary64, binary128, and decimal128. The binary32 (single-precision) and binary64 (double-precision) formats are used by virtually all hardware and programming languages.

Binary64 (double-precision) structure:

• 1 sign bit (s)
• 11 exponent bits (e), biased by 1023
• 52 mantissa bits (f), with implicit leading 1 for normalised values

Normalised value: (−1)^s × 2^{e − 1023} × 1.f

Range: approximately ±5 × 10⁻³²⁴ to ±1.8 × 10³⁰⁸. Precision: ~15–17 significant decimal digits.

Special encodings in binary64:

Subnormal (denormalised) numbers extend the range near zero at the cost of reduced precision. They allow gradual underflow — the result of a very small computation does not abruptly become zero, but loses mantissa bits gradually.

Two's complement: formal arithmetic properties

For an n-bit two's complement integer, the most negative value has no positive counterpart — it is its own two's complement. For 8-bit integers: −128 represented as 10000000. Negating −128 in 8 bits produces 10000000 again (overflow). This asymmetry is a formal consequence of the range −2ⁿ⁻¹ to 2ⁿ⁻¹ − 1.

Two's complement addition is modular arithmetic modulo 2ⁿ. Overflow occurs when the true mathematical result falls outside the representable range. In C, signed integer overflow is undefined behaviour (ISO C17, §6.5). In Java, signed integer overflow wraps predictably (Java Language Specification §15.18.2). In Python, integers have arbitrary precision — overflow cannot occur.

Number representation in the context of data types

The connection between number systems and data types in programming languages:

Unicode and UTF-8: text as binary

The Unicode standard (The Unicode Consortium, The Unicode Standard, current version at unicode.org/standard/standard.html) assigns a unique integer — a code point — to every character in every writing system: Latin, Devanagari, Chinese, Arabic, mathematical symbols, emoji. Code points are written in hexadecimal: U+0041 is Latin capital letter A (decimal 65). The full Unicode code space covers 1,114,112 code points (U+0000 to U+10FFFF).

UTF-8 (RFC 3629) encodes Unicode code points as variable-length sequences of 1 to 4 bytes. ASCII characters (U+0000 to U+007F) are encoded as single bytes identical to their ASCII values — making UTF-8 backward-compatible with ASCII. Code points above U+007F use multi-byte sequences with specific bit patterns identifying the sequence length.