Type Definition num_dual::StaticVec

pub type StaticVec<T, const N: usize> = StaticMat<T, 1, N>;

Implementations

impl<T: One, F, const N: usize> StaticVec<DualVec<T, F, N>, 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> StaticVec<DualVec<T, F, N>, M>

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> StaticVec<Dual2Vec<T, F, N>, 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> StaticVec<HyperDualVec<T, F, M, N>, M>

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> StaticVec<HyperDualVec<T, F, M, N>, 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 N: usize> StaticVec<T, 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: Zero + Copy, const N: usize> StaticVec<T, N>

pub fn sum(&self) -> T

sum over all elements in the vector.

impl<T: Float, const N: usize> StaticVec<T, N>

pub fn norm(&self) -> T

Calculate the Euclidian norm of the vector

impl<T: Copy + Zero, const N: usize> StaticVec<T, 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>) -> T where
    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);

Trait Implementations

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

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for StaticVec<T, N>

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

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