Comece

Três linhas

#include "smart2raw.h"

S2RPool p;
s2r_pool_init(&p, s2r_classify_array(valores, n), n);    /* 1. classificar */
for (size_t i = 0; i < n; i++) s2r_push(&p, valores[i]);  /* 2. guardar     */
size_t k = s2r_count_gt_fast(&p, 100);                    /* 3. operar      */

Compile com o que você já tem:

cc -O2 -std=c11 -I include seu_programa.c -o seu_programa

Deixe a biblioteca escolher a forma

A porta de entrada óbvia nem sempre é a certa. Em 4 milhões de timestamps o pool plano dá 15,26 MB e 0,73 ms, enquanto a forma em blocos dá 4,11 MB e 0,04 ms — então pergunte antes de decidir:

S2RAdvice a;
s2r_recommend(valores, n, &a);
printf("melhor: %s, %zu bytes (linha de base %zu)\n", a.best, a.best_bytes, a.raw_bytes);

Salvar e carregar

S2RBlocked b;
s2r_blocked_build_auto(&b, valores, n);   /* o tamanho de bloco é planejado, não chutado */
s2r_blocked_save(&b, "coluna.s2r");

O arquivo é little-endian canônico com CRC32: é idêntico em qualquer máquina, e um byte corrompido é pego na carga em vez de ser devolvido como dado.

Sem escrever C: as ferramentas de linha de comando

Se você quer avaliar antes de escrever código, o repositório traz três programas. Um make dentro de tools/ compila os três, e eles não pedem nada além do gcc.

s2r pack   dados.txt coluna.s2r          # texto → .s2r, classificando
s2r info   coluna.s2r                    # a classe escolhida, a contagem, o tamanho
s2r agg    coluna.s2r count-gt 100       # a consulta, direto no arquivo
s2r verify coluna.s2r                    # magia, classe, contagem e CRC32

O s2r_verify existe separado por um motivo: ele sai com código 0 quando o arquivo está íntegro e diferente de zero quando não está, então serve dentro de script e de CI sem precisar interpretar saída. E o s2r_convert fecha o ciclo — converte, processa na forma compacta e desconverte — com um teto de estouro que recusa em vez de promover além dele:

s2r_convert dados.txt saida.txt --op mul --by 3 --cap 32

São 19 checagens em tools/test_cli.sh, e elas rodam junto com o resto.

Downloads

s2r-probe.exe dados.csv --coluna 3 --salvar coluna.s2r

Ele imprime a classe escolhida, o tamanho contra int64 e contra dicionário, RLE e bitmap, a consulta cronometrada, e sai com código 0 só quando todas as verificações internas passaram.

Onde roda

O mesmo arquivo, com os mesmos testes passando: x86-64 com SSE2 e AVX2, ARM com NEON e SVE2, RISC-V com RVV, máquinas big-endian, e microcontroladores em modo enxuto (-DS2R_NO_STDIO -DS2R_NO_MMAP -DS2R_NO_SIMD). E, a partir deste site, em WebAssembly e num PE de Windows ligado sem runtime de C.

Vale dizer como cada um é verificado, porque não é a mesma coisa. Em hardware real roda um: x86-64, que é a máquina da integração contínua. ARM64 e s390x são ISA real em máquina emulada (QEMU), a cada commit — as instruções e a ordem de bytes são as do alvo; o silício não é. E vale ser específico sobre o que isso prova, porque "big-endian" costuma ser uma palavra e não uma medida: antes de qualquer teste, o job compila um binário s390x e o executa, e ele imprime __BYTE_ORDER__ : big e o valor 0x01020304 gravado na memória como 01 02 03 04, saindo com erro se não for; em cima disso rodam 250.212 checagens em 16 suítes, 0 falhas. O modo de microcontrolador (-DS2R_NO_STDIO -DS2R_NO_MMAP -DS2R_NO_SIMD) é uma configuração de compilação, não uma placa.

Os núcleos RVV e SVE2 rodam de verdade — o código vetorial que vai para o hardware, não uma reimplementação — conferidos elemento a elemento contra uma referência escalar, com o comprimento de vetor varrido de 128 a 1024 bits e com as bordas de tira e as caudas exercitadas explicitamente. Uma placa real teria dado um comprimento só; a varredura cobre a família inteira, que é exatamente o que um kernel agnóstico de comprimento precisa provar.

Licença

A versão publicada está sob AGPL-3.0-or-later. Se você pretende embutir o Smart2Raw em algo que não vai publicar sob a mesma licença, isso exige uma licença comercial — que é também o caminho para a versão avançada.