Struct Array 

pub struct Array<T, const N: usize> { /* private fields */ }

Fixed-size numeric vector backed by [T; N].

Unlike a heap-backed Vec, the length is part of the type, so no allocation or bounds checks are needed and the whole value can live on the stack or in a static. Works in no_std environments.

Example

use mathverse_core::arrays::Array;

let a = Array::from([1.0f64, 2.0, 3.0]);
let b = Array::ones();
let c = a + b;
assert_eq!(c, Array::from([2.0, 3.0, 4.0]));
assert!((a.dot(&b) - 6.0).abs() < 1e-12);

Implementations

impl<T: Num, const N: usize> Array<T, N>

pub const fn new(data: [T; N]) -> Self

Construct from a raw array.

pub fn from_fn<F: FnMut(usize) -> T>(f: F) -> Self

Build from a mapping function f(i).

use mathverse_core::arrays::Array;
let a = Array::from_fn(|i| i as f64 * 2.0);
assert_eq!(a, Array::from([0.0, 2.0, 4.0]));

pub fn zeros() -> Self

All elements set to T::zero().

use mathverse_core::arrays::Array;
assert_eq!(Array::<f64, 3>::zeros(), Array::from([0.0; 3]));

pub fn ones() -> Self

All elements set to T::one().

pub fn as_slice(&self) -> &[T]

The backing slice (read-only).

pub fn as_mut_slice(&mut self) -> &mut [T]

The backing mutable slice.

pub fn get(&self, i: usize) -> T

Get element i.

Panics

Panics if i >= N.

pub fn set(&mut self, i: usize, value: T)

Set element i in place.

Panics

Panics if i >= N.

pub fn try_get(&self, i: usize) -> Option<T>

Element at index i without panicking.

Returns None if i >= N.

pub fn sum(&self) -> T

Sum of all elements using Kahan-compensated summation for numerical stability with floating-point types.

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

Dot (scalar) product with another array of the same length. Uses Kahan-compensated summation for numerical stability.

use mathverse_core::arrays::Array;
let a = Array::from([1.0f64, 2.0, 3.0]);
let b = Array::from([4.0, 5.0, 6.0]);
assert!((a.dot(&b) - 32.0).abs() < 1e-12);

pub fn map<U: Num, F: FnMut(T) -> U>(&self, f: F) -> Array<U, N>

Element-wise apply of f.

pub fn zip_with<U: Num, V: Num, F: FnMut(T, U) -> V>( &self, other: &Array<U, N>, f: F, ) -> Array<V, N>

Zip with another array and combine with f.

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

Element-wise a * b.

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

where T: Div<Output = T>,

Element-wise a / b.

pub fn cumulative_sum(&self) -> Self

Cumulative sum (prefix sum).

use mathverse_core::arrays::Array;
let a = Array::from([1.0f64, 2.0, 3.0]);
assert_eq!(a.cumulative_sum(), Array::from([1.0, 3.0, 6.0]));

pub fn reversed(&self) -> Self

Reverse the elements.

pub fn all_eq(&self, other: &Self) -> bool

where T: PartialEq,

True when every element compares equal to the corresponding one in other.

impl<T: Num, const N: usize> Array<T, N>

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

Element-wise addition.

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

Element-wise subtraction.

pub fn scalar_mul(&self, s: T) -> Self

Scalar multiply: self * s.

pub fn scalar_add(&self, s: T) -> Self

Scalar addition: self + s.

pub fn scalar_div(&self, s: T) -> Self

where T: Div<Output = T>,

Divide every element by s.

impl<T: Real, const N: usize> Array<T, N>

pub fn l2_norm(&self) -> T

Euclidean (L2) norm.

use mathverse_core::arrays::Array;
let a = Array::from([3.0f64, 4.0]);
assert!((a.l2_norm() - 5.0).abs() < 1e-12);

pub fn l1_norm(&self) -> T

Manhattan (L1) norm.

pub fn max_norm(&self) -> T

Maximum (L∞ / Chebyshev) norm.

pub fn try_normalize(&self) -> Option<Self>

Normalize to unit length; returns None for a zero vector.

pub fn normalize(&self) -> Self

Normalize to unit length; a zero vector stays zero.

pub fn mean(&self) -> T

Mean of the elements.

Trait Implementations

impl<T: Num, const N: usize> Add for Array<T, N>

type Output = Array<T, N>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T, const N: usize> AsRef<[T]> for Array<T, N>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone, const N: usize> Clone for Array<T, N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy, const N: usize> Copy for Array<T, N>

impl<T: Debug, const N: usize> Debug for Array<T, N>

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

Formats the value using the given formatter.

impl<T: Num, const N: usize> Default for Array<T, N>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Num + Div<Output = T>, const N: usize> Div<T> for Array<T, N>

type Output = Array<T, N>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Num + Eq, const N: usize> Eq for Array<T, N>

impl<T, const N: usize> From<Array<T, N>> for [T; N]

fn from(arr: Array<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for Array<T, N>

fn from(data: [T; N]) -> Self

Converts to this type from the input type.

impl<T, const N: usize> Index<usize> for Array<T, N>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Num, const N: usize> Mul<T> for Array<T, N>

type Output = Array<T, N>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: PartialEq, const N: usize> PartialEq for Array<T, N>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq, const N: usize> StructuralPartialEq for Array<T, N>

impl<T: Num, const N: usize> Sub for Array<T, N>

type Output = Array<T, N>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.