Struct Vector

pub struct Vector<T, const N: usize> {
    pub store: [T; N],
}

Represents a vector of N elements of type T.

Examples

use mini_matrix::Vector;

let v = Vector::from([1, 2, 3]);
assert_eq!(v[0], 1);
assert_eq!(v[1], 2);
assert_eq!(v[2], 3);

Fields

store: [T; N]

Implementations

impl<T, const N: usize> Vector<T, N>

where T: Copy + Default,

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

Creates a new Vector from an array of elements.

Examples

use mini_matrix::Vector;

let v = Vector::from([1, 2, 3]);

pub const fn size(&self) -> usize

Returns the number of elements in the Vector.

Examples

use mini_matrix::Vector;

let v: Vector<i32, 3> = Vector::from([1, 2, 3]);
assert_eq!(v.size(), 3);

pub fn zero() -> Self

Creates a new Vector with all elements set to the default value of type T.

Examples

use mini_matrix::Vector;

let v: Vector<i32, 3> = Vector::zero();
assert_eq!(v[0], 0);
assert_eq!(v[1], 0);
assert_eq!(v[2], 0);

impl<T, const N: usize> Vector<T, N>

where T: Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Copy + Clone + Default,

pub fn add(&mut self, rhs: &Self)

Adds another vector to this vector in-place.

Examples

use mini_matrix::Vector;

let mut v1 = Vector::from([1, 2, 3]);
let v2 = Vector::from([4, 5, 6]);
v1.add(&v2);
assert_eq!(v1[0], 5);
assert_eq!(v1[1], 7);
assert_eq!(v1[2], 9);

pub fn sub(&mut self, rhs: &Self)

Subtracts another vector from this vector in-place.

Examples

use mini_matrix::Vector;

let mut v1 = Vector::from([4, 5, 6]);
let v2 = Vector::from([1, 2, 3]);
v1.sub(&v2);
assert_eq!(v1[0], 3);
assert_eq!(v1[1], 3);
assert_eq!(v1[2], 3);

pub fn scl(&mut self, scalar: T)

Multiplies this vector by a scalar value in-place.

Examples

use mini_matrix::Vector;

let mut v = Vector::from([1, 2, 3]);
v.scl(2);
assert_eq!(v[0], 2);
assert_eq!(v[1], 4);
assert_eq!(v[2], 6);

impl<T, const N: usize> Vector<T, N>

where T: Num + Sum + Copy + Clone,

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

Computes the dot product of two vectors.

The dot product is the sum of the products of corresponding elements.

Examples

use mini_matrix::Vector;

let v1 = Vector::from([1, 2, 3]);
let v2 = Vector::from([4, 5, 6]);
assert_eq!(v1.dot(&v2), 32); // 1*4 + 2*5 + 3*6 = 32

impl<T, const N: usize> Vector<T, N>

where T: Float + Sum<T>,

pub fn norm_1(&self) -> T

Calculates the L1 norm (Manhattan norm) of the vector.

The L1 norm is the sum of the absolute values of the vector’s components.

Returns

The L1 norm as a value of type T.

Examples

use mini_matrix::Vector;
let v = Vector::from([1.0, -2.0, 3.0]);
assert_eq!(v.norm_1(), 6.0);

pub fn norm(&self) -> T

Calculates the L2 norm (Euclidean norm) of the vector.

The L2 norm is the square root of the sum of the squared components.

Returns

The L2 norm as a value of type T.

Examples

use mini_matrix::Vector;
let v = Vector::from([1.0, -2.0, 3.0]);
assert_eq!(v.norm(), [1.0 + 4.0 + 9.0].iter().sum::<f32>().sqrt());

pub fn norm_inf(&self) -> T

Calculates the L-infinity norm (maximum norm) of the vector.

The L-infinity norm is the maximum of the absolute values of the vector’s components.

Returns

The L-infinity norm as a value of type T.

Examples

use mini_matrix::Vector;
let v = Vector::from([1.0, -2.0, 3.0]);
assert_eq!(v.norm_inf(), 3.0);

Methods from Deref<Target = [T; N]>

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

Returns a slice containing the entire array. Equivalent to &s[..].

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

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

pub fn each_ref(&self) -> [&T; N]

Borrows each element and returns an array of references with the same size as self.

Example

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

pub fn each_mut(&mut self) -> [&mut T; N]

Borrows each element mutably and returns an array of mutable references with the same size as self.

Example

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

Trait Implementations

impl<T, const N: usize> Add for Vector<T, N>

where T: Add<Output = T> + Default + Clone + Copy,

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

Adds two vectors element-wise.

Examples

use mini_matrix::Vector;

let v1 = Vector::from([1, 2, 3]);
let v2 = Vector::from([4, 5, 6]);
let v3 = v1 + v2;
assert_eq!(v3, Vector::from([5, 7, 9]));

type Output = Vector<T, N>

The resulting type after applying the + operator.

impl<T, const N: usize> AddAssign for Vector<T, N>

where T: Num + Default + Clone + Copy,

fn add_assign(&mut self, rhs: Self)

Adds another vector to this vector in-place.

Examples

use mini_matrix::Vector;

let mut v1 = Vector::from([1, 2, 3]);
let v2 = Vector::from([4, 5, 6]);
v1 += v2;
assert_eq!(v1, Vector::from([5, 7, 9]));

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

fn clone(&self) -> Vector<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T, const N: usize> Deref for Vector<T, N>

type Target = [T; N]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const N: usize> DerefMut for Vector<T, N>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, const N: usize> Display for Vector<T, N>

where T: Display,

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

Formats the vector for display.

Examples

use mini_matrix::Vector;

let v = Vector::from([1.0, 2.5, 3.7]);
println!("{}", v); // Outputs: //-> [1.0, 2.5, 3.7]

impl<T, const N: usize> Index<usize> for Vector<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, const N: usize> IndexMut<usize> for Vector<T, N>

fn index_mut(&mut self, index: usize) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T, const N: usize> Mul<T> for Vector<T, N>

where T: Mul + Num + Copy,

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

Multiplies a vector by a scalar.

Examples

use mini_matrix::Vector;

let v1 = Vector::from([1.0, 2.0, 3.0]);
let v2 = v1 * 2.0;
assert_eq!(v2, Vector::from([2.0, 4.0, 6.0]));

type Output = Vector<T, N>

The resulting type after applying the * operator.

impl<T, const M: usize, const N: usize> Mul<Vector<T, N>> for Matrix<T, M, N>

where T: MulAssign + AddAssign + Copy + Num + Default,

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

Multiplies a matrix by a vector.

Examples

use mini_matrix::{Matrix, Vector};

let a = Matrix::<i32, 2, 2>::from([[1, 2], [3, 4]]);
let v = Vector::<i32, 2>::from([5, 6]);
let result = a * v;
assert_eq!(result.store, [17, 39]);

type Output = Vector<T, M>

The resulting type after applying the * operator.

impl<T, const N: usize> Mul for Vector<T, N>

where T: Mul + Num + Sum + Copy,

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

Computes the dot product of two vectors.

This is an alternative way to compute the dot product using the * operator.

Examples

use mini_matrix::Vector;

let v1 = Vector::from([1, 2, 3]);
let v2 = Vector::from([4, 5, 6]);
assert_eq!(v1 * v2, 32); // 1*4 + 2*5 + 3*6 = 32

type Output = T

The resulting type after applying the * operator.

impl<T, const N: usize> Neg for Vector<T, N>

where T: Num + Copy + Signed,

fn neg(self) -> Self::Output

Negates a vector, inverting the sign of all its elements.

Examples

use mini_matrix::Vector;

let v1 = Vector::from([1, -2, 3]);
let v2 = -v1;
assert_eq!(v2, Vector::from([-1, 2, -3]));

type Output = Vector<T, N>

The resulting type after applying the - operator.

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

where T: PartialEq,

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<T, const N: usize> Sub for Vector<T, N>

where T: Sub<Output = T> + Default + Clone + Copy,

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

Subtracts one vector from another element-wise.

Examples

use mini_matrix::Vector;

let v1 = Vector::from([4, 5, 6]);
let v2 = Vector::from([1, 2, 3]);
let v3 = v1 - v2;
assert_eq!(v3, Vector::from([3, 3, 3]));

type Output = Vector<T, N>

The resulting type after applying the - operator.

impl<T, const N: usize> SubAssign for Vector<T, N>

where T: Num + Default + Clone + Copy,

fn sub_assign(&mut self, rhs: Self)

Subtracts another vector from this vector in-place.

Examples

use mini_matrix::Vector;

let mut v1 = Vector::from([4, 5, 6]);
let v2 = Vector::from([1, 2, 3]);
v1 -= v2;
assert_eq!(v1, Vector::from([3, 3, 3]));

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

impl<T, const N: usize> Eq for Vector<T, N>

where T: Eq,