Struct Vector 

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

Finite fixed-size vector of length D, stored inline.

Public construction rejects NaN and infinity through try_new, and the storage field is private, so a Vector value carries the invariant that every stored entry is finite. Algorithms therefore do not re-scan stored entries at every use; user-visible non-finite errors come from construction boundaries or from values computed during arithmetic, such as overflowed accumulators.

Direct field construction is intentionally unavailable to downstream callers:

use la_stack::Vector;

let _ = Vector::<2> {
    data: [1.0, f64::NAN],
};

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. Successful construction makes the returned Vector a finite-storage proof.

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 finite 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 finite 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 finite 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 Vector values are finite by construction, so this method only checks whether the accumulation overflows to NaN or infinity.

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 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. Vector values are finite by construction, so this method only checks whether the accumulation overflows to NaN or infinity.

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 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>