Chapter 2 — Data Representation

What are Data Units?

Data units are standard quantities used to measure and express digital information. The smallest unit is the bit (binary digit), which can be 0 or 1. Eight bits make one byte, the basic addressable storage unit in most computers. Larger units are formed by grouping bytes.

Common units (binary vs decimal)

There are two common ways to define larger units:

• Binary (used in computing, powers of 2): 1 KB (commonly) = 1024 bytes = 2^10 B. Official binary prefixes are KiB, MiB, GiB, etc. Example sequence: 1 KiB = 1024 B; 1 MiB = 1024 KiB = 1,048,576 B; 1 GiB = 1024 MiB = 1,073,741,824 B.
• Decimal (used by storage manufacturers, powers of 10): 1 kB = 1000 bytes; 1 MB = 1,000,000 bytes; 1 GB = 1,000,000,000 bytes.

Basic definitions

• Bit (b): smallest unit, value 0 or 1.
• Nibble: 4 bits.
• Byte (B): 8 bits.
• Kilobyte (KB) ~ 10^3 bytes (decimal) or Kibibyte (KiB) = 2^10 = 1024 bytes (binary).
• Megabyte (MB) / Mebibyte (MiB), Gigabyte (GB) / Gibibyte (GiB), Terabyte (TB) / Tebibyte (TiB), and so on.

Why two systems? Decimal prefixes are simple for marketing (hard disk makers) but operating systems and memory are often based on powers of two, so values shown by OS may differ from drive labels.

Practical considerations

• Storage capacity (HDD/SSD/RAM) is expressed in bytes (KB/MB/GB/TB).
• Network speed is expressed in bits per second (bps, kbps, Mbps). To convert to bytes/sec, divide by 8.
• File sizes, image sizes, and media durations can be calculated from resolution, color depth, sample rate, etc. (see formulas below).

Quick conversion table (binary)

Note on notation: Use capital B for bytes and lowercase b for bits (e.g., MB vs Mbps).

What are Number Systems? Number systems are ways to represent quantities using symbols (digits) and a base (radix). In computing, number systems let machines store and manipulate numbers in binary (base 2), octal (base 8), decimal (base 10) and hexadecimal (base 16).

Positional notation: In a base b system, a number's value is the sum of each digit multiplied by the base raised to the digit's position power (positions counted from right, starting at 0). For example: digits d_n...d_2 d_1 d_0 represents value = Σ (d_i × b^i).

Common bases:

• Binary (base 2): digits 0,1. Used internally by computers (bits).
• Octal (base 8): digits 0–7. Useful historically for compact binary grouping (3 bits per octal digit).
• Decimal (base 10): digits 0–9. Human everyday use.
• Hexadecimal (base 16): digits 0–9 and A–F. Compact form for binary (4 bits per hex digit), widely used in programming and color codes.

Conversion methods:

• Integer to another base: repeated division by the target base, collect remainders (least significant digit first).
• Fraction to another base: repeated multiplication of fractional part by the base, collect integer parts (most significant digit first).
• Shortcuts: group binary bits in triples (for octal) or nibbles of 4 (for hex) to convert quickly between binary and those bases.

Signed numbers and complements: Computers represent negative integers using schemes like sign-magnitude, 1's complement, and most commonly 2's complement. In n-bit 2's complement, a negative integer −x is stored as 2^n − x. This simplifies arithmetic and has a numeric range asymmetry (one more negative value than positive).

Other representations: BCD (Binary-Coded Decimal) stores each decimal digit in 4 bits; floating point represents real numbers with sign, exponent and mantissa (not typically part of basic number systems but important for real-number representation).

Why it matters: Understanding number systems is essential for binary arithmetic, memory addressing, data encoding (e.g., colors in hex), debugging, and understanding limits like overflow in fixed-bit hardware.

What are base conversions?

Base conversion is the process of changing a number from one positional numeral system (base) to another. A positional system with base b represents a number N as a sum of digits times powers of b:

N = d_n b^n + d_{n-1} b^{n-1} + ... + d_1 b + d_0 + d_{-1} b^{-1} + d_{-2} b^{-2} + ...

Each digit d_i is an integer in the range 0 to b-1. Common bases are decimal (base 10), binary (base 2), octal (base 8) and hexadecimal (base 16).

Why it matters (real-life relevance)

• Computers use binary internally; programmers often use hexadecimal for compact representation of binary data (memory addresses, color codes like #FF5733).
• Networking uses binary for IP addresses and masks; conversions help compute subnets.
• Digital electronics and embedded systems design require base conversions for bit-level operations.

General methods

1. Integer part (decimal or any base) to another base — repeated division method

Divide the integer by the new base repeatedly, record remainders. The converted number's digits (least significant to most) are the remainders read in reverse (last remainder is most significant).

2. Fractional part conversion — repeated multiplication method

Multiply the fractional part by the new base, take the integer part of the result as the next digit, then continue with the new fractional part. Repeat until fractional part becomes 0 or desired precision achieved.

3. Converting via decimal or directly between non-decimal bases

You can convert from any base A to base B by first converting A to decimal (base 10) using positional expansion, then from decimal to B using the division/multiplication methods. For many common pairs there's a direct shortcut:

• Binary ↔ Hexadecimal: group binary digits in blocks of 4 (2^4 = 16), map each 4-bit group to one hex digit.
• Binary ↔ Octal: group binary digits in blocks of 3 (2^3 = 8), map each 3-bit group to one octal digit.

Accuracy and repeating fractions

Some fractions in one base are repeating in another (e.g., 1/3 in decimal is 0.333..., and in binary it is 0.010101...). When converting fractions you may need to round or truncate to a fixed number of digits.

What is Binary Arithmetic?
Binary arithmetic is arithmetic performed using the binary number system (base 2), where each digit (bit) is 0 or 1. Computers perform all numeric operations in binary using logical circuits (adders, multipliers, etc.).

Positional value: each bit in a binary number represents a power of two: from right to left bits represent 2^0, 2^1, 2^2, ... For an n-bit unsigned number b_{n-1}...b_1 b_0 the value is Σ b_i·2^i.

Basic rules for binary addition (bitwise):

• 0 + 0 = 0
• 0 + 1 = 1
• 1 + 0 = 1
• 1 + 1 = 0 with carry 1
• 1 + 1 + carry(1) = 1 with carry 1

Binary subtraction can be done two ways:

• Direct borrow method (like decimal subtraction): subtract bit by bit, borrow when needed.
• Using complements (recommended in digital systems): convert the subtrahend to its two's complement and add. Two's complement of an n-bit number X is (~X) + 1 (bitwise invert then add 1). This turns subtraction A - B into A + (two's complement of B). If there's a carry out beyond n bits, discard it (indicates positive result); if not, the result is negative in two's complement form.

Binary multiplication uses repeated shifting and addition: multiply by 0 or 1 produces 0 or the multiplicand; shift the partial products left according to position and add them (like long multiplication in decimal).

Binary division is repeated subtraction/shift (long division): align divisor with most significant bits of dividend, subtract if possible, place 1 in quotient, shift divisor right and repeat.

Signed numbers and range (two's complement representation): with n bits the representable signed integer range is -2^{n-1} to 2^{n-1}-1. Two's complement simplifies hardware because addition circuitry can be used for subtraction.

Overflow: occurs when result exceeds representable range. For unsigned addition, overflow is signalled by carry out of the most significant bit. For two's complement signed addition, overflow occurs if adding two numbers of the same sign produces a result with opposite sign (equivalently, carry into sign bit ≠ carry out of sign bit).

Why it matters (real world): Binary arithmetic is the foundation of all computer calculations, digital signal processing, cryptography, networking (checksums), and embedded systems. The ALU (arithmetic logic unit) in CPUs implements these operations in hardware.

Definition
A complement of a number is another number which when added to the original yields a fixed base-dependent value (all 9s for decimal 9's-complement, all 1s for binary 1's-complement). Complements are used to simplify subtraction and to represent negative numbers in digital systems.

Types

• Decimal complements
  • 9's complement of an n-digit decimal number N = (10ⁿ - 1) − N
  • 10's complement of N = 10ⁿ − N (equivalently 9's complement + 1)
• Binary complements
  • 1's complement of an n-bit binary number B = (2ⁿ − 1) − B — obtained by flipping every bit (0↔1)
  • 2's complement of B = 2ⁿ − B — obtained by taking 1's complement and then adding 1 (or by computing bitwise NOT then +1)

Why they matter
Two's complement is the standard representation for signed integers in most computers: it allows a single zero, simple addition/subtraction using the same adder circuitry, and easy detection of overflow. One's complement and decimal complements are useful in some manual subtraction methods and older systems.

How to compute (short methods)

• 9's complement (decimal): replace each digit d by (9 − d).
• 10's complement (decimal): take 9's complement then add 1.
• 1's complement (binary): flip every bit (0→1, 1→0).
• 2's complement (binary): flip bits then add 1; equivalently compute bitwise NOT and add 1 (i.e., −B ≡ (~B) + 1 mod 2ⁿ).

Properties

• In n bits, 1's-complement representation has two zeros (+0 and −0); 2's-complement has a single zero.
• Range for n-bit two's complement: −2ⁿ⁻¹ ... 2ⁿ⁻¹ − 1.
• Range for n-bit one's complement: −(2ⁿ⁻¹ − 1) ... 2ⁿ⁻¹ − 1 (and two zeros).
• Subtraction: A − B can be done as A + (complement of B). In two's-complement arithmetic use 2's complement of B and, if a carry out appears, discard it; if no carry, result is already correct in two's-complement form (may require sign interpretation).

Overflow
In two's-complement addition, overflow occurs when adding two numbers of the same sign produces a result of the opposite sign. Another hardware test: overflow = carry into sign bit XOR carry out of sign bit.

Typical use-cases (real life)

• CPU integer arithmetic: two's complement used to store negative integers and perform subtraction via addition circuits.
• Sensors and embedded systems reporting negative values (temperatures, altitudes) use two's complement encoded integers.
• Manual subtraction on paper can be simplified using decimal complements (9's/10's complement method).

What it is: Computers store signed (positive and negative) integers in binary. Because binary digits (bits) have no inherent sign, several conventions are used to represent sign and magnitude. The commonly taught methods are Sign‑Magnitude, 1's Complement, 2's Complement and Excess (Bias) notation.

1. Sign‑Magnitude

• Format: MSB = sign (0 = +, 1 = -), remaining (n-1) bits = magnitude.
• Value: (-1)^{sign} × magnitude.
• Range (n bits): -(2^{n-1}-1) to +(2^{n-1}-1). There are two zeros: +0 and -0.
• Pros/Cons: Simple concept; but arithmetic is awkward because sign must be handled separately.

2. 1's Complement

• Negative of a number: bitwise invert (complement) the positive representation.
• Range (n bits): same numeric range as sign‑magnitude: -(2^{n-1}-1) to +(2^{n-1}-1). Two zeros exist (+0 and -0).
• Addition: perform bitwise addition and, if an end carry out of the MSB occurs, add that carry back into the LSB (end‑around carry).
• Pros/Cons: Simpler than sign‑magnitude for some operations, but still has two zeros and awkward carries.

3. 2's Complement (most used)

• Negative of a number: invert all bits of the positive representation, then add 1.
• Value interpretation: if MSB = 0, value = normal unsigned sum. If MSB = 1, value = -2^{n-1} + sum(of remaining weighted bits).
• Range (n bits): -2^{n-1} to +2^{n-1}-1. Unique zero (no +0/-0).
• Arithmetic: addition/subtraction works with the same binary adder used for unsigned numbers. Overflow detection: when adding two numbers, overflow occurs if the carry into the sign bit differs from the carry out of the sign bit; equivalently, if two operands have the same sign but the result has a different sign.
• Pros/Cons: Eliminates two-zero problem and simplifies arithmetic; widely used in CPUs.

4. Excess (Bias) Notation

• Stored value = true value + K, where K (bias) is usually 2^{n-1}-1 for n-bit fields used in exponents (e.g., IEEE floating point exponent bias).
• Allows ordering by unsigned magnitude and is useful for storing exponents.

Key ideas to remember

• 2's complement is the standard for integer arithmetic in modern processors.
• Range differences: two's complement allows one extra negative value compared with sign‑magnitude/1's complement because it has a single zero.
• Overflow detection rules differ by representation; for two's complement use the sign rules described above.

Overflow and Underflow describe situations where a computation produces a numeric result that cannot be represented within the fixed number of bits reserved for that number in a computer.

Integer overflow: With fixed-width integer representations (n bits), only a limited set of integers can be represented. For unsigned n-bit integers the representable range is 0 to 2ⁿ−1. For signed integers using two's complement the range is −2ⁿ⁻¹ to 2ⁿ⁻¹−1. If a calculation produces a result outside the allowed range, integer overflow occurs. Behavior depends on the system: arithmetic may wrap-around (modular arithmetic), set a hardware flag, or trigger an exception.

Integer underflow: Commonly used to mean the same wrap-around behavior when a subtraction or negative result falls below the minimum representable value. In unsigned arithmetic subtracting a larger number from a smaller one produces underflow that typically wraps to a large positive value (e.g., 0 − 1 = 2ⁿ−1).

Signed overflow detection: When adding two numbers of the same sign yields a result of the opposite sign, a signed overflow has occurred. Unsigned overflow can be detected by a carry out from the most significant bit.

Floating-point overflow and underflow: Floating-point numbers (e.g., IEEE formats) represent values roughly as ±mantissa × 2^exponent. Floating-point overflow occurs when a result's exponent is greater than the maximum exponent: the result is typically set to ±infinity. Floating-point underflow occurs when a nonzero result is closer to zero than the smallest positive representable normal number. Behaviors include gradual underflow to subnormal (denormal) numbers with reduced precision or flushing to zero for very small values.

Consequences and handling: Overflow/underflow can produce wrong results, wrap-around effects, or runtime errors. Common mitigations: use larger data types (more bits), check for overflow before performing operations, use saturating arithmetic (clamp to min/max), or use arbitrary-precision libraries for integers and high-precision or scaled arithmetic for reals.

Summary: Overflow and underflow are fundamental limits caused by finite representation. Integer cases produce wrap-around or flagged errors; floating-point cases produce infinities, zeros, or reduced-precision subnormal numbers.

Overview

Computers store real numbers (numbers with fractional parts) using two common schemes: fixed-point and floating-point. Both represent real values in binary, but they trade off range, precision, complexity and hardware cost.

Fixed-point representation

In fixed-point representation the binary point (radix point) is at a fixed position for all numbers. A fixed number of bits is reserved for the integer part and a fixed number for the fractional part. A fixed scaling factor 2^(-f) (where f is the number of fractional bits) is implied.

• Representation: store an integer N; interpreted value = N / 2^f.
• Notation: Qm.n (or Q format) means m integer bits and n fractional bits (excluding sign bit if signed).
• Advantages: simple, fast, deterministic precision; good for embedded systems, digital signal processing, financial apps.
• Limitations: limited dynamic range; uniform spacing between representable values (fixed precision across the whole range).

Example (8-bit unsigned with 4 fractional bits): to represent 6.75, compute 6.75 × 2^4 = 108 (decimal) = 01101100 (binary). Interpreted value = 108 / 16 = 6.75.

Floating-point representation

Floating-point stores numbers in scientific notation (binary): a sign, an exponent, and a significand (mantissa). The binary point "floats" because the exponent scales the significand, giving a much larger dynamic range.

• Generic value: (-1)^S × (1.fraction) × 2^(E - bias) for normalized numbers (binary normalized form with an implicit leading 1).
• IEEE 754 is the common standard. Typical formats:

• Single precision (32-bit): 1 sign bit, 8 exponent bits, 23 fraction bits. Bias = 127.
• Double precision (64-bit): 1 sign bit, 11 exponent bits, 52 fraction bits. Bias = 1023.

Special encodings exist for zero, subnormal (denormal) numbers, infinity and NaN.

Floating-point properties:

• Large dynamic range (can represent very large and very small magnitudes).
• Precision relative to magnitude is roughly constant (relative or percentage error roughly constant), but absolute spacing grows with magnitude.
• More complex hardware and rounding rules; susceptible to rounding and cancellation errors in arithmetic.

Example (IEEE 754 single): 13.25(decimal) = 1101.01₂ = 1.10101₂ × 2^3. Exponent field = 3 + 127 = 130 = 10000010₂. Fraction bits = 101010000... (pad to 23 bits). Final 32-bit pattern: 0 10000010 10101000000000000000000.

When to use which

• Fixed-point: use when deterministic precision and low-cost hardware are required (embedded controllers, audio codecs, financial calculations where scaling is fixed).
• Floating-point: use for scientific computing, graphics, general-purpose programs that need wide dynamic range (physics simulations, machine learning).

What it is
IEEE 754 is the most widely used standard for representing real (floating-point) numbers in computers. It defines binary formats (single and double precision), how to encode sign, exponent and fraction (mantissa), special values (zero, infinity, NaN), normalization rules, and rounding methods.

Basic structure
A floating-point number is stored in three fields: sign (S), exponent (E), and fraction (F).

• Single precision (32-bit): 1 bit sign, 8 bits exponent, 23 bits fraction.
• Double precision (64-bit): 1 bit sign, 11 bits exponent, 52 bits fraction.

Normalized numbers (most common)
Normalized representation assumes an implicit leading 1 before the binary point (called the hidden bit). The stored exponent is biased so that both positive and negative real exponents can be encoded.

Value formula (normalized)
Value = (-1)^S × 1.F × 2^{(E - bias)}
Here 1.F means the binary number formed by placing a binary point after an implicit 1 followed by the fraction bits.

Denormalized (subnormal) numbers
When the stored exponent is all zeros (E = 0), numbers are represented without the implicit leading 1 to allow representation of magnitudes closer to zero. Their value is:

Value = (-1)^S × 0.F × 2^{(1 - bias)}

Special cases

• E = all 1s and F = 0 => ±Infinity (sign bit chooses + or −)
• E = all 1s and F ≠ 0 => NaN (Not a Number)
• E = 0 and F = 0 => ±0 (signed zero)

Bias and ranges

• Single precision bias = 127. Exponent field 1..254 encodes e = E - 127 (so e range for normalized numbers is −126..+127).
• Double precision bias = 1023. Exponent field 1..2046 encodes e = E - 1023 (so e range −1022..+1023).

Precision and limits (single precision examples)

• Smallest positive normalized ≈ 2⁻¹²⁶ ≈ 1.17549435×10⁻³⁸
• Smallest positive denormal ≈ 2⁻¹⁴⁹ ≈ 1.40129846×10⁻⁴⁵
• Largest finite ≈ (2 − 2⁻²³) × 2¹²⁷ ≈ 3.4028235×10³⁸
• Machine epsilon (difference between 1 and next representable number) ≈ 2⁻²³ ≈ 1.1920929×10⁻⁷ for single precision.

Rounding
IEEE 754 defines rounding modes (round to nearest even is the default), so results of arithmetic are rounded to fit the available precision. This causes small rounding errors that are normal in floating-point arithmetic.

Why normalization and bias?
Normalization maximizes precision by keeping the leading digit nonzero. The bias makes exponent storage unsigned while allowing negative exponents.

Important consequences for students

• Not all decimal real numbers can be represented exactly in binary floating point (e.g., 0.1).
• Floating-point arithmetic is fast and wide-ranging in magnitude but not exact; avoid testing equality of floats directly—use tolerances.
• Understand special values: signed zero, ±infinity, and NaN affect comparisons and computations.

Short conversion recipe (decimal to IEEE 754 single)

1. Find sign bit S (0 for positive, 1 for negative).
2. Convert absolute value to binary and normalize to form 1.F × 2^e.
3. Compute biased exponent E = e + 127 and write it in 8 bits.
4. Take the fractional bits after the binary point (F), fill/truncate to 23 bits using rounding rule.
5. Concatenate S | E | F to get the 32-bit pattern.

What is Character Representation?
Character representation is the method of mapping human-readable characters (letters, digits, punctuation, symbols) to numeric codes so computers can store and process text. Each character is assigned a code point (a number). That code point is then stored as binary (bits).

Key ideas

• Code point: an integer assigned to a character (e.g., 'A' = 65).
• Encoding: how a code point is represented as bytes (examples: ASCII, UTF-8, UTF-16, UTF-32).
• Glyph vs. Code point: a glyph is the visual shape; many glyphs can map to one code point (or vice versa in complex scripts).

Common encodings

• ASCII – 7-bit standard for English: 128 code points (0–127). Example: 'A' = 65 (01000001).
• Extended ASCII – 8-bit (0–255) used historically for extra symbols and some language characters.
• Unicode – universal standard giving every character a unique code point (U+0000 to U+10FFFF). It covers scripts worldwide, symbols and emoji.
• UTF-8 – a widely used variable-length encoding for Unicode. Uses 1 byte for ASCII (U+0000–U+007F), 2 bytes for U+0080–U+07FF, 3 bytes for U+0800–U+FFFF, and 4 bytes for U+10000–U+10FFFF.

How a character is stored (example steps)

1. Choose code point: 'A' → 65 (decimal).
2. Convert to binary: 65 → 01000001 (8-bit representation).
3. Store the binary bits in memory (1 byte for this ASCII character).

Why variable-length encodings?
To save space: ASCII characters remain 1 byte (compact for English) while non-Latin characters get more bytes as needed.

Practical notes
Programs must agree on encoding (file headers, HTTP headers, or byte order marks) or text may appear corrupted (mojibake). Modern systems use Unicode (usually UTF-8).

Overview: Computers store and process data in binary (base-2) using bits (0 or 1). A binary code or encoding is a rule that maps information (numbers, characters, instructions, images) into binary patterns so the computer can store, transmit and interpret it.

Binary number basics: A binary number b_{n-1}...b_1b_0 represents the value Σ (b_i × 2^i). Example: 1101₂ = 1×2^3 + 1×2^2 + 0×2^1 + 1×2^0 = 13.

Numeric encodings (how integers are represented):

• Unsigned binary: All bits form a positive value. Range for n bits: 0 to 2^n − 1.
• Sign-magnitude: Most-significant-bit (MSB) is sign (0 = +, 1 = −), remaining bits magnitude. Example (4-bit): 1001 = −1. Two zeros (+0 and −0) exist.
• One's complement: Negative represented by bitwise inversion of positive. Example (4-bit): +5 = 0101, −5 = 1010. Still has +0 and −0.
• Two's complement (standard in computers): Negative = invert bits of positive and add 1. Range for n bits: −2^{n−1} to 2^{n−1} − 1. Example (4-bit): +3 = 0011, −3 = 1101.

Other numeric formats:

• Fixed-point: A fixed number of bits for integer and fractional parts (used in simple arithmetic).
• Floating-point: IEEE 754 standard uses sign, exponent, mantissa to represent real numbers (scientific notation in binary).

Binary-coded decimal (BCD) and related codes:

• BCD: Each decimal digit encoded as 4-bit binary (e.g., decimal 27 → 0010 0111). Useful in calculators and financial computations to avoid binary-decimal conversion errors.
• Excess-3: BCD value + 3 (0011). Helps with some arithmetic and error detection.
• Gray code: Adjacent numbers differ by exactly one bit (useful in rotary encoders and error-reduction when analog-to-digital transitions occur).

Character encodings:

• ASCII: 7-bit (commonly stored in 8 bits) encoding for English characters and control codes (128 symbols).
• Unicode: Universal character set (many languages). Implementations include UTF-8 (variable length, backward compatible with ASCII), UTF-16, UTF-32.

Error detection codes:

• Parity bit: Add one bit so that total number of 1s is even (even parity) or odd (odd parity). Simple single-bit error detection.
• Checksums, CRC, Hamming codes: Stronger methods to detect and correct multiple-bit errors (Hamming can correct single-bit errors and detect double-bit errors).

Why different encodings? Each encoding optimizes for ease of arithmetic, compactness, compatibility, error-resilience or human readability. Two's complement simplifies hardware for addition/subtraction; UTF-8 optimizes common-text storage while supporting all Unicode characters; Gray code reduces errors during transitions.

What is error detection? When digital data is transmitted or stored, noise or faults can flip bits. Error detection techniques let the receiver detect (and sometimes correct) such errors before using the data.

Parity — basic idea
A parity bit is a single extra bit appended to a group of data bits so that the total number of 1s in the transmitted block follows a chosen rule (even or odd). On reception the receiver recomputes the parity and compares it with the transmitted parity bit. A mismatch indicates an error.

Even and odd parity
- Even parity: parity bit is chosen so that the total count of 1s (data bits + parity bit) is even.
- Odd parity: parity bit is chosen so that the total count of 1s is odd.

How to generate/check parity
Generation: compute the sum (modulo 2) of all data bits and set parity bit accordingly. Checking: recompute the modular sum including the parity bit; if the result violates the chosen parity rule, an error is detected.

Example (conceptual)
Data bits: 1 0 1 1 (three 1s).
- Even parity: parity bit = 1 (so total 1s = 4, even). Transmitted: 1 0 1 1 1.
- If one bit flips during transmission (e.g., third bit 1 -> 0), receiver recomputes parity and finds mismatch – error detected.

What parity detects and its limitations
- Parity detects any odd number of bit errors (1, 3, 5, ... flips) because the total count of 1s changes parity.
- Parity fails to detect an even number of bit errors (2, 4, ...) when flips cancel out the parity change. Thus parity provides simple detection but cannot correct errors and cannot detect all error patterns.

Improvements: block & 2D parity
- Block parity: add a parity bit for each byte/word.
- Two-dimensional (row-and-column) parity: arrange data in a matrix, compute parity for each row and column and send both sets of parity bits. This can detect many burst errors and can locate and correct a single-bit error in the block (by finding the row and column with parity mismatch).

Relation to Hamming distance
The simple parity code has minimum Hamming distance 2. That guarantees detection of any single-bit error but not correction; it will also detect any odd-numbered error patterns.

Where parity is used
Simple parity bits are used in serial interfaces (UART optional parity), some memory and storage schemes historically (parity RAM), and as a component of RAID parity schemes (RAID 5) for disk-failure recovery. Modern networks/files often use stronger checks (CRC, checksums, ECC) when higher reliability is required.

Overview
Data representation is about how computers store and manipulate information (numbers, text, images, sound) using binary digits (bits). A bit is 0 or 1. Groups of bits form bytes (8 bits) and larger units. Understanding representations helps you know ranges, precision, storage size and how arithmetic/logic is done inside a computer.

Basic units and positional value

• Bit: binary digit (0 or 1). Byte: 8 bits. Common units: KB (2^10 bytes), MB (2^20), GB (2^30), TB (2^40).
• Positional value (binary): for an n-bit unsigned binary number b_{n-1}...b_1 b_0, its decimal value = Σ b_i * 2^i.

Number systems & conversions
Computers use binary (base 2). Humans often use decimal (base 10), while octal (base 8) and hexadecimal (base 16) are compact notations for binary. Conversion methods include repeated division (decimal→binary) and positional expansion (binary→decimal).

Representing integers
There are several ways to represent signed integers using n bits:

• Unsigned: range 0 to 2^n - 1.
• Sign-and-magnitude: highest bit is sign (0 positive, 1 negative); remaining bits give magnitude. Two representations for zero (+0 and -0).
• One's complement: negative = bitwise NOT of positive. Two zeros exist; arithmetic requires end-around carry.
• Two's complement: negative = invert bits and add 1. Common in modern CPUs. Range: -2^{n-1} to 2^{n-1}-1. Single zero, simpler arithmetic.

Fixed-point vs Floating-point
Fixed-point stores integers or scaled integers (implied decimal point). Floating-point stores a sign, exponent and mantissa to represent a wide dynamic range using scientific notation in base 2. IEEE 754 is the standard:

• Single precision (32-bit): 1 sign bit, 8-bit exponent (bias 127), 23-bit fraction (mantissa).
• Double precision (64-bit): 1 sign bit, 11-bit exponent (bias 1023), 52-bit fraction.

Value formula: (-1)^{sign} × (1.fraction) × 2^{exponent - bias} for normalized numbers.

Character encoding
Characters are mapped to numeric codes: ASCII (7-bit, 0–127) for basic Latin characters; extended ASCII (8-bit); Unicode (code points up to U+10FFFF) with UTF-8/UTF-16/UTF-32 encodings to support all world scripts.

Other representations and codes

• BCD (Binary Coded Decimal): stores decimal digits separately (each digit in 4 bits). Useful for precise decimal arithmetic in finance.
• Gray code: consecutive numbers differ by 1 bit; used in analog-to-digital converters and error reduction for mechanical encoders.
• Parity and checksums: simple error-detection: add a parity bit so total 1s are even (even parity) or odd (odd parity).

Limits, overflow and precision
Every representation has limits. Unsigned overflow occurs when value > 2^n -1. Two's complement overflow happens when result falls outside allowed range. Floating-point has limited precision (rounding) and can represent extremely large/small magnitudes but not all decimals exactly (e.g., 0.1).

Why it matters (real-life impact)
Correct data representation affects storage size, numeric correctness (banking, scientific computing), image/video color depth, network addresses, file formats and performance.