Die versteckten Fallen beim Arithmetic Coding: Warum deine Kompression unnötig Bits verschwendet

Arithmetic Coding fühlt sich immer wie der Hammer an. Ein schlauer Algorithmus, der Bit-Sequenzen sauber in Wahrscheinlichkeitsbereiche packt. Doch die Wahrheit: Viele Standard-Implementierungen aus dem Netz arbeiten im Hintergrund total ineffizient.

Nicht nur bei der Rechenleistung – nein, vor allem beim Kompressionsverhältnis. Genau dafür nutzt du Entropy Coding.

Der Klassiker, der enttäuscht

Du kennst das sicher: Tutorials zeigen so was hier.

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;
    }
}

Klingt logisch. Du pflegst einen Bereich [left, right], der mit jedem Bit enger wird. Sobald Bytes fix sind, spuckst du sie aus und gewinnst Präzision.

Der Haken? Diese Variante hat eine krasse Ungleichheit, die im Mathe-Modell gar nicht vorkommt.

Der Verrat an den Byte-Grenzen

Im perfekten Arithmetic Coding sind alle Intervalle gleicher Länge gleich. Bei 32-Bit-Ints? Fehlanzeige.

Zwei Fälle:

1. Ein Intervall bei left = 0 schrumpft nie unter 2^24 Bits.
2. Bei left = 2^31 - 1 kann es auf 2 Bits runtergehen.

Schuld ist die Bedingung left >> 24 == right >> 24. Die hängt von der Position ab, nicht nur von der Breite.

Stell dir vor, dein Intervall klemmt an einer Byte-Grenze – wie [2^31 - 1, 2^31]. Zu eng für feine Wahrscheinlichkeiten. Dein 0.95-Bit wird zu 50/50 quantisiert. Ergebnis: Mehr Bits als nötig.

Der Decoder mit doppeltem Boden

Ähnliches Chaos beim Decoder:

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
}

Der Decoder jongliert left, right und x. Mathe-mäßig reichen Längen (right - left) und Position (x - left). Aber der While-Loop zwingt zu absoluten Werten.

Folgen: Mehr Register, schlechtere Optimierungen, komplizierter Code. Alles nur wegen Positionsabhängigkeit.

Der richtige Weg raus

Lösung: Präzisionssteuerung umkrempeln. Statt Byte-Dumping bei gleichem Top-Byte (positionsabhängig) auf reine Intervall-Länge setzen (positionsunabhängig).

Klingt easy, braucht aber Loop-Überholung. Gewinn: Bessere Kompression, simpler und flotter Decoder.

Warum das bei NameOcean zählt

Bei NameOcean helfen wir Entwicklern bei AI-Apps mit Vibe Hosting oder High-Perf-Systemen. Ob Cloud-Speicher, API-Pakete oder Big-Data-Cruncher – gute Kompression spart massiv.

Viele greifen zu fertigen Libs, ohne Grenzen zu checken. 5-10% mehr Effizienz? Bei Petabyte oder Millionen Requests ein Gamechanger.

Lektion: "Standard"-Code täuscht. Grab tiefer, prüf Annahmen, jag Asymmetrien. Top-Engineer kapieren Edge-Cases.

Bei Cloud-Apps zählen Infra-Entscheidungen doppelt. Winzige Algo-Tweaks skalieren brutal. Optimierst du deinen Stack? Details machen den Unterschied.