Struct Vector 

pub struct Vector {
    pub dimensions: usize,
    pub precision: VectorPrecision,
    pub values: VectorData,
    pub metadata: Option<HashMap<String, String>>,
}

Multi-precision vector with enhanced functionality

Fields

dimensions: usize

precision: VectorPrecision

values: VectorData

metadata: Option<HashMap<String, String>>

Implementations

impl Vector

pub fn pearson_correlation(&self, other: &Vector) -> Result<f32>

Calculate Pearson correlation coefficient

pub fn spearman_correlation(&self, other: &Vector) -> Result<f32>

Calculate Spearman rank correlation

pub fn jaccard_similarity(&self, other: &Vector) -> Result<f32>

Calculate Jaccard similarity for binary vectors

pub fn hamming_distance(&self, other: &Vector) -> Result<u32>

Calculate Hamming distance for binary vectors

pub fn jensen_shannon_divergence(&self, other: &Vector) -> Result<f32>

Calculate Jensen-Shannon divergence

pub fn kl_divergence(&self, other: &Vector) -> Result<f32>

Calculate Kullback-Leibler divergence

pub fn hellinger_distance(&self, other: &Vector) -> Result<f32>

Calculate Hellinger distance

pub fn earth_movers_distance(&self, other: &Vector) -> Result<f32>

Calculate Earth Mover’s Distance (1D approximation)

pub fn wasserstein_distance(&self, other: &Vector) -> Result<f32>

Calculate Wasserstein distance (1-Wasserstein, same as EMD for 1D)

pub fn mahalanobis_distance( &self, other: &Vector, variance: &[f32], ) -> Result<f32>

Calculate Mahalanobis distance (simplified version without covariance matrix) This version assumes diagonal covariance (independent dimensions)

impl Vector

pub fn new(values: Vec<f32>) -> Self

Create a new F32 vector from values

pub fn with_precision(values: VectorData) -> Self

Create a new vector with specific precision

pub fn with_metadata( values: Vec<f32>, metadata: HashMap<String, String>, ) -> Self

Create a new vector with metadata

pub fn f64(values: Vec<f64>) -> Self

Create F64 vector

pub fn f16(values: Vec<u16>) -> Self

Create F16 vector (using u16 representation)

pub fn i8(values: Vec<i8>) -> Self

Create I8 quantized vector

pub fn binary(values: Vec<u8>) -> Self

Create binary vector

pub fn as_f32(&self) -> Vec<f32>

Get vector values as f32 (converting if necessary)

pub fn quantize_to_i8(values: &[f32]) -> Vec<i8>

Quantize f32 vector to i8

pub fn to_binary(values: &[f32], threshold: f32) -> Vec<u8>

Convert to binary representation using threshold

pub fn cosine_similarity(&self, other: &Vector) -> Result<f32>

Calculate cosine similarity with another vector

pub fn euclidean_distance(&self, other: &Vector) -> Result<f32>

Calculate Euclidean distance to another vector

pub fn manhattan_distance(&self, other: &Vector) -> Result<f32>

Calculate Manhattan distance (L1 norm) to another vector

pub fn minkowski_distance(&self, other: &Vector, p: f32) -> Result<f32>

Calculate Minkowski distance (general Lp norm) to another vector

pub fn chebyshev_distance(&self, other: &Vector) -> Result<f32>

Calculate Chebyshev distance (L∞ norm) to another vector

pub fn magnitude(&self) -> f32

Get vector magnitude (L2 norm)

pub fn normalize(&mut self)

Normalize vector to unit length

pub fn normalized(&self) -> Vector

Get a normalized copy of this vector

pub fn add(&self, other: &Vector) -> Result<Vector>

Add another vector (element-wise)

pub fn subtract(&self, other: &Vector) -> Result<Vector>

Subtract another vector (element-wise)

pub fn scale(&self, scalar: f32) -> Vector

Scale vector by a scalar

pub fn len(&self) -> usize

Get the number of dimensions in the vector

pub fn is_empty(&self) -> bool

Check if vector is empty (zero dimensions)

pub fn as_slice(&self) -> Vec<f32>

Get vector as slice of f32 values

Trait Implementations

impl Clone for Vector

fn clone(&self) -> Vector

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Vector

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Vector

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Vector

fn eq(&self, other: &Vector) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Vector

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Vector