Struct VectorOps 

pub struct VectorOps;

Vector operations

Implementations

impl VectorOps

pub fn add(a: &[f32], b: &[f32]) -> Result<Vec<f32>>

Add two vectors element-wise

pub fn subtract(a: &[f32], b: &[f32]) -> Result<Vec<f32>>

Subtract two vectors element-wise

pub fn scale(v: &[f32], scalar: f32) -> Vec<f32>

Multiply vector by scalar

pub fn centroid(vectors: &[Vec<f32>]) -> Result<Vec<f32>>

Calculate mean/centroid of multiple vectors

pub fn normalize(v: &[f32]) -> Vec<f32>

Normalize vector to unit length (L2 norm = 1)

pub fn norm(v: &[f32]) -> f32

L2 norm (Euclidean length)

pub fn dot(a: &[f32], b: &[f32]) -> Result<f32>

Dot product

pub fn sparse_dot( a_indices: &[usize], a_values: &[f32], b_indices: &[usize], b_values: &[f32], ) -> f32

Sparse dot product

Computes dot product between two sparse vectors represented as (indices, values). Much more efficient than materializing to dense when vectors are sparse.

Arguments

• a_indices - Indices of non-zero elements in vector a
• a_values - Values at those indices in vector a
• b_indices - Indices of non-zero elements in vector b
• b_values - Values at those indices in vector b

Returns

Dot product of the two sparse vectors

Performance

O(n + m) where n and m are the number of non-zero elements. For vectors with k non-zero elements in d dimensions: O(k) vs O(d) for dense.

Example

use vecstore::vectors::VectorOps;

// Sparse vectors in 1000-dimensional space
// a has non-zero values at indices [5, 100, 500]
// b has non-zero values at indices [5, 200, 500]
let a_indices = vec![5, 100, 500];
let a_values = vec![1.0, 2.0, 3.0];
let b_indices = vec![5, 200, 500];
let b_values = vec![1.5, 2.5, 1.0];

let dot = VectorOps::sparse_dot(&a_indices, &a_values, &b_indices, &b_values);
// Result: 1.0*1.5 + 3.0*1.0 = 4.5 (indices 5 and 500 match)
assert_eq!(dot, 4.5);

pub fn sparse_norm(values: &[f32]) -> f32

Sparse vector L2 norm (Euclidean length)

Example

use vecstore::vectors::VectorOps;

let indices = vec![0, 5, 10];
let values = vec![3.0, 4.0, 0.0]; // [3, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, ...]

let norm = VectorOps::sparse_norm(&values);
assert_eq!(norm, 5.0); // sqrt(3^2 + 4^2) = 5

pub fn sparse_cosine( a_indices: &[usize], a_values: &[f32], b_indices: &[usize], b_values: &[f32], ) -> f32

Cosine similarity for sparse vectors

Arguments

• a_indices, a_values - First sparse vector
• b_indices, b_values - Second sparse vector

Returns

Cosine similarity in [-1, 1] range. Returns 0.0 if either vector has zero norm.

Example

use vecstore::vectors::VectorOps;

let a_indices = vec![0, 1, 2];
let a_values = vec![1.0, 0.0, 1.0];
let b_indices = vec![0, 1];
let b_values = vec![1.0, 0.0];

let sim = VectorOps::sparse_cosine(&a_indices, &a_values, &b_indices, &b_values);
// Should be close to 1.0 / sqrt(2) ≈ 0.707
assert!((sim - 0.707).abs() < 0.01);