Struct glucose::Vector

#[repr(C)]pub struct Vector<T, const N: usize> {
    pub data: [T; N],
}

Fields

data: [T; N]

Implementations

impl<T: Scalar> Vector<T, 2>

pub fn add_fast(&self, rhs: Self) -> Self

pub fn sub_fast(&self, rhs: Self) -> Self

pub fn mul_fast(&self, rhs: T) -> Self

pub fn div_fast(&self, rhs: T) -> Self

pub fn dot_fast(&self, rhs: Self) -> T

pub fn wedge(&self, other: Self) -> Bivector2<T>

impl<T: Scalar> Vector<T, 3>

pub fn add_fast(&self, rhs: Self) -> Self

pub fn sub_fast(&self, rhs: Self) -> Self

pub fn mul_fast(&self, rhs: T) -> Self

pub fn div_fast(&self, rhs: T) -> Self

pub fn dot_fast(&self, other: Self) -> T

impl<T: Scalar> Vector<T, 4>

pub fn add_fast(&self, rhs: Self) -> Self

pub fn sub_fast(&self, rhs: Self) -> Self

pub fn mul_fast(&self, rhs: T) -> Self

pub fn div_fast(&self, rhs: T) -> Self

impl<T: Scalar> Vector<T, 5>

pub fn add_fast(&self, rhs: Self) -> Self

pub fn sub_fast(&self, rhs: Self) -> Self

pub fn mul_fast(&self, rhs: T) -> Self

pub fn div_fast(&self, rhs: T) -> Self

impl<T: Scalar> Vector<T, 6>

pub fn add_fast(&self, rhs: Self) -> Self

pub fn sub_fast(&self, rhs: Self) -> Self

pub fn mul_fast(&self, rhs: T) -> Self

pub fn div_fast(&self, rhs: T) -> Self

impl<T: Scalar> Vector<T, 7>

pub fn add_fast(&self, rhs: Self) -> Self

pub fn sub_fast(&self, rhs: Self) -> Self

pub fn mul_fast(&self, rhs: T) -> Self

pub fn div_fast(&self, rhs: T) -> Self

impl<T: Scalar> Vector<T, 8>

pub fn add_fast(&self, rhs: Self) -> Self

pub fn sub_fast(&self, rhs: Self) -> Self

pub fn mul_fast(&self, rhs: T) -> Self

pub fn div_fast(&self, rhs: T) -> Self

impl<T, const N: usize> Vector<T, { N }>

pub const fn new(data: [T; N]) -> Self

pub const fn len(&self) -> usize

pub const fn as_array(&self) -> &[T; N]

pub fn as_array_mut(&mut self) -> &mut [T; N]

pub fn as_slice(&self) -> &[T]

pub fn as_slice_mut(&mut self) -> &mut [T]

pub const fn as_ptr(&self) -> *const T

pub fn as_mut_ptr(&mut self) -> *mut T

pub fn as_bytes(&self) -> &[u8]

impl<T: Copy, const N: usize> Vector<T, { N }>

pub fn broadcast(value: T) -> Self

impl<T: Scalar, const N: usize> Vector<T, { N }>

pub fn unit(n: usize) -> Self

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

pub fn reverse(&mut self)

pub fn reversed(&self) -> Self

pub fn map<F: Fn(T) -> T>(&self, f: F) -> Self

pub fn apply<F: Fn(T) -> T>(&mut self, f: F)

pub fn zero() -> Self

constructs a new VecN with all values being 0

pub fn one() -> Self

constructs a new VecN with all values being 1

impl<T: Scalar + Float + Sum, const N: usize> Vector<T, { N }>

pub fn magnitude_squared(&self) -> T

pub fn magnitude(&self) -> T

pub fn normalize(&mut self)

pub fn normalized(&self) -> Self

impl<T: Scalar + Signed, const N: usize> Vector<T, { N }>

pub fn abs(&mut self)

pub fn abs_copy(&self) -> Self

impl<T: Scalar + Two, const N: usize> Vector<T, { N }>

pub fn reflect(&mut self, normal: Self)

impl<T: Scalar + Cmp, const N: usize> Vector<T, { N }>

pub fn clamp(&mut self, min: Self, max: Self)

pub fn clamped(&self, min: Self, max: Self) -> Self

returns a VecN' with clamped values without consuming VecN

pub fn max_by_component(&self, other: &Self) -> Self

returns a new VecN' with each component having the bigger number from either VecN1 or VecN2

pub fn min_by_component(&self, other: &Self) -> Self

returns a new VecN' with each component having the smaller number from either VecN1 or VecN2

impl<T: Default + Copy, const N: usize> Vector<T, { N }>

pub fn from_other<const M: usize>(rhs: Vector<T, { M }>) -> Self

Trait Implementations

impl<T: Scalar, const N: usize> Add<Vector<T, N>> for Vector<T, { N }>

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Scalar, const N: usize> AddAssign<Vector<T, N>> for Vector<T, { N }>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone, const N: usize> Clone for Vector<T, N>

fn clone(&self) -> Vector<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy, const N: usize> Copy for Vector<T, N>

impl<T: Debug, const N: usize> Debug for Vector<T, N>

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

Formats the value using the given formatter.

impl<T: Default + Copy, const N: usize> Default for Vector<T, { N }>

fn default() -> Self

Returns the "default value" for a type.

impl<T: Display, const N: usize> Display for Vector<T, { N }>

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

Formats the value using the given formatter.

impl<T: Scalar, const N: usize> Div<T> for Vector<T, { N }>

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Scalar, const N: usize> Div<Vector<T, N>> for Vector<T, { N }>

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Scalar, const N: usize> DivAssign<T> for Vector<T, { N }>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Scalar, const N: usize> DivAssign<Vector<T, N>> for Vector<T, { N }>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T, const N: usize> From<[T; N]> for Vector<T, { N }>

fn from(arr: [T; N]) -> Self

Performs the conversion.

impl<T: Copy, const N: usize> From<Matrix<T, N, 1_usize>> for Vector<T, { N }>

fn from(rhs: Matrix<T, { N }, 1>) -> Self

Performs the conversion.

impl<T, const M: usize> From<Vector<T, M>> for Matrix<T, { M }, 1>

fn from(rhs: Vector<T, { M }>) -> Self

Performs the conversion.

impl<T, const N: usize> Index<usize> for Vector<T, { N }>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for Vector<T, { N }>

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

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

impl<T: Scalar, const N: usize> Mul<T> for Vector<T, { N }>

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: Scalar, const N: usize, const M: usize> Mul<Vector<T, N>> for Matrix<T, { M }, { N }>

type Output = Vector<T, { M }>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<T, { N }>) -> Self::Output

Performs the * operation.

impl<T: Scalar, const N: usize> Mul<Vector<T, N>> for Vector<T, { N }>

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Scalar, const N: usize> MulAssign<T> for Vector<T, { N }>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Scalar, const N: usize> MulAssign<Vector<T, N>> for Vector<T, { N }>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: Scalar, const N: usize> Sub<Vector<T, N>> for Vector<T, { N }>

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Scalar, const N: usize> SubAssign<Vector<T, N>> for Vector<T, { N }>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.