Struct HashVec

pub struct HashVec<'a> { /* private fields */ }

A wrapper type for &[f32] slices that provides stable hashing and equality based on the IEEE‑754 bit patterns.

HashVec compares floats by their raw bit representation and writes each element’s to_bits() into the hasher. This ensures that 0.0 and -0.0 are distinguished, and that NaN values only compare equal if their bit patterns match.

Implements VecLike by delegating to the slice implementation, allowing distance, dot‑product, and normalization operations.

Since

Example

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use vecstasy::HashVec;
use vecstasy::VecLike;

let data: &[f32] = &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]; // len needs to be a multiple of 8
let hv = HashVec::from(data);

// Hash computation
let mut hasher = DefaultHasher::new();
hv.hash(&mut hasher);
let hash_value = hasher.finish();

// VecLike operations
let normed: Vec<f32> = hv.normalized();

Trait Implementations

impl<'a> Clone for HashVec<'a>

fn clone(&self) -> HashVec<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for HashVec<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a [f32]> for HashVec<'a>

fn from(value: &'a [f32]) -> Self

Converts to this type from the input type.

impl<'a> Hash for HashVec<'a>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for HashVec<'a>

fn eq(&self, other: &Self) -> 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<'a> VecLike for HashVec<'a>

fn l2_dist_squared(&self, other: &Self) -> f32

Computes the squared L2 (Euclidean) distance between self and othr.

Operates on fixed‐size chunks; any trailing elements when the slice length is not a multiple of the chunk size will be silently ignored in release mode.

Panics

• In debug mode, if self.len() != othr.len().
• In debug mode, if the slice length is not a multiple of the internal chunk size.

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

Computes the dot product of self and othr.

Operates on fixed‐size chunks; any trailing elements when the slice length is not a multiple of the chunk size will be silently ignored in release mode.

Panics

• In debug mode, if self.len() != othr.len().
• In debug mode, if the slice length is not a multiple of the internal chunk size.

fn normalized(&self) -> Self::Owned

Returns a normalized copy of the input slice.

Operates on fixed‐size chunks; any trailing elements when the slice length is not a multiple of the chunk size will be silently ignored in release mode.

If the input norm is zero, returns a zero vector of the same length.

Panics

• In debug mode, if the slice length is not a multiple of the internal chunk size.

type Owned = Vec<f32>

The owned vector type returned by normalized.

impl<'a> Eq for HashVec<'a>