Struct Cartesian 

pub struct Cartesian<const N: usize> {
    pub coordinates: [f64; N],
}

A Vector represented by N f64 coordinates.

Cartesian is the canonical implementation of InnerProduct.

Constructing vectors

The default is the 0 vector:

use hoomd_vector::Cartesian;

let v = Cartesian::<3>::default();
assert_eq!(v, [0.0; 3].into())

Create a vector with an array of coordinates:

use hoomd_vector::Cartesian;

let v = Cartesian::from([1.0, 2.0, 3.0, 4.0, 5.0]);

2D and 3D vectors can also be initialized from tuples:

use hoomd_vector::Cartesian;

let a = Cartesian::from((1.0, 2.0, 3.0));
let b = Cartesian::from((4.0, 5.0));

Construct a random vector in the [-1, 1] hypercube:

use hoomd_vector::Cartesian;
use rand::{RngExt, SeedableRng, rngs::StdRng};

let mut rng = StdRng::seed_from_u64(1);
let v: Cartesian<3> = rng.random();

Operating on vectors

Use vector math operations when you can:

use hoomd_vector::{Cartesian, InnerProduct};

let a = Cartesian::from([1.0, 2.0]);
let b = Cartesian::from([4.0, 8.0]);
let c = (a + b).dot(&a);

Access the coordinates directly when needed:

use hoomd_vector::Cartesian;

let a = Cartesian::from((1.0, 2.0));
let b = Cartesian::from((a[1], 0.0));

Compute the sum of an iterator over vectors:

use hoomd_vector::Cartesian;

let total: Cartesian<2> =
    [Cartesian::from((1.0, 2.0)), Cartesian::from((3.0, 4.0))]
        .into_iter()
        .sum();

Fields

coordinates: [f64; N]

The vector’s coordinates.

Implementations

impl Cartesian<2>

pub fn perpendicular(self) -> Self

Construct a 2-vector perpendicular to self.

Given a vector $(v_x, v_y)$ perpendicular returns the vector rotated by $\pi/2$:

(-v_y, v_x)

Example

use hoomd_vector::Cartesian;

let v = Cartesian::from([1.0, -4.5]);
assert_eq!(v.perpendicular(), [4.5, 1.0].into());

impl<const N: usize> Cartesian<N>

pub fn to_row_matrix(self) -> Matrix<1, N>

Convert a Cartesian<N> into a row matrix Matrix<1, N>.

Example

use hoomd_linear_algebra::matrix::Matrix;
use hoomd_vector::Cartesian;

let a = Cartesian::from([1.0, -2.0, 3.0]);

let b = a.to_row_matrix();
assert_eq!(b.rows, [[1.0, -2.0, 3.0]]);

pub fn to_column_matrix(self) -> Matrix<N, 1>

Convert a Cartesian<N> into a column matrix Matrix<N, 1>.

Example

use hoomd_linear_algebra::matrix::Matrix;
use hoomd_vector::Cartesian;

let a = Cartesian::from([1.0, -2.0, 3.0]);

let b = a.to_column_matrix();
assert_eq!(b.rows, [[1.0], [-2.0], [3.0]]);

Trait Implementations

impl<const N: usize> AbsDiffEq for Cartesian<N>

type Epsilon = <f64 as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximimate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<const N: usize> Add for Cartesian<N>

type Output = Cartesian<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: usize> AddAssign for Cartesian<N>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const N: usize> Clone for Cartesian<N>

fn clone(&self) -> Cartesian<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Cross for Cartesian<3>

fn cross(&self, other: &Self) -> Self

Perform the cross product. Compute the cross product (right-handed) of two vectors:

impl<const N: usize> Debug for Cartesian<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for Cartesian<N>

fn default() -> Self

Create a 0 vector.

Example

use hoomd_vector::Cartesian;

let v = Cartesian::<3>::default();
assert_eq!(v, [0.0; 3].into())

impl<'de, const N: usize> Deserialize<'de> for Cartesian<N>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> Display for Cartesian<N>

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

Formats the value using the given formatter.

impl<const N: usize> Distribution<Cartesian<N>> for Ball

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Cartesian<N>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<const N: usize> Distribution<Cartesian<N>> for StandardUniform

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Cartesian<N>

Sample a Cartesian vector from the uniform [-1, 1] hypercube.

Each coordinate in the vector is in the closed range [-1, 1].

Example

use hoomd_vector::Cartesian;
use rand::{RngExt, SeedableRng, rngs::StdRng};

let mut rng = StdRng::seed_from_u64(1);
let v: Cartesian<3> = rng.random();

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<const N: usize> Div<f64> for Cartesian<N>

type Output = Cartesian<N>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self

Performs the / operation.

impl<const N: usize> DivAssign<f64> for Cartesian<N>

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl<const N: usize> From<[f64; N]> for Cartesian<N>

fn from(coordinates: [f64; N]) -> Self

Create a Cartesian vector with the given coordinates.

Example

use hoomd_vector::Cartesian;

let v = Cartesian::from([4.0, 3.0]);

impl From<(f64, f64)> for Cartesian<2>

fn from(coordinates: (f64, f64)) -> Self

Converts to this type from the input type.

impl From<(f64, f64, f64)> for Cartesian<3>

fn from(coordinates: (f64, f64, f64)) -> Self

Converts to this type from the input type.

impl<const N: usize> From<Matrix<1, N>> for Cartesian<N>

fn from(value: Matrix<1, N>) -> Self

Converts to this type from the input type.

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

where T: Into<usize> + SliceIndex<[f64], Output = f64>,

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

Get the value of the vector at coordinate i.

Example

use hoomd_vector::Cartesian;

let v = Cartesian::<3>::try_from(3..6)?;
assert_eq!((v[0], v[1], v[2]), (3.0, 4.0, 5.0));

type Output = f64

The returned type after indexing.

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

where T: Into<usize> + SliceIndex<[f64], Output = f64>,

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

Get a mutable reference to the value of the vector at coordinate i.

Example

use hoomd_vector::Cartesian;

let mut v = Cartesian::<3>::try_from(3..6)?;
assert_eq!((v[0], v[1], v[2]), (3.0, 4.0, 5.0));
v[0] += 1.0;
assert_eq!(v[0], 4.0);

impl<const N: usize> InnerProduct for Cartesian<N>

fn default_unit() -> Unit<Self>

Create a unit vector in the space.

The default unit vector in Cartesian space is [0.0, 0.0, ...., 1.0].

Example

use hoomd_vector::{Cartesian, InnerProduct};

let u = Cartesian::<2>::default_unit();
assert_eq!(*u.get(), [0.0, 1.0].into());

let u = Cartesian::<3>::default_unit();
assert_eq!(*u.get(), [0.0, 0.0, 1.0].into());

fn dot(&self, other: &Self) -> f64

Compute the vector dot product between two vectors.

fn norm_squared(&self) -> f64

Compute the squared norm of the vector.

fn norm(&self) -> f64

Compute the norm of the vector.

fn to_unit(self) -> Result<(Unit<Self>, f64), Error>

Create a vector of unit length pointing in the same direction as the given vector.

fn to_unit_unchecked(self) -> (Unit<Self>, f64)

Create a vector of unit length pointing in the same direction as the given vector.

fn project(&self, b: &Self) -> Self

Project one vector onto another.

impl<const N: usize> IntoIterator for Cartesian<N>

fn into_iter(self) -> Self::IntoIter

Iterate over the components of the vector.

Example

use hoomd_vector::Cartesian;

let a = Cartesian::from([1.0, 2.0]);
let mut iter = a.into_iter();

assert_eq!(iter.next(), Some(1.0));
assert_eq!(iter.next(), Some(2.0));
assert_eq!(iter.next(), None);

type Item = f64

The type of the elements being iterated over.

type IntoIter = <[f64; N] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

impl<const N: usize> Metric for Cartesian<N>

fn distance_squared(&self, other: &Self) -> f64

Computes the squared distance between two points in Euclidean space.

d^2(\vec{x},\vec{y}) = \sum_{i=1}^{N} (x_i - y_i)^2

Example

use hoomd_vector::{Cartesian, Metric};

let x = Cartesian::from([0.0, 1.0, 1.0]);
let y = Cartesian::from([1.0, 0.0, 0.0]);
assert_eq!(3.0, x.distance_squared(&y));

fn n_dimensions(&self) -> usize

Return the number of dimensions in this Cartesian vector space.

Example

use hoomd_vector::{Cartesian, Metric};

let vec2 = Cartesian::<2>::default();
let vec3 = Cartesian::<3>::default();
assert_eq!(2, vec2.n_dimensions());
assert_eq!(3, vec3.n_dimensions());

fn distance(&self, other: &Self) -> f64

Compute the distance between two vectors belonging to a metric space.

impl<const N: usize> Mul<f64> for Cartesian<N>

type Output = Cartesian<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: usize> MulAssign<f64> for Cartesian<N>

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<const N: usize> Neg for Cartesian<N>

type Output = Cartesian<N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const N: usize> PartialEq for Cartesian<N>

fn eq(&self, other: &Cartesian<N>) -> 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<const N: usize> RelativeEq for Cartesian<N>

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl Rotate<Cartesian<2>> for Angle

fn rotate(&self, vector: &Cartesian<2>) -> Cartesian<2>

Rotate a Cartesian<2> in the plane by an Angle

Example

use approxim::assert_relative_eq;
use hoomd_vector::{Angle, Cartesian, Rotate, Rotation};
use std::f64::consts::PI;

let v = Cartesian::from([-1.0, 0.0]);
let a = Angle::from(PI / 2.0);
let rotated = a.rotate(&v);
assert_relative_eq!(rotated, [0.0, -1.0].into());

type Matrix = RotationMatrix<2>

Type of the related rotation matrix

impl Rotate<Cartesian<3>> for Versor

fn rotate(&self, vector: &Cartesian<3>) -> Cartesian<3>

Rotate a Cartesian<3> by a Versor

\mathbf{q} \vec{a} \mathbf{q}^*

Example

use approxim::assert_relative_eq;
use hoomd_vector::{Cartesian, Rotate, Rotation, Versor};
use std::f64::consts::PI;

let a = Cartesian::from([-1.0, 0.0, 0.0]);
let v = Versor::from_axis_angle([0.0, 0.0, 1.0].try_into()?, PI / 2.0);
let b = v.rotate(&a);
assert_relative_eq!(b, [0.0, -1.0, 0.0].into());

type Matrix = RotationMatrix<3>

Type of the related rotation matrix

impl<const N: usize> Rotate<Cartesian<N>> for RotationMatrix<N>

fn rotate(&self, vector: &Cartesian<N>) -> Cartesian<N>

Rotate a Cartesian<N> by a RotationMatrix

Examples

use approxim::assert_relative_eq;
use hoomd_vector::{Angle, Cartesian, Rotate, RotationMatrix};
use std::f64::consts::PI;

let v = Cartesian::from([-1.0, 0.0]);
let a = Angle::from(PI / 2.0);

let matrix = RotationMatrix::from(a);
let rotated = matrix.rotate(&v);
assert_relative_eq!(rotated, [0.0, -1.0].into());

use approxim::assert_relative_eq;
use hoomd_vector::{Cartesian, Rotate, RotationMatrix, Versor};
use std::f64::consts::PI;

let a = Cartesian::from([-1.0, 0.0, 0.0]);
let v = Versor::from_axis_angle([0.0, 0.0, 1.0].try_into()?, PI / 2.0);

let matrix = RotationMatrix::from(v);
let b = matrix.rotate(&a);
assert_relative_eq!(b, [0.0, -1.0, 0.0].into());

type Matrix = RotationMatrix<N>

Type of the related rotation matrix

impl<const N: usize> Serialize for Cartesian<N>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: usize> Sub for Cartesian<N>

type Output = Cartesian<N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: usize> SubAssign for Cartesian<N>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const N: usize> Sum for Cartesian<N>

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

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

impl<const N: usize> TryFrom<Range<usize>> for Cartesian<N>

fn try_from(value: Range<usize>) -> Result<Self, Self::Error>

Create a Cartesian vector with coordinates given by a range.

Example

use hoomd_vector::Cartesian;

let v = Cartesian::<3>::try_from(3..6)?;
assert_eq!(v, [3.0, 4.0, 5.0].into());

type Error = Error

The type returned in the event of a conversion error.

impl<const N: usize> TryFrom<Vec<f64>> for Cartesian<N>

fn try_from(value: Vec<f64>) -> Result<Self, Self::Error>

Create a Cartesian vector with coordinates given by a Vec<f64>

Example

use hoomd_vector::Cartesian;

let v = Cartesian::<3>::try_from(vec![3.0, 4.0, 5.0])?;
assert_eq!(v, [3.0, 4.0, 5.0].into());

This method deallocates the Vec after copying it. Use Cartesian::From<[f64; N]> in performance critical code.

type Error = Error

The type returned in the event of a conversion error.

impl<const N: usize> Copy for Cartesian<N>

impl<const N: usize> StructuralPartialEq for Cartesian<N>

impl<const N: usize> Vector for Cartesian<N>