Struct lowdim::Vec4d

pub struct Vec4d<S = i64>(_)
 where
    S: Integer;

A 4d discrete vector.

Implementations

impl<S: Integer> Vec4d<S>

pub fn new(x: S, y: S, z: S, w: S) -> Vec4d<S>

Creates a new 4d vector from its coordinates.

pub fn x(&self) -> S

Returns the x coordinate of the vector.

Examples

let v = v4d(2, 3, -1, 4);
assert_eq!(2, v.x());

pub fn y(&self) -> S

Returns the y coordinate of the vector.

Examples

let v = v4d(2, 3, -1, 4);
assert_eq!(3, v.y());

pub fn z(&self) -> S

Returns the z coordinate of the vector.

Examples

let v = v4d(2, 3, -1, 4);
assert_eq!(-1, v.z());

pub fn w(&self) -> S

Returns the w coordinate of the vector.

Examples

let v = v4d(2, 3, -1, 4);
assert_eq!(4, v.w());

pub fn is_towards_pos_x(&self) -> bool

Returns true if the vector points towards positive x.

That is, among the vectors pointing in both directions along the coordinate axes, the one pointing towards positive x is closest to this vector. Or to put it more concretely, the x coordinate of the vector is positive, and its absolute value is greater than that of the other coordinates.

Examples

use lowdim::v4d;

let v = v4d(6, 2, -1, 4);
assert!(v.is_towards_pos_x());
let v = v4d(6, -2, -1, 4);
assert!(v.is_towards_pos_x());
let v = v4d(-6, -2, -1, 4);
assert!(!v.is_towards_pos_x());
let v = v4d(6, 2, -1, 6);
assert!(!v.is_towards_pos_x());

pub fn is_towards_neg_x(&self) -> bool

Returns true if the vector points towards negative x.

That is, among the vectors pointing in both directions along the coordinate axes, the one pointing towards negative x is closest to this vector. Or to put it more concretely, the x coordinate of the vector is negative, and its absolute value is greater than that of the other coordinates.

Examples

let v = v4d(-6, 2, -1, 4);
assert!(v.is_towards_neg_x());

pub fn is_towards_pos_y(self) -> bool

Returns true if the vector points towards positive y.

See Vec4d::is_towards_pos_x for more details.

Examples

let v = v4d(2, 6, -1, 4);
assert!(v.is_towards_pos_y());

pub fn is_towards_neg_y(&self) -> bool

Returns true if the vector points towards negative y.

See Vec4d::is_towards_neg_x for more details.

Examples

let v = v4d(2, -6, -1, 4);
assert!(v.is_towards_neg_y());

pub fn is_towards_pos_z(self) -> bool

Returns true if the vector points towards positive z.

See Vec4d::is_towards_pos_x for more details.

Examples

let v = v4d(2, -3, 4, -1);
assert!(v.is_towards_pos_z());

pub fn is_towards_neg_z(&self) -> bool

Returns true if the vector points towards negative z.

See Vec4d::is_towards_neg_x for more details.

Examples

let v = v4d(2, -3, -4, -1);
assert!(v.is_towards_neg_z());

pub fn is_towards_pos_w(self) -> bool

Returns true if the vector points towards positive w.

See Vec4d::is_towards_pos_x for more details.

Examples

let v = v4d(2, -3, 4, 5);
assert!(v.is_towards_pos_w());

pub fn is_towards_neg_w(&self) -> bool

Returns true if the vector points towards negative w.

See Vec4d::is_towards_neg_x for more details.

Examples

let v = v4d(2, -3, -4, -5);
assert!(v.is_towards_neg_w());

Trait Implementations

impl<'a, S: Integer> Add<&'a Vec4d<S>> for Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the + operator.

fn add(self, other: &'a Vec4d<S>) -> Vec4d<S>

Performs the + operation.

impl<'a, S: Integer> Add<&'a Vec4d<S>> for &'a Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the + operator.

fn add(self, other: &'a Vec4d<S>) -> Vec4d<S>

Performs the + operation.

impl<S: Integer> Add<Vec4d<S>> for Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the + operator.

fn add(self, other: Vec4d<S>) -> Vec4d<S>

Performs the + operation.

impl<'a, S: Integer> Add<Vec4d<S>> for &'a Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the + operator.

fn add(self, other: Vec4d<S>) -> Vec4d<S>

Performs the + operation.

impl<'a, S: Integer> AddAssign<&'a Vec4d<S>> for Vec4d<S>

fn add_assign(&mut self, other: &'a Vec4d<S>)

Performs the += operation.

impl<S: Integer> AddAssign<Vec4d<S>> for Vec4d<S>

fn add_assign(&mut self, other: Vec4d<S>)

Performs the += operation.

impl<S: Clone> Clone for Vec4d<S> where
    S: Integer, 

fn clone(&self) -> Vec4d<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Integer> Debug for Vec4d<S>

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

Formats the value using the given formatter.

impl<S: Default> Default for Vec4d<S> where
    S: Integer, 

fn default() -> Vec4d<S>

Returns the “default value” for a type.

impl<'a, S: Integer> Div<&'a S> for Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the / operator.

fn div(self, other: &'a S) -> Vec4d<S>

Performs the / operation.

impl<'a, S: Integer> Div<&'a S> for &'a Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the / operator.

fn div(self, other: &'a S) -> Vec4d<S>

Performs the / operation.

impl<S: Integer> Div<S> for Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the / operator.

fn div(self, other: S) -> Vec4d<S>

Performs the / operation.

impl<'a, S: Integer> Div<S> for &'a Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the / operator.

fn div(self, other: S) -> Vec4d<S>

Performs the / operation.

impl<S: Integer> FromIterator<S> for Vec4d<S>

fn from_iter<II>(ii: II) -> Self where
    II: IntoIterator<Item = S>, 

Creates a value from an iterator.

impl<S: Hash> Hash for Vec4d<S> where
    S: Integer, 

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<S: Integer> Index<usize> for Vec4d<S>

type Output = S

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<'a, S: Integer> Mul<&'a Vec4d<S>> for Vec4d<S>

type Output = S

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<S>) -> S

Performs the * operation.

impl<'a, S: Integer> Mul<&'a Vec4d<S>> for &'a Vec4d<S>

type Output = S

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<S>) -> S

Performs the * operation.

impl<'a, S: Integer> Mul<&'a Vec4d<S>> for Matrix4d<S> where
    S: Copy + Add<Output = S> + Mul<Output = S>, 

type Output = Vec4d<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<S>) -> Vec4d<S>

Performs the * operation.

impl<'a, S: Integer> Mul<&'a Vec4d<S>> for &'a Matrix4d<S> where
    S: Copy + Add<Output = S> + Mul<Output = S>, 

type Output = Vec4d<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<S>) -> Vec4d<S>

Performs the * operation.

impl<'a> Mul<&'a Vec4d<i128>> for i128

type Output = Vec4d<i128>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<i128>) -> Vec4d<i128>

Performs the * operation.

impl<'a> Mul<&'a Vec4d<i128>> for &'a i128

type Output = Vec4d<i128>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<i128>) -> Vec4d<i128>

Performs the * operation.

impl<'a> Mul<&'a Vec4d<i32>> for i32

type Output = Vec4d<i32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<i32>) -> Vec4d<i32>

Performs the * operation.

impl<'a> Mul<&'a Vec4d<i32>> for &'a i32

type Output = Vec4d<i32>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<i32>) -> Vec4d<i32>

Performs the * operation.

impl<'a> Mul<&'a Vec4d<i64>> for i64

type Output = Vec4d<i64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<i64>) -> Vec4d<i64>

Performs the * operation.

impl<'a> Mul<&'a Vec4d<i64>> for &'a i64

type Output = Vec4d<i64>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vec4d<i64>) -> Vec4d<i64>

Performs the * operation.

impl<S: Integer> Mul<Vec4d<S>> for Vec4d<S>

type Output = S

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<S>) -> S

Performs the * operation.

impl<'a, S: Integer> Mul<Vec4d<S>> for &'a Vec4d<S>

type Output = S

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<S>) -> S

Performs the * operation.

impl<S: Integer> Mul<Vec4d<S>> for Matrix4d<S> where
    S: Copy + Add<Output = S> + Mul<Output = S>, 

type Output = Vec4d<S>

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<S>) -> Vec4d<S>

Performs the * operation.

impl<'a, S: Integer> Mul<Vec4d<S>> for &'a Matrix4d<S> where
    S: Copy + Add<Output = S> + Mul<Output = S>, 

type Output = Vec4d<S>

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<S>) -> Vec4d<S>

Performs the * operation.

impl Mul<Vec4d<i128>> for i128

type Output = Vec4d<i128>

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<i128>) -> Vec4d<i128>

Performs the * operation.

impl<'a> Mul<Vec4d<i128>> for &'a i128

type Output = Vec4d<i128>

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<i128>) -> Vec4d<i128>

Performs the * operation.

impl Mul<Vec4d<i32>> for i32

type Output = Vec4d<i32>

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<i32>) -> Vec4d<i32>

Performs the * operation.

impl<'a> Mul<Vec4d<i32>> for &'a i32

type Output = Vec4d<i32>

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<i32>) -> Vec4d<i32>

Performs the * operation.

impl Mul<Vec4d<i64>> for i64

type Output = Vec4d<i64>

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<i64>) -> Vec4d<i64>

Performs the * operation.

impl<'a> Mul<Vec4d<i64>> for &'a i64

type Output = Vec4d<i64>

The resulting type after applying the * operator.

fn mul(self, other: Vec4d<i64>) -> Vec4d<i64>

Performs the * operation.

impl<S: Integer> Neg for Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the - operator.

fn neg(self) -> Vec4d<S>

Performs the unary - operation.

impl<'a, S: Integer> Neg for &'a Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the - operator.

fn neg(self) -> Vec4d<S>

Performs the unary - operation.

impl<S: PartialEq> PartialEq<Vec4d<S>> for Vec4d<S> where
    S: Integer, 

fn eq(&self, other: &Vec4d<S>) -> bool

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

fn ne(&self, other: &Vec4d<S>) -> bool

This method tests for !=.

impl<'a, S: Integer> Sub<&'a Vec4d<S>> for Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the - operator.

fn sub(self, other: &'a Vec4d<S>) -> Vec4d<S>

Performs the - operation.

impl<'a, S: Integer> Sub<&'a Vec4d<S>> for &'a Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the - operator.

fn sub(self, other: &'a Vec4d<S>) -> Vec4d<S>

Performs the - operation.

impl<S: Integer> Sub<Vec4d<S>> for Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the - operator.

fn sub(self, other: Vec4d<S>) -> Vec4d<S>

Performs the - operation.

impl<'a, S: Integer> Sub<Vec4d<S>> for &'a Vec4d<S>

type Output = Vec4d<S>

The resulting type after applying the - operator.

fn sub(self, other: Vec4d<S>) -> Vec4d<S>

Performs the - operation.

impl<'a, S: Integer> SubAssign<&'a Vec4d<S>> for Vec4d<S>

fn sub_assign(&mut self, other: &'a Vec4d<S>)

Performs the -= operation.

impl<S: Integer> SubAssign<Vec4d<S>> for Vec4d<S>

fn sub_assign(&mut self, other: Vec4d<S>)

Performs the -= operation.

impl<'a, S: Integer> Sum<&'a Vec4d<S>> for Vec4d<S>

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = &'a Vec4d<S>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<S: Integer> Sum<Vec4d<S>> for Vec4d<S>

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = Vec4d<S>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<S: Integer> Vector<S> for Vec4d<S>

fn as_slice(&self) -> &[S]

Returns a slice containing the coordinates of the vector.

fn as_mut_slice(&mut self) -> &mut [S]

Returns a mutable slice containing the coordinates of the vector.

fn norm_l1(&self) -> S

Returns the L1 norm of the vector.

This is also called the taxicab, Manhatten or city block norm.

fn norm_l_infty(&self) -> S

Returns the L∞ norm of the vector.

This is also called the maximum or Chebychev norm.

fn norm_l2_squared(&self) -> S

Returns the square of the L2-norm of the vector.

The L2-norm is also called the Euclidean norm and is the standard notion of the length of a vector.

const DIM: usize

The dimension of the vectors in this type.

type DefaultLayout = Layout4d<S>

The default layout to use with this vector.

fn with<F>(f: F) -> Vec4d<S> where
    F: Fn(usize) -> S, 

Create a vector from a function which computes the coordinates.

fn componentwise_cmp(&self, other: &Vec4d<S>) -> Option<Ordering>

Returns the partial ordering by component of two vectors.

fn lex_cmp(&self, other: &Vec4d<S>) -> Ordering

Returns the lexicographic total ordering for this and another vector.

fn zero() -> Self

Creates the zero vector.

fn ones() -> Self

Creates a vector of ones.

fn is_zero(&self) -> bool

Returns true if a vector is the zero vector.

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

Apply min by component

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

Apply max by component

fn signum(&self) -> Self

Signum by component.

fn unit_vecs() -> UnitVecs<S, Self>

Returns an iterator that yields the unit vectors.

fn unit_vecs_l1() -> UnitVecsL1<S, Self>

Returns an iterator that yields the vectors to orthogonal neighbours.

fn unit_vecs_l_infty() -> UnitVecsLInfty<S, Self>

Creates a vector of the vectors with L∞ norm equal to 1.

impl<S: Copy> Copy for Vec4d<S> where
    S: Integer, 

impl<S: Eq> Eq for Vec4d<S> where
    S: Integer, 

impl<'a, S: Integer> MatrixOps<S, &'a Vec4d<S>, Vec4d<S>> for Matrix4d<S>

impl<'a, S: Integer> MatrixOps<S, &'a Vec4d<S>, Vec4d<S>> for &'a Matrix4d<S>

impl<S: Integer> MatrixOps<S, Vec4d<S>, Vec4d<S>> for Matrix4d<S>

impl<'a, S: Integer> MatrixOps<S, Vec4d<S>, Vec4d<S>> for &'a Matrix4d<S>

impl<S> StructuralEq for Vec4d<S> where
    S: Integer, 

impl<S> StructuralPartialEq for Vec4d<S> where
    S: Integer, 

impl<'a, S: Integer> VectorOps<S, &'a Vec4d<S>, Vec4d<S>> for Vec4d<S>

impl<'a, S: Integer> VectorOps<S, &'a Vec4d<S>, Vec4d<S>> for &'a Vec4d<S>

impl<S: Integer> VectorOps<S, Vec4d<S>, Vec4d<S>> for Vec4d<S>

impl<'a, S: Integer> VectorOps<S, Vec4d<S>, Vec4d<S>> for &'a Vec4d<S>