Capcane ascunse în Arithmetic Coding: De ce compresia ta risipește biți prețioși

Ai implementat vreodată arithmetic coding? Te simți mândru de rezultat. E un algoritm elegant care transformă secvențe de biți în intervale precise de probabilități. Dar realitatea e dură: majoritatea codurilor simple de pe net nu comprimă la potențial maxim.

Nu vorbesc de viteză pe CPU (deși contează). Vorbesc de raportul de compresie – motivul principal pentru care folosești entropy coding.

Implementarea clasică care te păcălește

Ce vezi în tutoriale? Un cod standard gen:

let mut left: u32 = 0;
let mut right: u32 = u32::MAX;

fn encode_bit(bit: bool, probability: f32) {
    let mid = left + ((right - left) as f32 * probability) as u32;
    if !bit {
        right = mid;
    } else {
        left = mid + 1;
    }
    
    while left >> 24 == right >> 24 {
        output_byte((left >> 24) as u8);
        left <<= 8;
        right = (right << 8) | 0xff;
    }
}

Logic, nu? Menții un interval [left, right]. Fiecare bit îl micșorează după probabilitate. Când un byte e sigur, îl scoți și continui.

Problema? Are o asimetrie discretă, absentă în modelul matematic perfect.

Trădarea limitelor de byte

Aici intervine haosul. În varianta ideală cu precizie infinită, toate intervalele de lungime egală se comportă la fel. Dar cu 32 de biți, nu.

Exemple clare:

1. Interval de la left = 0 nu scade sub 2^24 biți.
2. Unul de la left = 2^31 - 1 ajunge la doar 2 biți.

De ce? Condiția left >> 24 == right >> 24 depinde de poziție, nu doar de mărime.

Dacă intervalul trece o graniță de byte – gen [2^31 - 1, 2^31] – devine minuscul. Probabilitățile se cuantizează grosier. Un bit cu probabilitate 0.95 se împarte 50/50, din lipsă de precizie.

Rezultat? Emiți biți în plus față de teoria entropiei.

Decodorul cu secrete proprii

Și decodorul ascunde belele:

fn decode_bit(probability: f32) -> bool {
    let mid = left + ((right - left) as f32 * probability) as u32;
    if x <= mid {
        right = mid;
        bit = false;
    } else {
        left = mid + 1;
        bit = true;
    }
    
    while left >> 24 == right >> 24 {
        left <<= 8;
        right = (right << 8) | 0xff;
        x = (x << 8) | (bytes.next().unwrap() as u32);
    }
    
    bit
}

Urmărește left, right și x (valoarea codată). Matematic, ajungi doar cu lungimea intervalului (right - left) și poziția relativă (x - left).

De ce trei variabile? Din cauza buclei de precizie. Condiția leagă totul de poziția absolută, nu de mărime relativă.

Consecințe:

• Mai multă presiune pe registre.
• Optimizări compiler mai slabe.
• Cod greu de înțeles.

Soluția inteligentă

Schimbă abordarea. Nu mai arunca biți după byte-ul superior identic (dependent de offset). Folosește doar lungimea intervalului (independent de offset).

Pare ușor? Cere recalibrare totală a buclelor. Beneficiu? Compresie optimă și decodor mai rapid, mai curat.

De ce contează la NameOcean

La NameOcean, ajutăm developeri să construiască app-uri AI cu Vibe Hosting sau sisteme ultra-optimizate. Comprimarea salvează spațiu în cloud, micșorează payload-uri API sau procesează date masive eficient.

Mulți preiau librării fără să le testeze limitele. Un plus de 5-10% la compresie pare mic – până la petabyte de date sau milioane de request-uri.

Lecția mare: implementările "standard" au capcane. Analizează-le. Contestă asimetriile. Cei mai buni ingineri nu copiază algoritmi – îi disecă.

Pentru app-uri critice pe cloud, deciziile de infrastructură se înmulțesc rapid. Optimizări mici, la scară mare, fac diferența. Vrei să-ți tunezi stack-ul? Detaliile decid.