Data Representation: Integers and Floating-Point Numbers

The Same Box, Infinite Shapes

A chemist tells you the temperature of absolute zero: -273.15°C. A census bureau records the world population: 7,888,000,000. A game engine stores a pixel color intensity: 127.

Your computer stores all three of those numbers in the same fundamental way — as patterns of 1s and 0s in a fixed number of bits. But a negative decimal fraction, a seven-billion integer, and a small whole number each need different rules for how those bits are arranged. Get the rules wrong and -273.15 becomes garbage, 7 billion overflows to zero, and the pixel flickers to the wrong color.

This lesson is about those rules.

Why Data Representation Rules Exist

Hardware doesn't know what a "number" means. A CPU register is just 64 switches. The meaning — is this a temperature? a memory address? a character? — comes entirely from the instructions operating on those bits and the convention the programmer agreed to follow.

"Data has no intrinsic meaning. A sequence of bits means whatever the program says it means."

This is why type systems in programming languages exist: to enforce the correct interpretation of bit patterns.

Unsigned Integers

Unsigned integers store only non-negative whole numbers (0 and above). With n bits, you can store values from 0 to 2ⁿ − 1.

A 32-bit unsigned integer was once enough for memory addresses — until RAM exceeded 4 GB. That is precisely why 64-bit computing became mandatory in the mid-2000s.

Signed Integers: How Negatives Work

Sign-Magnitude (Rejected)

The naive approach: use the leftmost bit as a plus/minus sign, the rest as magnitude. Problems:

• +0 (00000000) and -0 (10000000) are both "zero" — two representations of the same value
• Addition hardware must check the sign bit and use different logic for negative numbers

One's Complement (Mostly Rejected)

Negate by flipping all bits. Still has the two-zeros problem.

Two's Complement (The Universal Standard)

All modern CPUs use two's complement for signed integers. To negate: flip all bits, add 1. This elegantly eliminates the double-zero problem and makes addition hardware work for both positive and negative numbers without modification.

With n bits, two's complement stores −2^(n−1) to 2^(n−1) − 1:

• 8-bit: −128 to +127
• 16-bit: −32,768 to +32,767
• 32-bit: −2,147,483,648 to +2,147,483,647
• 64-bit: −9.2×10¹⁸ to +9.2×10¹⁸

Why is the negative range one larger than the positive? Because zero is in the positive half. The bit pattern 10000000 in 8-bit two's complement is −128, not +128.

Character Encoding

ASCII (1963)

American Standard Code for Information Interchange maps 128 characters to 7-bit codes (0–127):

• Digits: '0' = 48, '9' = 57
• Uppercase: 'A' = 65, 'Z' = 90
• Lowercase: 'a' = 97, 'z' = 122
• Space = 32, Newline = 10

Notice: lowercase letters are exactly 32 higher than uppercase. To toggle case, flip bit 5 (value 32).

Unicode and UTF-8 (1991–Present)

ASCII covers only English. Unicode defines 1,114,112 code points (U+0000 to U+10FFFF), covering every language, emoji, ancient script, and mathematical symbol on Earth.

UTF-8 is the dominant encoding: variable-width (1 to 4 bytes per character):

• U+0000 to U+007F (basic ASCII): 1 byte — backward compatible
• U+0080 to U+07FF (Latin, Greek, Arabic, Hebrew): 2 bytes
• U+0800 to U+FFFF (Chinese, Japanese, Korean): 3 bytes
• U+10000 to U+10FFFF (emoji, rare scripts): 4 bytes

As of 2024, UTF-8 is used by 98.2% of websites (W3Techs data).

Floating-Point Numbers: IEEE 754

Integers can't represent 3.14159 or 6.022×10²³. For real-number approximations, computers use floating-point, standardized by the IEEE in 1985 in IEEE 754 — one of the most influential standards in computing history.

The Concept: Scientific Notation in Binary

Just as 6.022 × 10²³ separates the significant digits from the scale, IEEE 754 separates:

• Sign: positive or negative
• Mantissa (significand): the significant bits
• Exponent: the scale (power of 2)

32-bit Single Precision Float

Bit 31    Bits 30–23     Bits 22–0
  S    |   EEEEEEEE  |  MMMMMMMMMMMMMMMMMMMMMMM
Sign     8-bit exponent   23-bit mantissa

• 1 sign bit: 0 = positive, 1 = negative
• 8 exponent bits: stored with a bias of 127 (actual exponent = stored value − 127)
• 23 mantissa bits: the fractional part (there's an implicit leading 1)

Range: approximately ±1.18×10⁻³⁸ to ±3.4×10³⁸ Precision: ~7 significant decimal digits

64-bit Double Precision Float

• 1 sign bit
• 11 exponent bits (bias 1023)
• 52 mantissa bits

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

Most programming languages use 64-bit doubles by default (double in C/Java, float in Python).

IEEE 754 Bit Layout Diagram

Special IEEE 754 Values

IEEE 754 reserves specific bit patterns for special cases:

Why 0.1 + 0.2 ≠ 0.3

This is perhaps the most famous floating-point surprise:

>>> 0.1 + 0.2
0.30000000000000004

Why? Because 0.1 cannot be represented exactly in binary floating-point — just as 1/3 cannot be represented exactly in decimal.

0.1 in binary is a repeating pattern: 0.0001100110011001100110011... (infinite). A 64-bit double truncates this to 52 mantissa bits, introducing a tiny rounding error. When you add two such approximations, the errors accumulate.

The rule: Never use floating-point equality checks (==) for financial or safety-critical calculations. Use integer arithmetic (store prices in cents, not dollars) or dedicated decimal libraries.

Complete Data Type Reference Table

Key Takeaways

• Unsigned integers store 0 to 2ⁿ−1; signed integers (two's complement) store −2^(n−1) to 2^(n−1)−1
• Two's complement is the universal standard for signed integers — negation = flip bits + add 1
• ASCII maps 128 characters to 7 bits; UTF-8 extends this to 1.1 million Unicode code points with variable-width encoding
• IEEE 754 (1985) standardizes floating-point: sign + biased exponent + mantissa
• A 32-bit float gives ~7 decimal digits of precision; a 64-bit double gives ~15–17
• Special values (NaN, ±Infinity, ±0) are encoded in reserved exponent patterns
• 0.1 + 0.2 ≠ 0.3 because most decimal fractions cannot be represented exactly in binary — always use integer arithmetic for money