🔶 Avx-Arrow

Formato Colunar Nativo de Alta Performance

Ver Exemplos Referência da API

Visão Geral do Módulo

Avx-Arrow é um formato de dados colunar desenvolvido do zero para performance máxima em cargas de trabalho científicas e analíticas. Com tipos científicos nativos e otimizações SIMD avançadas, oferece 3-5x mais velocidade que implementações tradicionais.

⚡

Zero-Copy

Operações sem cópia de dados para máxima eficiência de memória e cache.

🔬

Tipos Científicos

Quaternions, Tensors, Complex e Spinors nativos para computação científica.

🗜️

Compressão

LZ4, Zstd, Delta, RLE e Dictionary para reduzir uso de memória.

🔗

Integração

Bindings para Python/NumPy/Pandas e WebAssembly nativos.

Todos os Tipos Disponíveis

Tipos Primitivos

Tipo Descrição Tamanho Uso
Int8/UInt8 Inteiros de 8 bits 1 byte Flags, pequenos contadores
Int16/UInt16 Inteiros de 16 bits 2 bytes IDs pequenos, portas
Int32/UInt32 Inteiros de 32 bits 4 bytes IDs, timestamps
Int64/UInt64 Inteiros de 64 bits 8 bytes IDs grandes, timestamps precisos
Float16 Float de meia precisão 2 bytes ML inference, GPU
Float32 Float de precisão simples 4 bytes Gráficos, física
Float64 Float de dupla precisão 8 bytes Ciência, engenharia
Boolean Valor booleano 1 bit Flags, máscaras

Tipos Científicos (Exclusivos)

🔄 Quaternion

Uso: Rotações 3D, orientação espacial, gráficos

let q = Quaternion::new(1.0, 0.0, 0.0, 0.0);
let from_euler = Quaternion::from_euler(0.0, 90.0, 0.0);
let rotated = q * from_euler;

📊 Tensor

Uso: Machine learning, arrays multidimensionais

let tensor = TensorArray::from_shape_vec(
    vec![2, 3, 3],
    vec![1.0, 2.0, 3.0, ...]
)?;

🔢 Complex

Uso: Processamento de sinais, FFT, física quântica

let c = Complex::new(1.0, 2.0);
let magnitude = c.magnitude();
let phase = c.phase();

⚛️ Spinor

Uso: Física quântica, teoria da relatividade

let spinor = Spinor::new([1.0, 0.0], [0.0, 1.0]);
let evolved = spinor.evolve(hamiltonian, time);

Exemplos de Uso

Exemplo 1: Arrays Básicos

Rust 
use avx_arrow::array::*;
use avx_arrow::{Schema, Field, DataType, RecordBatch};

// Criar arrays
let ids = Int64Array::from(vec![1, 2, 3, 4, 5]);
let names = StringArray::from(vec!["Alice", "Bob", "Carol", "Dave", "Eve"]);
let scores = Float64Array::from(vec![95.5, 87.3, 92.1, 88.9, 91.0]);

// Schema
let schema = Schema::new(vec![
    Field::new("id", DataType::Int64),
    Field::new("name", DataType::Utf8),
    Field::new("score", DataType::Float64),
]);

// RecordBatch
let batch = RecordBatch::try_new(
    schema,
    vec![Box::new(ids), Box::new(names), Box::new(scores)]
)?;

println!("Batch: {} linhas, {} colunas",
    batch.num_rows(), batch.num_columns());

Exemplo 2: Operações de Computação

Rust 
use avx_arrow::compute::*;

let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
let b = Int32Array::from(vec![10, 20, 30, 40, 50]);

// Aritmética
let sum = add(&a, &b)?;
let product = multiply(&a, &b)?;

// Agregações
let total = sum_i32(&a)?;
let average = mean_f64(&a)?;

// Filtros
let mask = BooleanArray::from(vec![true, false, true, false, true]);
let filtered = filter(&a, &mask)?;

Exemplo 3: Compressão

Rust 
use avx_arrow::compression::*;

// LZ4 (rápido)
let data = Int32Array::from(vec![1, 2, 3, 4, 5]);
let compressed = lz4_compress(&data)?;

// Zstd (máxima compressão)
let zstd = zstd_compress(&data, 3)?;

// Delta (séries temporais)
let timestamps = Int64Array::from(vec![1000, 1001, 1002]);
let delta = delta_encode(×tamps)?;

Referência da API

Core Types

Tipo Descrição Métodos Principais
Schema Define estrutura de dados new(), fields(), field()
Field Campo individual new(), name(), data_type()
RecordBatch Coleção de arrays try_new(), num_rows(), columns()

Operações de Computação

Aritméticos

  • add(a, b) - Adição
  • sub(a, b) - Subtração
  • mul(a, b) - Multiplicação
  • div(a, b) - Divisão

Agregações

  • sum(array) - Soma
  • mean(array) - Média
  • min(array) - Mínimo
  • max(array) - Máximo

Filtros

  • filter(array, mask)
  • take(array, indices)
  • slice(array, offset, len)

Joins

  • inner_join(left, right)
  • left_join(left, right)
  • outer_join(left, right)

Performance

Benchmarks Detalhados (1M elementos)

Operação Avx-Arrow Taxa Otimização
add_i32 1.2 ms 833k ops/ms SIMD AVX2
multiply_f64 1.5 ms 666k ops/ms SIMD AVX2
filter 0.8 ms 1.25M ops/ms Bitmap SIMD
sort 12.5 ms 80k ops/ms Radix + SIMD

Compressão (100MB dados)

Algoritmo Tempo Taxa Ratio
LZ4 45 ms 2.2 GB/s 2.5x
Zstd (level 3) 180 ms 555 MB/s 4.2x
Delta 12 ms 8.3 GB/s 8.0x
Dictionary 25 ms 4.0 GB/s 10.0x

Casos de Uso com Animações

📊 Analytics em Tempo Real

Processe milhões de registros por segundo com agregações, joins e window functions.

let grouped = group_by(&data, &["sensor_id"])?;
let avg = aggregate(&grouped, "temp", AggregateFunc::Mean)?;

📈 Time Series

Análise de séries temporais com compressão Delta otimizada.

let ma_7d = rolling_mean(&prices, 7)?;
let cumulative = cumsum(&prices)?;

🤖 Machine Learning

Features e tensors para pipelines de ML.

let features = TensorArray::from_shape_vec(
    vec![10000, 128], data
)?;

Licença

⚖️ Propriedade Exclusiva

Este software é propriedade exclusiva de Nícolas Ávila. Todos os direitos reservados.

Para licenciamento comercial, entre em contato:

  • 📧 nicolas@avila.inc
  • 🌐 https://avila.inc
Ver Licença Completa