terminals-core 0.1.0

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
use terminals_core::primitives::vector;

fn bench_cosine_similarity(c: &mut Criterion) {
    let mut group = c.benchmark_group("cosine_similarity");
    for size in [64, 384, 1024] {
        let a: Vec<f32> = (0..size).map(|i| (i as f32).sin()).collect();
        let b: Vec<f32> = (0..size).map(|i| (i as f32).cos()).collect();
        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |bench, _| {
            bench.iter(|| vector::cosine_similarity(black_box(&a), black_box(&b)));
        });
    }
    group.finish();
}

fn bench_normalize(c: &mut Criterion) {
    let mut group = c.benchmark_group("normalize");
    for size in [64, 384, 1024] {
        let template: Vec<f32> = (0..size).map(|i| (i as f32).sin()).collect();
        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |bench, _| {
            let mut v = template.clone();
            bench.iter(|| {
                v.copy_from_slice(&template);
                vector::normalize(black_box(&mut v));
            });
        });
    }
    group.finish();
}

fn bench_euclidean_distance(c: &mut Criterion) {
    let mut group = c.benchmark_group("euclidean_distance");
    for size in [64, 384, 1024] {
        let a: Vec<f32> = (0..size).map(|i| (i as f32).sin()).collect();
        let b: Vec<f32> = (0..size).map(|i| (i as f32).cos()).collect();
        group.bench_with_input(BenchmarkId::from_parameter(size), &size, |bench, _| {
            bench.iter(|| vector::euclidean_distance(black_box(&a), black_box(&b)));
        });
    }
    group.finish();
}

fn bench_top_k(c: &mut Criterion) {
    let mut group = c.benchmark_group("top_k");
    let query: Vec<f32> = (0..384).map(|i| (i as f32).sin()).collect();
    for n_candidates in [10, 100, 1000] {
        let candidates: Vec<Vec<f32>> = (0..n_candidates)
            .map(|j| (0..384).map(|i| ((i + j) as f32).cos()).collect())
            .collect();
        let refs: Vec<&[f32]> = candidates.iter().map(|v| v.as_slice()).collect();
        group.bench_with_input(
            BenchmarkId::from_parameter(n_candidates),
            &n_candidates,
            |bench, _| {
                bench.iter(|| vector::top_k(black_box(&query), black_box(&refs), 5));
            },
        );
    }
    group.finish();
}

criterion_group!(
    benches,
    bench_cosine_similarity,
    bench_normalize,
    bench_euclidean_distance,
    bench_top_k,
);
criterion_main!(benches);