Struct VectorRow

pub struct VectorRow<T, const S: usize>
where
    T: Copy,
{ /* private fields */ }

A static row vector type

Size must be known at compile time but operations are checked for size compatibility at compile time too

S: The length of the vector

Implementations

impl<T, const S: usize> VectorRow<T, S>

where T: Copy,

pub fn new(values: [T; S]) -> Self

Initializes a new row vector with the given values

Examples

let x = static_linear_algebra::VectorRow::new([0, 1, 2]);
 
assert_eq!(&[0, 1, 2], x.get_values());

pub fn from_value(value: T) -> Self

Initializes a new row vector filled with a single value

Examples

let x = static_linear_algebra::VectorRow::<f32, 2>::from_value(1.);
 
assert_eq!(&[1., 1.], x.get_values());

pub fn get_values(&self) -> &[T; S]

Retrieves a reference to the data of the row vector

Examples

let x = static_linear_algebra::VectorRow::new([0, 1]);
let data = x.get_values();
 
assert_eq!(&[0, 1], data);

pub fn get_values_mut(&mut self) -> &mut [T; S]

Retrieves a mutable reference to the data of the row vector

Examples

let mut x = static_linear_algebra::VectorRow::new([0, 1]);
let data = x.get_values_mut();
data[0] = 5;
 
assert_eq!(&[5, 1], x.get_values());

pub fn transpose(&self) -> VectorColumn<T, S>

Transposes the row vector into a column vector

Examples

let x = static_linear_algebra::VectorRow::new([0, 1, 2]);
let y = x.transpose();
 
assert_eq!(&[0, 1, 2], y.get_values());

impl<T, const S: usize> VectorRow<Complex<T>, S>

where T: Copy + Num + Neg<Output = T>,

pub fn hermitian_conjugate(&self) -> VectorColumn<Complex<T>, S>

Takes the hermitian conjugate of the row vector (transpose the vector and complex conjugate each element (change the sign of the imaginary part))

Examples

use num::Complex;
 
let x = static_linear_algebra::VectorRow::new([Complex::new(1, 0), Complex::new(0, 2)]);
let y = x.hermitian_conjugate();
 
assert_eq!(&[Complex::new(1, 0), Complex::new(0, -2)], y.get_values())

Trait Implementations

impl<TL, TR, TO, const S: usize> Add<VectorRow<TR, S>> for VectorRow<TL, S>

where TL: Copy + Add<TR, Output = TO>, TR: Copy, TO: Copy,

fn add(self, rhs: VectorRow<TR, S>) -> Self::Output

Normal elementwise addition of two row vectors

Examples

let x = static_linear_algebra::VectorRow::new([0, 1]);
let y = static_linear_algebra::VectorRow::new([0, 10]);
 
let z = x + y;
 
assert_eq!(&[0, 11], z.get_values());

type Output = VectorRow<TO, S>

The resulting type after applying the + operator.

impl<T, const S: usize> AddAssign for VectorRow<T, S>

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

fn add_assign(&mut self, rhs: VectorRow<T, S>)

Normal elementwise addition of two row vectors

Examples

let mut x = static_linear_algebra::VectorRow::new([0, 1]);
let y = static_linear_algebra::VectorRow::new([0, 10]);
 
x += y;
 
assert_eq!(&[0, 11], x.get_values());

impl<T, const S: usize> Clone for VectorRow<T, S>

where T: Copy + Clone,

fn clone(&self) -> VectorRow<T, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const S: usize> Debug for VectorRow<T, S>

where T: Copy + Debug,

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

Formats the value using the given formatter.

impl<T, const S: usize> Index<usize> for VectorRow<T, S>

where T: Copy,

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const S: usize> IndexMut<usize> for VectorRow<T, S>

where T: Copy,

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

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

impl<TL, TR, TO, const R: usize, const C: usize> Mul<Matrix<TR, R, C>> for VectorRow<TL, R>

where TL: Copy + Mul<TR, Output = TO>, TR: Copy, TO: Copy + Sum,

fn mul(self, rhs: Matrix<TR, R, C>) -> Self::Output

Multiplication between a row vector and a matrix

Examples

let x = static_linear_algebra::VectorRow::new([0, 1]);
let y = static_linear_algebra::Matrix::new([[0, 10, 20], [30, 40, 50]]);
 
let z = x * y;
 
assert_eq!(&[30, 40, 50], z.get_values());

type Output = VectorRow<TO, C>

The resulting type after applying the * operator.

impl<TL, TR, TO, const S: usize> Mul<TR> for VectorRow<TL, S>

where TL: Copy + Mul<TR, Output = TO>, TR: Copy + Num, TO: Copy,

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

Scalar multiplication from the right, this is preferable from lhs scalar multiplication

Examples

let x = static_linear_algebra::VectorRow::new([0, 1]);
let y = 10;
 
let z = x * y;
 
assert_eq!(&[0, 10], z.get_values());

type Output = VectorRow<TO, S>

The resulting type after applying the * operator.

impl<TL, TR, TO, const S: usize> Mul<VectorColumn<TR, S>> for VectorRow<TL, S>

where TL: Copy + Mul<TR, Output = TO>, TR: Copy, TO: Copy + Sum,

fn mul(self, rhs: VectorColumn<TR, S>) -> Self::Output

Inner product between a row vector and a column vector

Examples

let x = static_linear_algebra::VectorRow::new([0, 1]);
let y = static_linear_algebra::VectorColumn::new([10, 20]);
 
let z = x * y;
 
assert_eq!(20, z);

type Output = TO

The resulting type after applying the * operator.

impl<TL, TR, TO, const R: usize, const C: usize> Mul<VectorRow<TR, C>> for VectorColumn<TL, R>

where TL: Copy + Mul<TR, Output = TO>, TR: Copy, TO: Copy + Sum,

fn mul(self, rhs: VectorRow<TR, C>) -> Self::Output

Outer product between a column vector and a row vector

Examples

let x = static_linear_algebra::VectorColumn::new([0, 1]);
let y = static_linear_algebra::VectorRow::new([10, 20]);
 
let z = x * y;
 
assert_eq!(&[[0, 0], [10, 20]], z.get_values());

type Output = Matrix<TO, R, C>

The resulting type after applying the * operator.

impl<TL, TR, TO, const S: usize> Mul<VectorRow<TR, S>> for VectorRow<TL, S>

where TL: Copy + Mul<TR, Output = TO>, TR: Copy, TO: Copy + Sum,

fn mul(self, rhs: VectorRow<TR, S>) -> Self::Output

Inner product (dot product) between two row vectors

Examples

let x = static_linear_algebra::VectorRow::new([0, 1]);
let y = static_linear_algebra::VectorRow::new([0, 10]);
 
let z = x * y;
 
assert_eq!(10, z);

type Output = TO

The resulting type after applying the * operator.

impl<T, const S: usize> MulAssign<T> for VectorRow<T, S>

where T: Copy + Mul<T, Output = T> + Num,

fn mul_assign(&mut self, rhs: T)

Scalar multiplication from the right, this is preferable from lhs scalar multiplication

Examples

let mut x = static_linear_algebra::VectorRow::new([0, 1]);
let y = 10;
 
x *= y;
 
assert_eq!(&[0, 10], x.get_values());

impl<T, const S: usize> PartialEq for VectorRow<T, S>

where T: Copy + PartialEq,

fn eq(&self, other: &VectorRow<T, S>) -> 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<TL, TR, TO, const S: usize> Sub<VectorRow<TR, S>> for VectorRow<TL, S>

where TL: Copy + Sub<TR, Output = TO>, TR: Copy, TO: Copy,

fn sub(self, rhs: VectorRow<TR, S>) -> Self::Output

Normal elementwise subtraction of two row vectors

Examples

let x = static_linear_algebra::VectorRow::new([0, 1]);
let y = static_linear_algebra::VectorRow::new([0, 10]);
 
let z = x - y;
 
assert_eq!(&[0, -9], z.get_values());

type Output = VectorRow<TO, S>

The resulting type after applying the - operator.

impl<T, const S: usize> SubAssign for VectorRow<T, S>

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

fn sub_assign(&mut self, rhs: VectorRow<T, S>)

Normal elementwise subtraction of two row vectors

Examples

let mut x = static_linear_algebra::VectorRow::new([0, 1]);
let y = static_linear_algebra::VectorRow::new([0, 10]);
 
x -= y;
 
assert_eq!(&[0, -9], x.get_values());

impl<'a, T, const S: usize> Sum<&'a VectorRow<T, S>> for VectorRow<T, S>

where T: Copy + Zero + Add<T, Output = T> + PartialEq,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, const S: usize> Sum for VectorRow<T, S>

where T: Copy + Zero + Add<T, Output = T> + PartialEq,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, const S: usize> Zero for VectorRow<T, S>

where T: Copy + Zero + PartialEq,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T, const S: usize> Copy for VectorRow<T, S>

where T: Copy + Copy,

impl<T, const S: usize> StructuralPartialEq for VectorRow<T, S>

where T: Copy,