I tranelli nascosti dell'arithmetic coding: perché il tuo compressore spreca bit preziosi

Hai mai codificato un arithmetic coding e pensato di aver fatto un ottimo lavoro? È un algoritmo pulito, che trasforma sequenze di bit in intervalli probabilistici con precisione chirurgica. Peccato che la maggior parte delle versioni base che girano online sottoperformino senza dirlo.

Non parlo di velocità di calcolo (anche se conta). Mi riferisco al rapporto di compressione, il vero motivo per cui usi l'entropy coding.

L'implementazione da manuale che inganna

Prendiamo il classico esempio che trovi ovunque. Funziona più o meno così:

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;
    }
    
    // Scarica byte quando sono certi
    while left >> 24 == right >> 24 {
        output_byte((left >> 24) as u8);
        left <<= 8;
        right = (right << 8) | 0xff;
    }
}

Sembra logico: mantieni un intervallo [left, right] che si restringe a ogni bit, in base alla probabilità. Quando un byte è stabile, lo emetti e liberi spazio per la precisione successiva.

Il guaio? C'è un'asimmetria nascosta che il modello matematico ideale non prevede.

Il problema dei confini dei byte

Qui casca l'asino. Nella teoria perfetta, intervalli della stessa dimensione si comportano uguale. Con interi a 32 bit, no.

Prova a pensare a due casi:

1. Un intervallo da left = 0 non scende mai sotto 2^24 bit.
2. Uno da left = 2^31 - 1 può ridursi a soli 2 bit.

Colpa della condizione while left >> 24 == right >> 24. Dipende dalla posizione dell'intervallo, non solo dalla sua grandezza.

Se l'intervallo cavalca un confine di byte – tipo [2^31 - 1, 2^31] – diventa minuscolo. Le probabilità si quantizzano male. Un bit con p=0.95 finisce spaccato 50/50, perché non c'è spazio per sfumature.

Risultato: emetti bit in eccesso rispetto all'entropia teorica.

Il decoder più complicato del necessario

Anche il decoder nasconde insidie:

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
}

Gestisce left, right e x (il valore codificato corrente). Ma in teoria bastano due info: lunghezza intervallo (right - left) e posizione relativa (x - left).

Lo fa complesso per quel ciclo di precisione. Lega tutto alla posizione assoluta, non alla dimensione relativa.

Conseguenze:

• Più registri usati
• Meno ottimizzazioni dal compilatore
• Codice difficile da seguire

Tutto per una condizione che dovrebbe ignorare dove sta l'intervallo.

Come sistemare

La soluzione? Ripensa la gestione della precisione. Invece di scaricare byte in base al byte alto uguale (dipendente dalla posizione), usa solo la lunghezza dell'intervallo (indipendente).

Sembra facile, ma va rifatto l'intero loop di encode/decode. In cambio: compressione ottimale, decoder più snello e veloce.

Perché conta per NameOcean

Da NameOcean aiutiamo developer che creano app AI con Vibe Hosting o sistemi super ottimizzati. Che comprimi dati per storage cloud, payload API o dataset enormi, queste basi sulla compressione sono cruciali.

Molti usano librerie pronte senza capirne i limiti. Un +5-10% sul rapporto di compressione è poco... finché non gestisci petabyte o milioni di request.

Lezione chiave: le implementazioni "standard" nascondono trappole. Scava. Capisci le assunzioni. Sfida le asimmetrie. I migliori non copiano algoritmi: li dominano, inclusi i casi limite.

Se sviluppi app cloud ad alte prestazioni, rifletti: le scelte infrastrutturali si sommano. Piccoli fix algoritmici, su milioni di operazioni, fanno la differenza. Vuoi ottimizzare lo stack? I dettagli vincono.