Struct Vector 

pub struct Vector<const D: usize> { /* private fields */ }

Fixed-size vector of length D, stored inline.

Implementations

impl<const D: usize> Vector<D>

pub const fn try_new(data: [f64; D]) -> Result<Self, LaError>

Try to create a finite vector from a backing array.

This is the public raw-storage boundary for vectors. Public compute methods parse stored entries into crate-internal proof-bearing types before arithmetic, including when crate-internal unchecked storage exists.

Examples

use la_stack::prelude::*;

let v = Vector::<3>::try_new([1.0, 2.0, 3.0])?;
assert_eq!(v.into_array(), [1.0, 2.0, 3.0]);

Errors

Returns LaError::NonFinite with the first offending entry index when data contains NaN or infinity.

pub const fn zero() -> Self

All-zeros vector.

Examples

use la_stack::prelude::*;

let z = Vector::<2>::zero();
assert_eq!(z.into_array(), [0.0, 0.0]);

pub const fn as_array(&self) -> &[f64; D]

Borrow the backing array.

Examples

use la_stack::prelude::*;

let v = Vector::<2>::try_new([1.0, -2.0])?;
assert_eq!(v.as_array(), &[1.0, -2.0]);

pub const fn into_array(self) -> [f64; D]

Consume and return the backing array.

Examples

use la_stack::prelude::*;

let v = Vector::<2>::try_new([1.0, 2.0])?;
let a = v.into_array();
assert_eq!(a, [1.0, 2.0]);

pub const fn dot(self, other: Self) -> Result<f64, LaError>

Dot product.

Terms are accumulated in f64 using f64::mul_add at each index. Intermediate rounding occurs, and this method does not provide a certified absolute rounding bound for the returned dot product. Raw storage is parsed into the crate-internal finite-vector proof before accumulation, so internally unchecked vectors are rejected before arithmetic starts.

Examples

use la_stack::prelude::*;

let a = Vector::<3>::try_new([1.0, 2.0, 3.0])?;
let b = Vector::<3>::try_new([-2.0, 0.5, 4.0])?;
assert!((a.dot(b)? - 11.0).abs() <= 1e-12);

Errors

Returns LaError::NonFinite when either input contains NaN/infinity or the accumulated dot product overflows to NaN or infinity.

pub const fn norm2_sq(self) -> Result<f64, LaError>

Squared Euclidean norm.

This is computed as dot(self, self), so norm2_sq has the same f64 mul_add accumulation behavior as dot. Intermediate rounding occurs, and this method does not provide a certified absolute rounding bound for the returned squared norm. Raw storage is parsed into the crate-internal finite-vector proof before accumulation.

Examples

use la_stack::prelude::*;

let v = Vector::<3>::try_new([1.0, 2.0, 3.0])?;
assert!((v.norm2_sq()? - 14.0).abs() <= 1e-12);

Errors

Returns LaError::NonFinite when stored entries are NaN/infinity or the accumulated norm overflows to NaN or infinity.

Trait Implementations

impl<const D: usize> Clone for Vector<D>

fn clone(&self) -> Vector<D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const D: usize> Copy for Vector<D>

impl<const D: usize> Debug for Vector<D>

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

Formats the value using the given formatter.

impl<const D: usize> Default for Vector<D>

fn default() -> Self

Returns the “default value” for a type.

impl<const D: usize> PartialEq for Vector<D>

fn eq(&self, other: &Vector<D>) -> 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<const D: usize> StructuralPartialEq for Vector<D>