Struct nalgebra::DVec3 [−] [src]

pub struct DVec3<N> {
    // some fields omitted
}

Stack-allocated, dynamically sized vector with a maximum size of 3.

Methods

`impl<N> DVec3<N>`

`fn len(&self) -> usize`

`impl<N: Zero + Copy + Clone> DVec3<N>`

`fn new_zeros(dim: usize) -> DVec3<N>`

Builds a vector filled with zeros.

Arguments

dim - The dimension of the vector.

`fn is_zero(&self) -> bool`

Tests if all components of the vector are zeroes.

`impl<N> DVec3<N>`

`fn as_slice<'a>(&'a self) -> &'a [N]`

Slices this vector.

`fn as_mut_slice<'a>(&'a mut self) -> &'a mut [N]`

Mutably slices this vector.

`impl<N: One + Zero + Copy + Clone> DVec3<N>`

`fn new_ones(dim: usize) -> DVec3<N>`

Builds a vector filled with ones.

Arguments

dim - The dimension of the vector.

`impl<N: Rand + Zero> DVec3<N>`

`fn new_random(dim: usize) -> DVec3<N>`

Builds a vector filled with random values.

`impl<N: BaseFloat + ApproxEq<N>> DVec3<N>`

`fn canonical_basis_with_dim(dim: usize) -> Vec<DVec3<N>>`

Computes the canonical basis for the given dimension. A canonical basis is a set of vectors, mutually orthogonal, with all its component equal to 0.0 except one which is equal to 1.0.

`fn orthogonal_subspace_basis(&self) -> Vec<DVec3<N>>`

Computes a basis of the space orthogonal to the vector. If the input vector is of dimension n, this will return n - 1 vectors.

`impl<N: Copy + Zero> DVec3<N>`

`fn from_elem(dim: usize, elem: N) -> DVec3<N>`

Builds a vector filled with a constant.

`impl<N: Copy + Zero> DVec3<N>`

`fn from_slice(dim: usize, vec: &[N]) -> DVec3<N>`

Builds a vector filled with the components provided by a vector.

The vector must have at least dim elements.

`impl<N: Zero> DVec3<N>`

`fn from_fn<F: FnMut(usize) -> N>(dim: usize, f: F) -> DVec3<N>`

Builds a vector filled with the result of a function.

Trait Implementations

`impl<N: PartialEq> PartialEq for DVec3<N>`

`fn eq(&self, other: &DVec3<N>) -> bool`

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

`impl<N: Clone> Clone for DVec3<N>`

`fn clone(&self) -> DVec3<N>`

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

`impl<N> Shape<usize> for DVec3<N>`

`fn shape(&self) -> usize`

`impl<N: Copy> Indexable<usize, N> for DVec3<N>`

`fn swap(&mut self, i: usize, j: usize)`

`unsafe fn unsafe_at(&self, i: usize) -> N`

`unsafe fn unsafe_set(&mut self, i: usize, val: N)`

`impl<N> Index<usize> for DVec3<N>`

`type Output = N`

`fn index(&self, i: usize) -> &N`

`impl<N> IndexMut<usize> for DVec3<N>`

`fn index_mut(&mut self, i: usize) -> &mut N`

`impl<N> Iterable<N> for DVec3<N>`

`fn iter<'l>(&'l self) -> Iter<'l, N>`

`impl<N> IterableMut<N> for DVec3<N>`

`fn iter_mut<'l>(&'l mut self) -> IterMut<'l, N>`

`impl<N: Copy + Add<N, Output=N> + Mul<N, Output=N>> Axpy<N> for DVec3<N>`

`fn axpy(&mut self, a: &N, x: &DVec3<N>)`

`impl<N: Copy + Mul<N, Output=N> + Zero> Mul<DVec3<N>> for DVec3<N>`

`type Output = DVec3<N>`

`fn mul(self, right: DVec3<N>) -> DVec3<N>`

`impl<N: Copy + Div<N, Output=N> + Zero> Div<DVec3<N>> for DVec3<N>`

`type Output = DVec3<N>`

`fn div(self, right: DVec3<N>) -> DVec3<N>`

`impl<N: Copy + Add<N, Output=N> + Zero> Add<DVec3<N>> for DVec3<N>`

`type Output = DVec3<N>`

`fn add(self, right: DVec3<N>) -> DVec3<N>`

`impl<N: Copy + Sub<N, Output=N> + Zero> Sub<DVec3<N>> for DVec3<N>`

`type Output = DVec3<N>`

`fn sub(self, right: DVec3<N>) -> DVec3<N>`

`impl<N: Neg<Output=N> + Zero + Copy> Neg for DVec3<N>`

`type Output = DVec3<N>`

`fn neg(self) -> DVec3<N>`

`impl<N: BaseNum> Dot<N> for DVec3<N>`

`fn dot(&self, other: &DVec3<N>) -> N`

`impl<N: BaseFloat> Norm<N> for DVec3<N>`

`fn sqnorm(&self) -> N`

`fn normalize(&self) -> DVec3<N>`

`fn normalize_mut(&mut self) -> N`

`fn norm(&self) -> N`

`impl<N: ApproxEq<N>> ApproxEq<N> for DVec3<N>`

`fn approx_epsilon(_: Option<DVec3<N>>) -> N`

`fn approx_ulps(_: Option<DVec3<N>>) -> u32`

`fn approx_eq_eps(&self, other: &DVec3<N>, epsilon: &N) -> bool`

`fn approx_eq_ulps(&self, other: &DVec3<N>, ulps: u32) -> bool`

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

`impl<N: Copy + Mul<N, Output=N> + Zero> Mul<N> for DVec3<N>`

`type Output = DVec3<N>`

`fn mul(self, right: N) -> DVec3<N>`

`impl<N: Copy + Div<N, Output=N> + Zero> Div<N> for DVec3<N>`

`type Output = DVec3<N>`

`fn div(self, right: N) -> DVec3<N>`

`impl<N: Copy + Add<N, Output=N> + Zero> Add<N> for DVec3<N>`

`type Output = DVec3<N>`

`fn add(self, right: N) -> DVec3<N>`

`impl<N: Copy + Sub<N, Output=N> + Zero> Sub<N> for DVec3<N>`

`type Output = DVec3<N>`

`fn sub(self, right: N) -> DVec3<N>`

`impl<N: Zero> FromIterator<N> for DVec3<N>`

`fn from_iter<I: IntoIterator<Item=N>>(param: I) -> DVec3<N>`