> rice | adaptive | compress <

// Rice Coding - Adaptive integer compression with tunable parameter

INPUT 0 chars

k parameter

Show Steps

Separate Codes

OUTPUT 0 chars

>> features

[ADAPTIVE]

Tunable Parameter

Adjust k to optimize for different data distributions.

[EFFICIENT]

Geometric Data

Optimal for data with geometric or exponential distribution.

[SIMPLE]

Fast Coding

Simple division and remainder operations for speed.

>> technical info

How Rice Coding Works

Rice coding divides each integer n by 2^k to get quotient q and remainder r. The quotient is encoded in unary (q ones followed by a zero), and the remainder is encoded in k binary bits. This creates a variable-length code that adapts to the data distribution through the k parameter.

Rice Coding Example (k=2)

k=2, M=2^2=4

0 → q=0, r=0 → 0|00 → 000
1 → q=0, r=1 → 0|01 → 001
2 → q=0, r=2 → 0|10 → 010
3 → q=0, r=3 → 0|11 → 011
4 → q=1, r=0 → 10|00 → 1000
5 → q=1, r=1 → 10|01 → 1001
6 → q=1, r=2 → 10|10 → 1010
7 → q=1, r=3 → 10|11 → 1011
8 → q=2, r=0 → 110|00 → 11000

Larger k: fewer unary bits, more binary bits
Smaller k: more unary bits, fewer binary bits

Why Use Rice Coding

Adaptive to data distribution
Simple to implement
Fast encode/decode
Good for sensor data
Efficient for small integers

>> frequently asked questions

What is Rice coding?

Rice coding is a variable-length entropy encoding method that's particularly efficient for geometric distributions. It's a special case of Golomb coding where the divisor M is restricted to powers of 2 (M = 2^k), making it faster to compute using bit shifts.

How to choose the k parameter?

The optimal k depends on your data distribution. For data with mean μ, the optimal k ≈ log₂(μ × ln(2)). Small k (0-2) works well for very small numbers, while larger k (4-8) is better for data with larger values. Use the analyze function to find the optimal k for your data.

Rice vs Golomb coding?

Rice coding is a subset of Golomb coding where M = 2^k. This restriction makes Rice coding faster (using bit shifts instead of division) but potentially less optimal. Golomb can choose any M value for better compression, while Rice trades some compression efficiency for speed.

Where is Rice coding used?

Rice coding is widely used in lossless audio compression (FLAC, ALAC), image compression (JPEG-LS), and data from sensors with geometric distributions. It's particularly effective when data values are small non-negative integers with exponentially decreasing probability.

Rice coding in FLAC audio — how does it actually compress?

FLAC (Free Lossless Audio Codec) is the canonical Rice-coding success story. The pipeline: 1. Split audio into small blocks (typically 4096 samples). 2. Fit a linear predictor (LPC) to each block; subtract the prediction from the actual samples to get residuals. 3. Residuals have a roughly Laplace / geometric distribution — peaked at 0, tails falling off exponentially. Exactly what Rice coding is optimal for. 4. Choose an adaptive <code>k</code> parameter per partition (<code>k = round(log2(mean / log(2)))</code>). 5. Encode each residual with Rice(<code>k</code>): unary quotient + <code>k</code>-bit remainder. For well-predicted audio, most residuals are small integers (±1 to ±64). Rice encodes these in 5-8 bits instead of the 16-24 bits the raw sample would need. Compression ratio: 50-60% of original, fully lossless. ALAC (Apple Lossless) uses a near-identical scheme.

How do I map signed integers into Rice coding?

Rice coding natively handles only non-negative integers. For signed data (like audio residuals which can be negative), use ZigZag encoding or the equivalent sign/magnitude interleave first: <code>zigzag(n) = (n << 1) ^ (n >> 31)</code> (for 32-bit) This maps: • 0 → 0 • -1 → 1 • 1 → 2 • -2 → 3 • 2 → 4 • -3 → 5 • ... Small-magnitude negatives and positives both map to small non-negative integers, preserving the geometric distribution. After Rice decoding, reverse with <code>(z >> 1) ^ -(z & 1)</code>. This is exactly how Protocol Buffers encode signed varints, and how FLAC and JPEG-LS handle negative residuals.

Rice vs Elias gamma/delta vs varint — which integer code wins?

All are prefix-free codes for non-negative integers, but they optimize for different distributions: • Rice: <code>k</code>-tunable. Optimal for geometric distributions with mean = <code>2^k</code>. Best when you can tune k to match the data. • Elias gamma: <code>⌊log2(n)⌋+1</code> unary + <code>⌊log2(n)⌋</code> binary bits. Best when distribution is heavy-tailed (many small + few huge values). • Elias delta: gamma-encoded length + binary body. Best for very heavy tails. • Varint (LEB128): 7 data bits per byte + continuation bit. Best for bytewise alignment; used in Protobuf, MIDI, DWARF. • Exp-Golomb: Generalized Elias gamma with parameter <code>k</code>. Used in H.264/H.265 for syntax elements. Rule of thumb: tune Rice when you know your data's mean; use Elias gamma when you don't; use varint when you need bytewise alignment over bitwise packing.