Struct num_dual::StaticMat

pub struct StaticMat<T, const M: usize, const N: usize>(_);

A statically allocated MxN matrix. The struct is used in the vector (hyper) dual numbers and provides utilities for the calculation of Jacobians.

Implementations

impl<T: One, F, const N: usize> StaticMat<T, 1, N>

pub fn derive(self) -> Self

Derive a vector of dual numbers.

let v = StaticVec::new_vec([4.0, 3.0]).map(DualVec64::<2>::from_re).derive();
let n = (v[0].powi(2) + v[1].powi(2)).sqrt();
assert_eq!(n.re, 5.0);
assert_relative_eq!(n.eps[0], 0.8);
assert_relative_eq!(n.eps[1], 0.6);

impl<T: One + Zero + Copy + AddAssign, F, const M: usize, const N: usize> StaticMat<T, 1, N>

pub fn jacobian(&self) -> StaticMat<T, M, N>

Extract the Jacobian from a vector of Dual numbers.

let xy = StaticVec::new_vec([5.0, 3.0]).map(DualVec64::<2>::from).derive();
let j = StaticVec::new_vec([xy[0] * xy[1].powi(3), xy[0].powi(2) * xy[1]]).jacobian();
assert_eq!(j[(0,0)], 27.0);     // y³
assert_eq!(j[(0,1)], 135.0);    // 3xy²
assert_eq!(j[(1,0)], 30.0);     // 2xy
assert_eq!(j[(1,1)], 25.0);     // x²

impl<T: One, F, const N: usize> StaticMat<T, 1, N>

pub fn derive(self) -> Self

Derive a vector of second order dual numbers.

let v = StaticVec::new_vec([4.0, 3.0]).map(Dual2Vec64::<2>::from_re).derive();
let n = (v[0].powi(2) + v[1].powi(2)).sqrt();
assert_eq!(n.re, 5.0);
assert_relative_eq!(n.v1[0], 0.8);
assert_relative_eq!(n.v1[1], 0.6);
assert_relative_eq!(n.v2[(0,0)], 0.072);
assert_relative_eq!(n.v2[(0,1)], -0.096);
assert_relative_eq!(n.v2[(1,0)], -0.096);
assert_relative_eq!(n.v2[(1,1)], 0.128);

impl<T: One, F, const M: usize, const N: usize> StaticMat<T, 1, N>

pub fn derive1(self) -> Self

Derive a vector of hyper dual numbers w.r.t. to the first set of variables.

impl<T: One, F, const M: usize, const N: usize> StaticMat<T, 1, N>

pub fn derive2(self) -> Self

Derive a vector of hyper dual numbers w.r.t. to the second set of variables.

let x = HyperDualVec64::<1, 2>::from_re(2.0).derive1();
let v = StaticVec::new_vec([2.0, 3.0]).map(HyperDualVec64::<1, 2>::from_re).derive2();
let n = (x.powi(2)*v[0].powi(2) + v[1].powi(2)).sqrt();
assert_eq!(n.re, 5.0);
assert_relative_eq!(n.eps1[0], 1.6);
assert_relative_eq!(n.eps2[0], 1.6);
assert_relative_eq!(n.eps2[1], 0.6);
assert_relative_eq!(n.eps1eps2[(0,0)], 1.088);
assert_relative_eq!(n.eps1eps2[(0,1)], -0.192);

impl<T, const M: usize, const N: usize> StaticMat<T, M, N>

pub fn new(mat: [[T; N]; M]) -> Self

Create a new StaticMat from an array of arrays.

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

Return a reference to the raw data in the StaticMat.

impl<T, const N: usize> StaticMat<T, 1, N>

pub fn new_vec(vec: [T; N]) -> Self

Create a new StaticVec from an array.

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

Return a reference to the raw data in the StaticVec.

impl<T: Copy + Zero + One + AddAssign, const N: usize> StaticMat<T, N, N>

pub fn eye() -> Self

Create a NxN unity matrix.

impl<T: Zero + Copy, const N: usize> StaticMat<T, 1, N>

pub fn sum(&self) -> T

sum over all elements in the vector.

impl<T: Float, const N: usize> StaticMat<T, 1, N>

pub fn norm(&self) -> T

Calculate the Euclidian norm of the vector

impl<T: Copy, const M: usize, const N: usize> StaticMat<T, M, N>

pub fn map<B, F>(&self, f: F) -> StaticMat<B, M, N>where
    B: Copy + Zero,
    F: Fn(T) -> B,

Apply a function elementwise to all elements of the matrix and return a new matrix with the results.

pub fn map_zip<B, C, F>(
    &self,
    other: &StaticMat<B, M, N>,
    f: F
) -> StaticMat<C, M, N>where
    B: Copy,
    C: Copy + Zero,
    F: Fn(T, B) -> C,

Apply a function elementwise to all elements of the matrix and a second matrix. Return a new matrix with the results.

pub fn iter(&self) -> Flatten<Iter<'_, [T; N]>>

Iterate over all matrix elements.

pub fn matmul<B: Copy, C, const O: usize>(
    &self,
    other: &StaticMat<B, N, O>
) -> StaticMat<C, M, O>where
    C: Copy + Zero + AddAssign,
    T: Mul<B, Output = C>,

Perform a matrix-matrix multiplication.

use num_dual::StaticMat;
let a = StaticMat::new([[1, 2], [3, 4]]);
let b = StaticMat::new([[2, 1], [4, 3]]);
let x = a.matmul(&b);
assert_eq!(x[(0,0)], 10);
assert_eq!(x[(0,1)], 7);
assert_eq!(x[(1,0)], 22);
assert_eq!(x[(1,1)], 15);

pub fn transpose_matmul<B: Copy, C, const O: usize>(
    &self,
    other: &StaticMat<B, M, O>
) -> StaticMat<C, N, O>where
    C: Copy + Zero + AddAssign,
    T: Mul<B, Output = C>,

Perform a matrix-matrix multiplication in which the first matrix is transposed.

use num_dual::StaticVec;
let a = StaticVec::new_vec([1, 2]);
let b = StaticVec::new_vec([2, 1]);
let x = a.transpose_matmul(&b);
assert_eq!(x[(0,0)], 2);
assert_eq!(x[(0,1)], 1);
assert_eq!(x[(1,0)], 4);
assert_eq!(x[(1,1)], 2);

pub fn matmul_transpose<B: Copy, C, const O: usize>(
    &self,
    other: &StaticMat<B, O, N>
) -> StaticMat<C, M, O>where
    C: Copy + Zero + AddAssign,
    T: Mul<B, Output = C>,

Perform a matrix-matrix multiplication in which the second matrix is transposed.

use num_dual::{StaticMat, StaticVec};
let a = StaticMat::new([[1, 2], [3, 4]]);
let b = StaticVec::new_vec([2, 1]);
let x = a.matmul_transpose(&b);
assert_eq!(x[(0, 0)], 4);
assert_eq!(x[(1, 0)], 10);

pub fn t(&self) -> StaticMat<T, N, M>where
    T: Zero,

Transpose the matrix.

impl<T: Copy + Zero, const N: usize> StaticMat<T, 1, N>

pub fn first<const M: usize>(&self) -> StaticVec<T, M>

Return a new vector containing the first M elements of self.

pub fn last<const M: usize>(&self) -> StaticVec<T, M>

Return a new vector containing the last M elements of self.

pub fn dot(&self, other: &StaticVec<T, N>) -> Twhere
    T: Mul<Output = T> + AddAssign,

Calculate the dot product of two vectors.

use num_dual::StaticVec;
let a = StaticVec::new_vec([1, 2, 3, 4]);
let b = StaticVec::new_vec([2, 1, 4, 3]);
assert_eq!(a.dot(&b), 28);

impl<T, const M: usize, const N: usize> StaticMat<T, M, N>

pub fn scale<F: Copy>(&mut self, f: F)where
    T: MulAssign<F>,

multiply each matrix element with f in place.

Trait Implementations

impl<T: Copy + AddAssign, const M: usize, const N: usize> Add<StaticMat<T, M, N>> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Copy + AddAssign, const M: usize, const N: usize> Add<T> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the + operator.

fn add(self, other: T) -> Self

Performs the + operation.

impl<T: Copy + AddAssign, const M: usize, const N: usize> AddAssign<StaticMat<T, M, N>> for StaticMat<T, M, N>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: Copy + AddAssign, const M: usize, const N: usize> AddAssign<T> for StaticMat<T, M, N>

fn add_assign(&mut self, other: T)

Performs the += operation.

impl<T: Clone, const M: usize, const N: usize> Clone for StaticMat<T, M, N>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const M: usize, const N: usize> Debug for StaticMat<T, M, N>

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

Formats the value using the given formatter.

impl<T: Display, const M: usize, const N: usize> Display for StaticMat<T, M, N>

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

Formats the value using the given formatter.

impl<T: Copy + DivAssign, const M: usize, const N: usize> Div<StaticMat<T, M, N>> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self

Performs the / operation.

impl<T: Copy + DivAssign, const M: usize, const N: usize> Div<T> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the / operator.

fn div(self, other: T) -> Self

Performs the / operation.

impl<T: Copy + DivAssign, const M: usize, const N: usize> DivAssign<StaticMat<T, M, N>> for StaticMat<T, M, N>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T: Copy + DivAssign, const M: usize, const N: usize> DivAssign<T> for StaticMat<T, M, N>

fn div_assign(&mut self, other: T)

Performs the /= operation.

impl<T, const M: usize, const N: usize> Index<(usize, usize)> for StaticMat<T, M, N>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const M: usize, const N: usize> IndexMut<(usize, usize)> for StaticMat<T, M, N>

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

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

impl<T: Copy + MulAssign, const M: usize, const N: usize> Mul<StaticMat<T, M, N>> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<T: Copy + MulAssign, const M: usize, const N: usize> Mul<T> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the * operator.

fn mul(self, other: T) -> Self

Performs the * operation.

impl<T: Copy + MulAssign, const M: usize, const N: usize> MulAssign<StaticMat<T, M, N>> for StaticMat<T, M, N>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T: Copy + MulAssign, const M: usize, const N: usize> MulAssign<T> for StaticMat<T, M, N>

fn mul_assign(&mut self, other: T)

Performs the *= operation.

impl<T: Copy + Neg<Output = T>, const M: usize, const N: usize> Neg for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: Copy + One + MulAssign, const M: usize, const N: usize> One for StaticMat<T, M, N>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<T: PartialEq, const M: usize, const N: usize> PartialEq<StaticMat<T, M, N>> for StaticMat<T, M, N>

fn eq(&self, other: &StaticMat<T, M, N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Copy + RemAssign, const M: usize, const N: usize> Rem<StaticMat<T, M, N>> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self

Performs the % operation.

impl<T: Copy + RemAssign, const M: usize, const N: usize> Rem<T> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the % operator.

fn rem(self, other: T) -> Self

Performs the % operation.

impl<T: Copy + RemAssign, const M: usize, const N: usize> RemAssign<StaticMat<T, M, N>> for StaticMat<T, M, N>

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<T: Copy + RemAssign, const M: usize, const N: usize> RemAssign<T> for StaticMat<T, M, N>

fn rem_assign(&mut self, other: T)

Performs the %= operation.

impl<T: Copy + SubAssign, const M: usize, const N: usize> Sub<StaticMat<T, M, N>> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Copy + SubAssign, const M: usize, const N: usize> Sub<T> for StaticMat<T, M, N>

type Output = StaticMat<T, M, N>

The resulting type after applying the - operator.

fn sub(self, other: T) -> Self

Performs the - operation.

impl<T: Copy + SubAssign, const M: usize, const N: usize> SubAssign<StaticMat<T, M, N>> for StaticMat<T, M, N>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T: Copy + SubAssign, const M: usize, const N: usize> SubAssign<T> for StaticMat<T, M, N>

fn sub_assign(&mut self, other: T)

Performs the -= operation.

impl<T: Copy + Zero + AddAssign, const M: usize, const N: usize> Zero for StaticMat<T, M, N>

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: Copy, const M: usize, const N: usize> Copy for StaticMat<T, M, N>

impl<T: Eq, const M: usize, const N: usize> Eq for StaticMat<T, M, N>

impl<T, const M: usize, const N: usize> StructuralEq for StaticMat<T, M, N>

impl<T, const M: usize, const N: usize> StructuralPartialEq for StaticMat<T, M, N>