Chapter 2 — Encodings

What is encoding?
Encoding is the process of mapping information from a human-understandable form into binary sequences that computers can store, manipulate and transmit. Everything digital — numbers, letters, pictures and sound — becomes a sequence of bits (0s and 1s). The choice of encoding determines how efficiently and reliably information is handled.

Why encodings matter
Different encodings are chosen depending on goals: compact storage, ease of processing, error resilience, interoperability between systems, or faithful reproduction of data. For example, a simple ASCII encoding is compact for plain English text but cannot represent characters from many world languages; Unicode solves that by using more space when needed. For multimedia, raw formats store every sample but use lots of space; compressed formats reduce size by exploiting redundancy and perceptual limits.

Basic terminology
Bit: the smallest unit of information. Byte: commonly eight bits. Word: the number of bits a machine processes at once (16, 32, 64). Endianness: the order in which bytes are stored for multi-byte values (big-endian vs little-endian). Precision and range: in numeric encodings these determine what values can be represented exactly and which cannot.

Where encodings are used
Encodings are used in file formats (text files, images, audio files), communication protocols (how bits are sent over wires), and internal computer arithmetic. Operating systems and programming languages provide libraries to convert among encodings because mismatches cause garbled text or wrong numerical results.

How we will study this unit
Start with number systems (how bases work and conversions), then learn binary arithmetic and signed integer representations. Next cover fixed-point and floating-point for real numbers, then character encodings (ASCII, Unicode). Move on to media: images, audio and video, including how to compute storage needs and why compression is used. Finally study error detection/correction and line coding for transmission. Each topic includes examples and calculations so you can reason about file sizes, precision, and errors in practical settings.

Practical skills you will gain
By the end of the unit you should be able to convert numbers between bases, represent integers and real numbers in computer formats, estimate sizes of files and choose suitable encodings, and understand basic error-control and physical-layer signalling methods. These skills are useful in programming, debugging, and understanding how digital devices handle information.

Place-value notation
All positional number systems use digits placed in positions that represent increasing powers of the base (radix). In base b, the rightmost digit represents b^0, the next b^1, then b^2, and so on. Decimal (base 10) uses digits 0–9; binary (base 2) uses 0 and 1; octal (base 8) uses 0–7; hexadecimal (base 16) uses 0–9 and A–F (for values 10–15).

Converting integers from decimal to another base
To convert a decimal integer to base b, perform repeated division by b. At each step divide the number by b, write down the remainder; then divide the quotient again. Continue until quotient is zero. The base-b representation is the sequence of remainders read from last to first. This method works for any base.

Converting integers from other bases to decimal
To convert a number given in base b to decimal, multiply each digit by b raised to the position index and add them. For example, in base 16 the number 3A5 equals 3×16^2 + 10×16 + 5.

Binary grouping shortcuts
Binary is closely related to octal and hexadecimal because powers of two match their bases: 2^3 = 8 and 2^4 = 16. Group binary digits in threes to convert to octal and in fours to convert to hexadecimal. This makes conversions quick: e.g., binary 110101 → group as 110 101 → octal digits 6 and 5 → 65₈.

Fractional parts
To convert fractional decimal numbers to base b, repeatedly multiply the fractional part by b. The integer parts produced at each multiplication become the digits after the radix point. For converting fractional parts from base b to decimal, multiply each digit by b^{−n} where n is position after the point and sum. Many fractions terminate in some bases and recur in others; for instance 0.5 decimal is 0.1 in binary, but 0.1 decimal is recurring in binary.

Signed numbers and representations
While conversions above apply to unsigned magnitudes, signed numbers require a representation scheme (discussed in later topics). When converting negative numbers in two's complement, it is common to convert the absolute value and then apply the two's complement procedure.

Practical tips
Use hexadecimal to represent bytes because one hex digit covers four bits and two hex digits represent a byte. Programmers often use hex constants (0x...) for readability. For manual work, write out powers of the base and align digits carefully to avoid mistakes. Always check by converting back to decimal.

Binary addition rules
Binary arithmetic follows place-value rules with base 2. The basic addition truths are: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (which is 0 with a carry of 1). If three bits are added (including a carry-in), 1+1+1 = 11 (which is 1 with a carry of 1). When adding multi-bit numbers, work from least significant bit (rightmost) to most significant, propagating carries. In fixed n-bit registers, a final carry out may indicate overflow for unsigned arithmetic.

Detecting overflow
Overflow depends on whether the operands are signed or unsigned. For unsigned n-bit addition, overflow occurs if there is a carry out of the most significant bit (MSB). For signed two's complement numbers, overflow occurs when two operands of the same sign produce a result with a different sign; equivalently, when the carry into MSB differs from carry out of MSB.

Binary subtraction
Subtraction A − B can be done by complementing B and adding: in two's complement systems take two's complement of B (invert bits and add 1) and compute A + (−B). This simplifies hardware because one adder can perform both addition and subtraction. Alternatively, perform borrow-based column subtraction similar to decimal subtraction.

Multiplication
Binary multiplication uses shifting and addition. Multiply the multiplicand by each bit of the multiplier (0 gives zeros, 1 gives the multiplicand) and shift the partial product left appropriate positions before summing. This is analogous to long multiplication in decimal. In hardware, Booth's algorithm and other optimisations reduce the number of additions.

Division
Binary division is repeated subtraction and shifting. The algorithm shifts the divisor and subtracts from the dividend, setting quotient bits when subtraction succeeds. Modern CPUs use restoring or non-restoring division algorithms to implement division in hardware efficiently.

Fixed-width arithmetic concerns
In fixed n-bit arithmetic, results wrap modulo 2^n. For unsigned numbers this behaviour is straightforward but may be undesirable if overflow is unhandled. For fixed-point arithmetic, scaling must be managed so fractional positions remain aligned. Always check bit width and signedness in numerical computations to avoid silent errors.

Practical advice
When adding or multiplying large numbers by hand, write carries clearly. Use two's complement for signed arithmetic to avoid handling signs separately. In programming, use data types with sufficient bit width and, for critical calculations, consider using arbitrary-precision libraries or floating-point if needed.

Need for signed representations
Unsigned binary can only represent non-negative values. To represent negative integers we use signed encodings which reserve some information to indicate sign and magnitude. Each method has trade-offs in simplicity, arithmetic behaviour, and representable range.

Sign-magnitude
Sign-magnitude uses the most significant bit (MSB) as a sign bit: 0 for positive and 1 for negative. The remaining bits store the magnitude using standard binary. For an n-bit word, magnitude uses n−1 bits so range is −(2^{n−1} − 1) to +(2^{n−1} − 1) with two representations of zero (+0 and −0). Arithmetic must treat sign bits separately, complicating hardware.

One's complement
One's complement represents negative numbers by inverting all bits of the positive representation (bitwise NOT). Example in 8 bits: +5 = 00000101; −5 = 11111010. One's complement still has two zeros (all zeros and all ones) and requires an end-around carry when adding: if there is a carry out of MSB, add it back into LSB. This makes hardware simpler than sign-magnitude but still imperfect.

Two's complement
Two's complement forms negative numbers by inverting bits and adding one. It eliminates the double-zero problem and unifies addition/subtraction using the same adder hardware. For n bits, two's complement range is −2^{n−1} to 2^{n−1} − 1, asymmetric because the most negative value has no positive counterpart. Sign extension is simple: when increasing bit width, replicate the sign bit into new bits to preserve value.

Arithmetic consequences and overflow
Two's complement arithmetic wraps modulo 2^n. Overflow detection differs for signed numbers: overflow occurs when adding two numbers with the same sign yields a result with a different sign (or equivalently when carries into and out of MSB differ). One's complement and sign-magnitude require extra logic to handle signs in arithmetic operations, making two's complement the standard in modern systems.

Choosing a representation
For teaching and clarity, sign-magnitude shows the concept of sign plainly; one's complement introduces the idea of bit inversion; two's complement is used in practice due to arithmetic convenience. Understanding all three helps when reading older documentation or particular protocol specifications that might use non-standard encodings.

Examples and conversions
To convert negative numbers: sign-magnitude simply set MSB; one's complement invert bits; two's complement invert and add one. To interpret a two's complement bit pattern, if MSB is 0 treat as positive; if MSB is 1, compute two's complement to get magnitude and add a negative sign.

What fixed-point means
Fixed-point representation stores real numbers by fixing the location of the binary (or decimal) point. A fixed number of bits represent the integer part and a fixed number represent the fractional part. This contrasts with floating-point where the position of the point can change via an exponent.

Format notation and interpretation
Commonly used notation is Qm.f where m is number of bits for integer part (including sign if signed) and f is number of bits for fractional part. A stored integer value V in Qm.f format represents the real number V × 2^{−f}. For example, a Q7.8 value stored as 00000001 00000000 (binary) represents 1.0 because integer stored = 256 so 256×2^{−8} = 1.

Range and precision
The number of fractional bits f determines resolution: the smallest representable step (LSB) is 2^{−f}. The integer bits determine range. For signed fixed-point using two's complement, the total number of bits n = m + f and range is approximately −2^{m−1} to 2^{m−1} − 2^{−f}. Fixed-point gives predictable precision and fast arithmetic on hardware without floating-point units, but limited dynamic range.

Arithmetic operations
Addition and subtraction require operands to share the same Q format. Multiplication of two Qm.f numbers results in Q(2m).(2f) if not rescaled; to restore the original scale shift the product right by f bits (effectively divide by 2^f). Division requires left-shifting the dividend before integer division or using other rescaling methods to preserve fractional precision. Proper rounding may be applied after shifting to reduce cumulative errors.

Advantages and disadvantages
Advantages: speed, deterministic behaviour and simplicity in embedded systems. Disadvantages: limited range and careful scaling needed to avoid overflow or loss of precision. Fixed-point is widely used in digital signal processing (audio codecs, filters) and microcontrollers without FPU.

Implementational notes
When converting between fixed-point formats, align fractional bits by shifting left or right. When increasing fractional bits to gain precision, keep in mind sign extension for signed values. Always check for overflow after arithmetic and apply saturation or wrap-aware logic as required by application.

Why floating-point is used
Floating-point representation allows storage of very large and very small real numbers with a limited number of bits by splitting a number into a significand (mantissa) and an exponent. This is similar to scientific notation; it gives a trade-off between dynamic range and precision and is used for most general-purpose real-number computations.

IEEE 754 standard
IEEE 754 defines formats and arithmetic rules for floating-point numbers. Common formats are single precision (32-bit) and double precision (64-bit). A single-precision number has 1 sign bit, 8 exponent bits and 23 fraction bits. The stored value is interpreted as (−1)^{S} × (1.F) × 2^{E − bias} for normalized numbers, where bias = 127 for single precision. Double precision uses 1 sign, 11 exponent, 52 fraction bits and bias 1023.

Normalized, denormalized and special values
Normalized numbers assume an implicit leading 1 in the significand (the hidden bit) which gives extra precision. If exponent bits are all zeros and fraction non-zero, the number is denormalized (subnormal), represented as (−1)^{S} × (0.F) × 2^{1 − bias}; denormals fill the gap near zero with reduced precision. If exponent bits are all ones and fraction is zero, the value is ±infinity; if fraction is non-zero, the value is NaN (Not a Number), used for invalid results like 0/0.

Precision and machine epsilon
Floating-point cannot represent all real numbers exactly; results are rounded to nearest representable value according to rounding mode (default round to nearest even). Machine epsilon is the difference between 1 and the next representable floating-point number; it measures precision. Numerical algorithms must account for rounding errors, cancellation (loss of significant digits when subtracting close numbers), and accumulation of errors in loops.

Converting numbers
To convert a decimal number to IEEE 754 single precision: (1) convert to binary, (2) normalize to 1.F × 2^E, (3) compute exponent field as E + bias, (4) fill fraction bits from F rounding as needed, and (5) set sign bit. Understanding normalization and exponent bias is important for correct manual conversions.

Practical implications
Floating-point operations are fast on hardware with FPU but still approximate. For high-precision needs use double precision or arbitrary-precision libraries; for predictable fixed decimal digits (money) prefer fixed-point or decimal types. Know special values and how comparisons behave (NaN comparisons are special). Many subtle bugs in programs come from misunderstanding floating-point behaviour rather than language syntax.

Purpose of character encodings
Text must be represented as numbers for storage and processing. Character encodings map characters (letters, digits, punctuation and control signals) to numeric code points, which are then stored as binary. Choices of encoding affect language support, file size and compatibility.

ASCII basics
ASCII uses 7 bits to encode 128 characters: control codes (0–31), printable characters (32–126) and DEL (127). Common printable characters include digits '0'–'9', uppercase 'A'–'Z' and lowercase 'a'–'z'. Because ASCII fits in one byte with MSB zero, many systems store ASCII in 8-bit bytes for convenience. ASCII includes control codes like LF (line feed, 10) and CR (carriage return, 13) used in text formatting and communications.

Limitations of ASCII
ASCII only covers basic Latin script and lacks accented characters, diacritics and characters of most world languages. This limitation led to numerous incompatible extensions in the past, causing problems when text moved between systems using different code pages.

Unicode and UTF encodings
Unicode assigns a unique code point to nearly every character used in human writing systems, symbols and emoji. Code points are written U+xxxx. Unicode itself is an abstract mapping of characters to numbers; actual bytes are produced by encodings called UTFs. UTF-8 is variable-length and backward-compatible with ASCII: U+0000 to U+007F use one byte identical to ASCII; other code points use 2–4 bytes. UTF-16 uses 16-bit units and may need surrogate pairs for code points beyond U+FFFF. UTF-32 uses 4 bytes per code point, simple but space-inefficient. UTF-8 is most common on the web due to compactness for Latin scripts and robustness.

Practical aspects
Files must declare or assume an encoding; misinterpreting encoding leads to garbled text. Many protocols use byte-order markers (BOM) for UTF-16/32 to indicate endianness. Be careful when counting characters: number of bytes ≠ number of characters in UTF-8 since characters may be multi-byte. Libraries in programming languages provide functions to encode/decode Unicode strings; understand when to use them to avoid bugs.

Normalization and comparability
Unicode includes composed and decomposed forms (e.g., 'é' can be a single code point or 'e' + combining accent). Unicode normalization forms (NFC, NFD) ensure comparable representations for string matching and storage.

Pixels and bitmaps
Digital images are arrays of pixels arranged in rows and columns. Each pixel stores colour information. A bitmap stores the colour of every pixel explicitly; resolution is width × height. Bit depth indicates how many bits describe each pixel: 1-bit for black-and-white, 8-bit for 256 indexed colours, and 24-bit true colour with 8 bits per RGB channel allowing over 16 million colours.

Colour models
Most displays use RGB colour model: each pixel has red, green and blue intensity channels. Other models like YUV split luminance (Y) and chrominance (U, V) components; YUV is commonly used in video because human vision is more sensitive to luminance details than chroma, allowing chroma subsampling (e.g., 4:2:0) to reduce data with little visible loss.

Storage size calculation
Uncompressed image size in bytes = width × height × bits_per_pixel / 8. For example, a 1024×768 image at 24 bpp uses 1024×768×3 = 2,359,296 bytes (~2.25 MB) not counting headers.

Palettes and indexed colour
When images use few colours, a palette (colour lookup table) maps small pixel indices to full colours. An 8-bit indexed image stores one byte per pixel indexing a table of up to 256 colours; this reduces size when used appropriately (icons, GIFs).

Lossless compression methods for images
Lossless image compression exploits redundancy: Run-Length Encoding (RLE) compresses runs of identical pixels (useful for simple graphics), while dictionary methods (LZ77 family) replace repeated patterns with references. PNG uses a combination of filtering, LZ-like compression (DEFLATE) and Huffman coding to compress images without quality loss.

Lossy compression and JPEG
Photographic images benefit from lossy compression like JPEG. JPEG divides image into blocks, applies the Discrete Cosine Transform (DCT) to each block, quantizes the transform coefficients (discarding small coefficients that contribute little to perceived image), and entropy-encodes the result. Lossy compression introduces artifacts (blocking, blurring) at high compression but achieves large size reduction.

Choosing formats
Use lossless formats (PNG) for line art, text, and images requiring exact reproduction; use lossy (JPEG, modern alternatives like WebP/HEIF) for photographs and web images where smaller size matters. Newer formats improve compression efficiency and often provide both lossless and lossy modes.

From analogue to digital
Sound is a continuous-time waveform. To represent it digitally we sample the waveform at discrete time intervals and quantize each sample's amplitude into a finite number of levels. The most common uncompressed digital format is PCM (Pulse Code Modulation) which stores the sequence of amplitude samples as binary numbers.

Sampling theorem and sampling rate
The Nyquist–Shannon sampling theorem states that to reconstruct a band-limited signal perfectly, the sampling rate must be greater than twice the highest frequency present in the signal. Human hearing typically ranges to about 20 kHz, so CD-quality audio uses 44.1 kHz sampling. Lower sampling rates reduce fidelity and may cause aliasing if proper anti-alias filters are not used.

Bit depth and dynamic range
Bit depth (bits per sample) determines amplitude resolution. A 16-bit sample provides 2^{16} = 65,536 discrete levels and about 96 dB of dynamic range, whereas 24-bit increases dynamic range further. Stereo audio stores two channels (left and right). File size for PCM = sampling_rate × bits_per_sample × channels × duration_seconds / 8.

Quantization and noise
Quantization maps continuous amplitudes to discrete levels; the difference is quantization error (noise). Higher bit depth reduces this error. Dithering (adding low-level noise before quantization) can reduce audible quantization distortion by decorrelating quantization errors.

Compression of audio
Uncompressed PCM files are large. Lossless audio formats such as FLAC compress without loss by removing redundancy. Lossy formats like MP3 and AAC use perceptual models (psychoacoustics) to discard sounds that are masked by louder frequencies or are less perceptible, achieving much higher compression ratios. For archival or editing use lossless; for distribution and streaming lossy formats are common due to smaller size.

Practical calculations
Example: 44.1 kHz, 16-bit, stereo, 3 minutes → size = 44100 × 16 × 2 × 180 / 8 ≈ 30 MB. For 22.05 kHz mono 16-bit, 2 minutes → size ≈ 5.29 MB (calculate similarly). These calculations help plan storage and bandwidth requirements.

Video as a sequence of images
Video is a time sequence of frames displayed at a certain frame rate (e.g., 24, 25, 30 or 60 frames per second). Each frame is an image; therefore uncompressed video data grows quickly and needs compression for practical storage and transmission.

Spatial and temporal redundancy
Video codecs exploit both spatial redundancy within frames (like image compression) and temporal redundancy between frames. Temporal redundancy is reduced using inter-frame prediction: keyframes (I-frames) store full image data, while predicted frames (P-frames) store differences from previous frames and bidirectionally predicted frames (B-frames) use both past and future frames to predict content. This approach reduces bitrate significantly for typical footage where consecutive frames are similar.

Colour spaces and chroma subsampling
Video commonly uses a luminance-chrominance model (YUV or YCbCr) separating brightness (Y) from colour (U and V channels). Because human vision is more sensitive to luminance than chrominance details, chroma subsampling (e.g., 4:2:2, 4:2:0) reduces colour resolution to save bandwidth with minor perceived loss.

Compression transforms and motion compensation
Modern codecs (H.264, H.265, VP9, AV1) use block-based transforms (like DCT or integer approximations), quantization and entropy coding (CABAC/CAVLC) combined with motion estimation/compensation. Motion vectors describe how blocks moved between frames; residuals (differences) are then transformed and quantized, leveraging human perception to discard less-important details.

Containers and codecs
Containers (MP4, MKV) package video, audio and metadata but do not define compression. Codecs (encoders/decoders) define how data is compressed. Choose a codec for compatibility and efficiency; newer codecs provide better compression at higher decoding complexity.

Bandwidth and storage calculations
Uncompressed video size (bytes/sec) = width × height × bytes_per_pixel × frames_per_second. For example, 1920×1080 at 24 fps uncompressed 8-bit RGB is roughly 149 MB/s, so compression is essential. Bitrate targets and GOP (group of pictures) structure influence quality and size.

Goal of lossless compression
Lossless compression reduces data size without losing any information. It is required when exact reconstruction is necessary: text files, program code, some images and scientific data. Lossless methods exploit statistical redundancy or repeated patterns in the data.

Statistical coding: Huffman
Huffman coding assigns variable-length prefix-free codes to symbols based on their frequencies: common symbols get short codes and rare ones get long codes. Build a binary tree by repeatedly merging the two least-frequent nodes; the code for each symbol is the path from root to leaf. Huffman coding is optimal for symbol-by-symbol coding given known frequencies and forms a core part of many compressors.

Dictionary methods: LZ family
Dictionary methods (LZ77, LZ78) replace repeated strings with references to earlier occurrences. LZ77 uses a sliding window: when a match is found in the window, the encoder outputs a pointer (distance, length) to the previous occurrence. LZ78 builds an explicit dictionary of phrases. Practical compressors (DEFLATE used by ZIP/PNG) combine LZ77 with Huffman coding to represent literals and pointers compactly.

Entropy and limits
Entropy H = −Σ p(i) log2 p(i) measures the minimum average number of bits per symbol required by any lossless coding scheme. No lossless compressor can always produce code lengths below entropy for arbitrary data. The effectiveness depends on redundancy in the specific data.

Practical considerations
Compression ratio depends on data type: text and structured data compress well; already compressed or random data compress poorly. Memory and CPU constraints influence algorithm choice: LZ77 with Huffman is good for general use; more powerful compressors (bzip2, LZMA) trade CPU and memory for better compression. Streaming systems use smaller windows to allow on-the-fly processing.

Use cases and file formats
PNG uses DEFLATE (LZ77 + Huffman) for lossless images; ZIP and gzip use similar approaches. Understanding how these methods work helps troubleshoot file sizes and choose appropriate settings for backup and transmission.

Why lossy compression
Lossy compression achieves higher compression ratios by discarding information judged least important for perception. It is used for images, audio and video where perfect reconstruction is not necessary. The design relies on human visual and auditory models to hide losses while keeping the content acceptable.

Transform coding
Most lossy image and video codecs use transform coding. Images are divided into blocks and a transform (such as the Discrete Cosine Transform, DCT) converts spatial samples into frequency coefficients. Energy often concentrates in a few low-frequency coefficients. Quantization reduces precision of high-frequency coefficients more than low-frequency ones because humans are less sensitive to fine details. After quantization, remaining coefficients are entropy-coded.

Perceptual models in audio
Audio codecs use psychoacoustic models: they identify frequencies that are masked by louder sounds and remove them, or reduce precision where errors are not audible. Temporal masking and frequency masking allow codecs like MP3 and AAC to remove inaudible components and achieve significant compression.

Rate–distortion trade-off
Compression involves choosing a point on the rate–distortion curve: lower bitrate (rate) means higher distortion. Encoder settings (quality level, quantization parameters, target bitrate) control this balance. There is a knee region where small increases in bitrate yield large improvement in quality; beyond that returns diminish.

Artifacts and practical limits
Excessive compression introduces artifacts: blocking and ringing in JPEG images, pre-echo or warbling in audio, and macroblocking or blurring in video. Choosing appropriate parameters and modern codecs reduces visible artifacts. For editing and archival tasks avoid lossy transforms to prevent cumulative degradation.

Modern codecs and improvements
New codecs (HEVC/H.265, AV1, newer image formats like WebP and HEIF) use better transforms, adaptive quantization and advanced prediction to improve compression efficiency. However, decoding complexity and patent/licensing issues are practical constraints. When designing systems, decide whether lossy compression is acceptable, and choose codecs matching quality, latency and licensing needs.

Need for error control
Bits can be corrupted during storage or transmission due to noise, interference or hardware faults. Error control schemes add redundancy so receivers can detect and possibly correct errors, allowing reliable communication and storage without undetectable corruption.

Parity bits
Parity is the simplest detection method: append a bit so total number of 1s in a block is even (even parity) or odd (odd parity). Parity detects any odd number of bit errors but fails for even-numbered bit flips. It is cheap and used for simple link-level error detection where the error environment is mild.

Checksums
Checksums compute a sum of data words (commonly modulo 2^n) and append the result. They detect many common errors like single-bit flips and some multi-bit errors, but carefully crafted changes can cancel out and escape detection. Checksums are used in transport protocols and file formats for quick integrity checks.

Cyclic Redundancy Check (CRC)
CRC treats bit sequences as polynomials over GF(2) and computes a remainder when dividing by a chosen generator polynomial. The transmitter appends this remainder; the receiver recomputes the remainder and if non-zero detects an error. Well-chosen CRC polynomials detect single-bit errors, double-bit errors, and burst errors up to certain lengths. CRCs are efficient in hardware using shift registers and XOR gates and are widely used in networking and storage.

Error correction: Hamming and FEC
Error correction adds more redundancy so some errors can be corrected without retransmission. Hamming codes are simple block codes capable of detecting and correcting single-bit errors and detecting some double-bit errors; they place parity bits at positions that are powers of two and compute parity checks whose pattern (syndrome) pinpoints the erroneous bit. More powerful forward error correction (FEC) codes — Reed–Solomon, convolutional codes, LDPC and Turbo codes — can correct multiple errors and are used in CDs, DVDs, mobile and satellite communications.

Trade-offs and system design
Error detection is cheaper but requires retransmission on failure (ARQ). FEC reduces retransmission but increases bandwidth or storage due to extra redundancy. System designers choose methods based on channel error characteristics, latency tolerance and resource constraints.

From bits to signals
Line coding converts sequences of bits into electrical or optical signals suitable for the transmission medium. The choice of line code affects synchronization, DC content, spectral properties (bandwidth), and susceptibility to noise. Good line coding helps receivers recover clock timing and data reliably.

NRZ (Non-Return-to-Zero)
NRZ maps logical 1 to one signal level and logical 0 to another, without returning to a neutral level between bits. It is simple and bandwidth-efficient but suffers from long runs of identical bits causing baseline wander and loss of clock recovery because there may be no transitions to lock onto.

Manchester encoding
Manchester encoding combines clock and data by using transitions in the middle of each bit period. One convention uses high-to-low as 0 and low-to-high as 1 (or vice versa depending on standard). Because every bit has a transition, Manchester simplifies clock recovery and has no DC component, but it uses roughly twice the bandwidth compared to NRZ for the same data rate because the effective fundamental frequency is doubled.

Multi-level signalling and baud vs bit rate
Baud is the number of signal symbols transmitted per second. Bit rate is the number of information bits transmitted per second. If each symbol encodes multiple bits (multi-level signalling such as M-ary PAM or QAM), then bit rate = baud × bits_per_symbol. For binary signalling bits_per_symbol = 1 so baud equals bit rate. Modern modems increase bits_per_symbol to achieve higher bit rates in limited bandwidth by using amplitude and phase modulation.

Trade-offs and channel considerations
Line coding affects spectral occupancy and susceptibility to channel impairments. Manchester is robust for clock recovery but consumes more bandwidth; NRZ is compact but needs additional protocols for clocking and DC compensation. Practical systems combine line coding with higher-layer framing, error control and equalization to achieve reliable data transfer over the physical medium.

Examples and calculations
If a link uses Manchester encoding at a data bit rate of 1 Mbps, the required bandwidth is roughly double that of NRZ for the same bit rate, i.e., approximately 2 MHz of fundamental frequency. If a modem transmits 2400 baud with 4 bits per symbol, the bit rate is 2400 × 4 = 9600 bits/s.

Why practical calculations matter
Understanding how to compute sizes, perform conversions and measure precision helps you design and debug systems, choose formats and answer exam questions. This topic collects common calculation patterns that appear repeatedly across encodings.

File size calculations
For uncompressed data, multiply counts by size per item: image bytes = width × height × bits_per_pixel / 8. Audio bytes = sampling_rate × bits_per_sample × channels × duration_seconds / 8. Video bytes/second = width × height × bytes_per_pixel × frames_per_second. For storage estimates include headers and metadata: add a small overhead percentage (commonly 1–5%) if exact format headers are unknown.

Converting representations
Follow step-by-step procedures: to convert decimal to binary use repeated division; to convert binary fraction to decimal multiply by powers of two; to form two's complement invert bits and add one; to form IEEE 754 single precision convert to binary, normalize, compute biased exponent and fill fraction bits then round. Always verify by converting back to decimal.

Precision and rounding examples
Floating-point rounding can cause surprising results: (0.1)₁₀ cannot be represented exactly in binary floating-point and accumulates error when summed many times. Machine epsilon for IEEE 754 single is about 1.19×10^{−7}; comparing floats for equality is unsafe—use tolerances.

Error-control practicalities
To detect errors choose CRC of appropriate degree based on expected burst length; small embedded links can use parity; file checksums (e.g., SHA or MD5) detect accidental corruption but are not substitutes for CRC in streaming hardware because of performance differences.

Worked examples checklist
When solving exam/assignment problems: write base assumptions (signed/unsigned, bit width), show intermediate steps (division remainders, carries, inversion and addition for two's complement, normalization for floating point), and check results by reverse conversion or range checks. State units (bytes, bits, MB) clearly and use powers of 1024 vs 1000 appropriately when required by question context.

Summary
Practical calculation skills connect theoretical encoding knowledge to real systems and exam questions. Practice converting, calculating sizes and analysing precision issues to build confidence and avoid common mistakes in programming and data handling.