Struct Embedding 

pub struct Embedding {
    pub data: Vec<f32>,
    pub dim: usize,
    /* private fields */
}

A dense vector embedding

Fields

data: Vec<f32>

The vector data

dim: usize

Dimensionality

Implementations

impl Embedding

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

Create a new embedding from a vector

pub fn zeros(dim: usize) -> Self

Create a zero embedding of given dimension

pub fn random(dim: usize) -> Self

Create a random embedding (for testing)

pub fn norm(&mut self) -> f32

Get the L2 norm of the embedding

pub fn normalize(&mut self)

Normalize the embedding to unit length

pub fn normalized(&self) -> Self

Get a normalized copy

pub fn dot(&self, other: &Embedding) -> f32

Dot product with another embedding

pub fn add(&self, other: &Embedding) -> Self

Add another embedding (element-wise)

pub fn scale(&self, s: f32) -> Self

Scale by a scalar

impl Embedding

pub fn to_amplitude_encoding(&self) -> Self

Convert to amplitude encoding (normalize to unit vector for quantum state) This prepares the embedding for use as quantum state amplitudes

pub fn from_complex_amplitudes(amplitudes: &[Complex64]) -> Self

Create embedding from quantum state amplitudes (complex → real) Takes the real parts of complex amplitudes

pub fn from_probabilities(probs: &[f64]) -> Self

Create embedding from quantum state probability distribution Each element is sqrt(probability) to preserve amplitude structure

pub fn fidelity(&self, other: &Embedding) -> f32

Compute quantum fidelity with another embedding Treats both as normalized quantum state amplitudes Returns |⟨ψ|φ⟩|² ∈ [0, 1]

pub fn trace_distance(&self, other: &Embedding) -> f32

Compute trace distance (quantum distinguishability) Returns value in [0, 1], where 0 = identical, 1 = orthogonal

pub fn quantize_binary(&self) -> Self

Quantize embedding to binary (for Hamming distance)

pub fn product_quantize(&self, num_subvectors: usize) -> Vec<Vec<f32>>

Product quantization: split into subvectors Returns (num_subvectors, subvector_dim, subvector_data)

Trait Implementations

impl Clone for Embedding

fn clone(&self) -> Embedding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Embedding

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Embedding

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&[f32]> for Embedding

fn from(data: &[f32]) -> Self

Converts to this type from the input type.

impl From<Vec<f32>> for Embedding

fn from(data: Vec<f32>) -> Self

Converts to this type from the input type.

impl Serialize for Embedding

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

where __S: Serializer,

Serialize this value into the given Serde serializer.