Struct lattice_qcd_rs::lattice::Direction

Get if the position is Negative. see Direction::is_positive

pub const fn to_positive(self) -> Self

Return the positive direction associated, for example -x gives +x and +x gives +x.

pub const fn index(&self) -> usize

Get a index associated to the direction.

pub fn to_vector(self, a: f64) -> SVector<Real, D>

Convert the direction into a vector of norm a;

pub const fn dim() -> usize

Returns the dimension

pub fn to_unit_vector(self) -> SVector<Real, D>

Convert the direction into a vector of norm 1;

pub fn from_vector(v: &SVector<Real, D>) -> Self

Find the direction the vector point the most. For a zero vector return DirectionEnum::XPos.

Example

assert_eq!(
    Direction::from_vector(&nalgebra::Vector4::new(1_f64, 0_f64, 0_f64, 0_f64)),
    Direction::<4>::new(0, true).ok_or(ImplementationError::OptionWithUnexpectedNone)?
);
assert_eq!(
    Direction::from_vector(&nalgebra::Vector4::new(0_f64, -1_f64, 0_f64, 0_f64)),
    Direction::<4>::new(1, false).ok_or(ImplementationError::OptionWithUnexpectedNone)?
);
assert_eq!(
    Direction::from_vector(&nalgebra::Vector4::new(0.5_f64, 1_f64, 0_f64, 2_f64)),
    Direction::<4>::new(3, true).ok_or(ImplementationError::OptionWithUnexpectedNone)?
);

Trait Implementations§

impl<const D: usize> Clone for Direction<D>

fn clone(&self) -> Direction<D>

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl<const D: usize> Debug for Direction<D>

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

Formats the value using the given formatter. Read more

fn from(d: &Direction<D>) -> Self

Converts to this type from the input type.

impl<const D: usize> From<&Direction<D>> for usize

Return Direction::to_index.

fn from(d: &Direction<D>) -> Self

Converts to this type from the input type.

impl From<&DirectionEnum> for Direction<4>

fn from(d: &DirectionEnum) -> Self

Converts to this type from the input type.

impl<const D: usize> From<&Matrix<f64, Const<D>, Const<1>, ArrayStorage<f64, D, 1>>> for Direction<D>

Return DirectionEnum::from_vector.

impl<const D: usize> PartialOrd<Direction<D>> for Direction<D>

Partial ordering is set as follows: two directions can be compared if they have the same index or the same direction sign. In the first case a positive direction is greater than a negative direction In the latter case the ordering is done on the index.

Example

use std::cmp::Ordering;

let dir_1 =
    Direction::<4>::new(1, false).ok_or(ImplementationError::OptionWithUnexpectedNone)?;
let dir_2 =
    Direction::<4>::new(1, true).ok_or(ImplementationError::OptionWithUnexpectedNone)?;
assert!(dir_1 < dir_2);
assert_eq!(dir_1.partial_cmp(&dir_2), Some(Ordering::Less));
//--------
let dir_3 =
    Direction::<4>::new(3, false).ok_or(ImplementationError::OptionWithUnexpectedNone)?;
let dir_4 =
    Direction::<4>::new(1, false).ok_or(ImplementationError::OptionWithUnexpectedNone)?;
assert!(dir_3 > dir_4);
assert_eq!(dir_3.partial_cmp(&dir_4), Some(Ordering::Greater));
//--------
let dir_5 =
    Direction::<4>::new(3, true).ok_or(ImplementationError::OptionWithUnexpectedNone)?;
let dir_6 =
    Direction::<4>::new(1, false).ok_or(ImplementationError::OptionWithUnexpectedNone)?;
assert_eq!(dir_5.partial_cmp(&dir_6), None);
//--------
let dir_5 =
    Direction::<4>::new(1, false).ok_or(ImplementationError::OptionWithUnexpectedNone)?;
let dir_6 =
    Direction::<4>::new(1, false).ok_or(ImplementationError::OptionWithUnexpectedNone)?;
assert_eq!(dir_5.partial_cmp(&dir_6), Some(Ordering::Equal));

impl<const D: usize> StructuralEq for Direction<D>

impl<const D: usize> StructuralPartialEq for Direction<D>

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

Checks if self is actually part of its subset T (and can be converted to it).

fn to_subset_unchecked(&self) -> SS

impl<T> ClosedNeg for Twhere T: Neg<Output = T>,

impl<T> DeserializeOwned for Twhere T: for<'de> Deserialize<'de>,