Draft of using FastAC to code -256 .. 255 with Laplace dist.

// Using FastAC by Amir Said -- http://www.cipr.rpi.edu/research/SPIHT/EW_Code/FastAC.zip
#include "arithmetic_codec.h"

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/laplace_distribution.hpp>

#include <vector>

std::size_t const N_VAL(1 << 20);

// ============================================================================
// Generate some random data with distribution similar to what's in the question

std::vector<int32_t> gen_data(std::size_t n)
{
    boost::random::mt19937 rng;
    boost::random::laplace_distribution<> dist(0, 20);

    std::vector<int32_t> data;
    data.reserve(n);

    for (; data.size() < n;) {
        int32_t v = static_cast<int32_t>(std::round(dist(rng)));
        if ((v >= -256) && (v <= 255)) {
            data.push_back(v);
        }
    }

    return data;
}

// ============================================================================
// Ziz-Zag Coding
//
// Maps signed integers into unsigned integers
// 0 => 0, -1 => 1, 1 => 2, -2 => 3, 2 => 4 ...

uint32_t zigzag_encode(int32_t v)
{
    return static_cast<uint32_t>((v >> 31) ^ (v << 1));
}

std::vector<uint32_t> zigzag_encode(std::vector<int32_t> const& data)
{
    std::vector<uint32_t> result(data.size());
    std::transform(data.begin(), data.end(), result.begin(),
        [](int32_t v) -> uint32_t { return zigzag_encode(v); });
    return result;
}

int32_t zigzag_decode(uint32_t v)
{
    return (static_cast<int32_t>(v) >> 1) ^ -(static_cast<int32_t>(v)& 1);
}

std::vector<int32_t> zigzag_decode(std::vector<uint32_t> const& data)
{
    std::vector<int32_t> result(data.size());
    std::transform(data.begin(), data.end(), result.begin(),
        [](uint32_t v) -> int32_t { return zigzag_decode(v); });
    return result;
}

// ============================================================================
// Simple approach with 1 adaptive model for 512 symbols
// Processes zig-zag coded 9-bit values

template<typename ModelT, typename CodecT = Arithmetic_Codec>
uint32_t encode(std::vector<uint32_t> const& buffer
    , ModelT& model
    , CodecT& encoder)
{
    encoder.start_encoder();
    for (uint32_t v : buffer) {
        encoder.encode(v, model);
    }
    return 8 * encoder.stop_encoder();
}

template<typename ModelT, typename CodecT = Arithmetic_Codec>
void decode(std::vector<uint32_t>& buffer
    , ModelT& model
    , CodecT& decoder)
{
    decoder.start_decoder();
    for (uint32_t i(0); i < buffer.size(); ++i) {
        buffer[i] = decoder.decode(model);
    }
    decoder.stop_decoder();
}

void test_simple(std::vector<uint32_t> const& zdata)
{
    Arithmetic_Codec codec(N_VAL * 2);
    Adaptive_Data_Model adaptive_model(512);

    std::size_t raw_size_bits(N_VAL * 9);
    std::size_t packed_size_bits(encode(zdata, adaptive_model, codec));
    double ratio(double(packed_size_bits) / raw_size_bits * 100);
    std::cout << "Ratio = " << ratio << " %\n";

    std::vector<uint32_t> dzdata(N_VAL);

    adaptive_model.reset();

    decode(dzdata, adaptive_model, codec);

    std::cout << "Match = " << ((zdata == dzdata) ? "true" : "false") << "\n";
}

// ============================================================================
// Split approach with 3 adaptive models (1*2 and 2*256 symbols)
// Processes zig-zag coded 9-bit values
//
// First the MSB is coded using the 2 symbol model_msb
// If MSB == 0 then LSB is coded using the 256 symbold model_lsb0
// If MSB == 1 then LSB is coded using the 256 symbold model_lsb1

template<typename ModelT, typename CodecT = Arithmetic_Codec>
uint32_t encode(std::vector<uint32_t> const& buffer
    , ModelT& model_msb
    , ModelT& model_lsb0
    , ModelT& model_lsb1
    , CodecT& encoder)
{
    encoder.start_encoder();
    for (uint32_t v : buffer) {
        uint32_t msb(v >> 8);
        uint32_t lsb(v & 0xFF);

        encoder.encode(msb, model_msb);
        if (msb == 0) {
            encoder.encode(lsb, model_lsb0);
        } else {
            encoder.encode(lsb, model_lsb1);
        }
    }
    return 8 * encoder.stop_encoder();
}

template<typename ModelT, typename CodecT = Arithmetic_Codec>
void decode(std::vector<uint32_t>& buffer
    , ModelT& model_msb
    , ModelT& model_lsb0
    , ModelT& model_lsb1
    , CodecT& decoder)
{
    decoder.start_decoder();
    for (uint32_t i(0); i < buffer.size(); ++i) {
        uint32_t msb(decoder.decode(model_msb));
        uint32_t lsb;
        if (msb == 0) {
            lsb = decoder.decode(model_lsb0);
        } else {
            lsb = decoder.decode(model_lsb1);
        }
        buffer[i] = (msb << 8) | lsb;
    }
    decoder.stop_decoder();
}

void test_split(std::vector<uint32_t> const& zdata)
{

    Arithmetic_Codec codec(N_VAL * 2);
    Adaptive_Data_Model adaptive_model_msb(2);
    Adaptive_Data_Model adaptive_model_lsb0(256);
    Adaptive_Data_Model adaptive_model_lsb1(256);

    std::size_t raw_size_bits(N_VAL * 9);
    std::size_t packed_size_bits(encode(zdata, adaptive_model_msb
        , adaptive_model_lsb0, adaptive_model_lsb1, codec));
    double ratio(double(packed_size_bits) / raw_size_bits * 100);
    std::cout << "Ratio = " << ratio << " %\n";

    std::vector<uint32_t> dzdata(N_VAL);

    adaptive_model_msb.reset();
    adaptive_model_lsb0.reset();
    adaptive_model_lsb1.reset();

    decode(dzdata, adaptive_model_msb
        , adaptive_model_lsb0, adaptive_model_lsb1, codec);

    std::cout << "Match = " << ((zdata == dzdata) ? "true" : "false") << "\n";
}

// ============================================================================
// PN approach with 3 adaptive models (1*2 and 2*256 symbols)
// Processes signed 9-bit values
//
// First the sign is coded using the 2 symbol model_sign
// If sign positive then abs value is coded using the 256 symbol model_valuep
// If sign negative then abs value - 1 is coded using the 256 symbol model_valuen

template<typename ModelT, typename CodecT = Arithmetic_Codec>
uint32_t encode(std::vector<int32_t> const& buffer
    , ModelT& model_sign
    , ModelT& model_valuep
    , ModelT& model_valuen
    , CodecT& encoder)
{
    encoder.start_encoder();
    for (int32_t v : buffer) {
        uint32_t sign, value;
        if (v >= 0) {
            sign = 0;
            value = v;
        } else {
            sign = 1;
            value = std::abs(v) - 1;
        }

        encoder.encode(sign, model_sign);
        if (sign == 0) {
            encoder.encode(value, model_valuep);
        } else {
            encoder.encode(value, model_valuen);
        }
    }
    return 8 * encoder.stop_encoder();
}

template<typename ModelT, typename CodecT = Arithmetic_Codec>
void decode(std::vector<int32_t>& buffer
    , ModelT& model_sign
    , ModelT& model_valuep
    , ModelT& model_valuen
    , CodecT& decoder)
{
    decoder.start_decoder();
    for (uint32_t i(0); i < buffer.size(); ++i) {
        uint32_t sign(decoder.decode(model_sign));
        int32_t value;
        if (sign == 0) {
            value = decoder.decode(model_valuep);
            buffer[i] = value;
        } else {
            value = decoder.decode(model_valuen);
            buffer[i] = -(value + 1);
        }
    }
    decoder.stop_decoder();
}

void test_split_pn(std::vector<int32_t> const& data)
{

    Arithmetic_Codec codec(N_VAL * 2);
    Adaptive_Data_Model adaptive_model_sign(2);
    Adaptive_Data_Model adaptive_model_valuep(256);
    Adaptive_Data_Model adaptive_model_valuen(256);

    std::size_t raw_size_bits(N_VAL * 9);
    std::size_t packed_size_bits(encode(data, adaptive_model_sign
        , adaptive_model_valuep, adaptive_model_valuen, codec));
    double ratio(double(packed_size_bits) / raw_size_bits * 100);
    std::cout << "Ratio = " << ratio << " %\n";

    std::vector<int32_t> ddata(N_VAL);

    adaptive_model_sign.reset();
    adaptive_model_valuep.reset();
    adaptive_model_valuen.reset();

    decode(ddata, adaptive_model_sign
        , adaptive_model_valuep, adaptive_model_valuen, codec);

    std::cout << "Match = " << ((data == ddata) ? "true" : "false") << "\n";
}

// ============================================================================

int main()
{
    std::vector<int32_t> data(gen_data(N_VAL));
    std::vector<uint32_t> zdata(zigzag_encode(data));

    test_simple(zdata);
    test_split(zdata);
    test_split_pn(data);

    return 0;
}

// ============================================================================