Struct MathVec

Source

pub struct MathVec<T, const N: usize> { /* private fields */ }

Implementations§

Source §

pub const ZERO: Self

Methods from Deref<Target = [T; N]>§

1.57.0

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

Returns a slice containing the entire array. Equivalent to &s[..].

1.57.0

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

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

1.77.0

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

Borrows each element and returns an array of references with the same size as self.

§Example

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

1.77.0

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

Borrows each element mutably and returns an array of mutable references with the same size as self.

§Example


let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

§Panics

Panics if M > N.

§Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

§Panics

Panics if M > N.

§Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

§Panics

Panics if M > N.

§Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

§Panics

Panics if M > N.

§Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

Read the type from the reader

Source §

fn read<R>(reader: &mut R) -> Result<Self, Error>
where R: Read + Seek,

Read the type from the reader while assuming no arguments have been passed Read more

Source §

fn read_args<R>(reader: &mut R, args: Self::Args) -> Result<Self, Error>
where R: Read + Seek,

Read the type from the reader using the specified arguments

Source §

Returns a duplicate of the value. Read more

Dereferences the value.

Source §

impl<T, const N: usize> DerefMut for MathVec<T, N>

Source §

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

Source §

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

Available on crate feature serde only.

Feeds a slice of this type into the given Hasher. Read more

Source §

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

Source §

type Output = T

The returned type after indexing.

Source §

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

Performs the indexing (container[index]) operation. Read more

Source §

impl<T: Ord, const N: usize> Ord for MathVec<T, N>

Source §

fn cmp(&self, other: &MathVec<T, N>) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0§

fn max(self, other: Self) -> Self
where Self: Sized,

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

impl<T: Eq, const N: usize> Eq for MathVec<T, N>

Source §

impl<T, const N: usize> StructuralPartialEq for MathVec<T, N>

impl<T> FromQuery for T
where T: DeserializeOwned,

Source §

type Target = T

Target type after parsing.

Source §

type Error = HistoryError

Error that can occur while parsing.

Source §

fn from_query( query: &str, ) -> Result<<T as FromQuery>::Target, <T as FromQuery>::Error>

Decode this query string into the target type.

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

Source §

impl<T> ToQuery for T
where T: Serialize,

Source §

type Error = HistoryError

Error that can be returned from the conversion.

Performs the conversion.

§

impl<T, U> TryInto for T
where U: TryFrom<T>,

§

type Error = >::Error

The type returned in the event of a conversion error.

§

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Source §

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

Source §

Struct MathVec Copy item path

Implementations§

impl<T, const N: usize> MathVec<T, N>

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

pub fn into_inner(self) -> [T; N]

impl<T: Copy + Sum, const N: usize> MathVec<T, N>

pub fn sum(&self) -> T

impl<T: Clone, const N: usize> MathVec<T, N>

pub fn dot<U: From<T> + Mul + Sum<<U as Mul>::Output>>(&self, other: &Self) -> U

impl<const N: usize> MathVec<i8, N>

pub const ZERO: Self

impl<const N: usize> MathVec<i16, N>

pub const ZERO: Self

impl<const N: usize> MathVec<i32, N>

pub const ZERO: Self

impl<const N: usize> MathVec<i64, N>

pub const ZERO: Self

impl<const N: usize> MathVec<i128, N>

pub const ZERO: Self

impl<const N: usize> MathVec<isize, N>

pub const ZERO: Self

impl<const N: usize> MathVec<u8, N>

pub const ZERO: Self

impl<const N: usize> MathVec<u16, N>

pub const ZERO: Self

impl<const N: usize> MathVec<u32, N>

pub const ZERO: Self

impl<const N: usize> MathVec<u64, N>

pub const ZERO: Self

impl<const N: usize> MathVec<u128, N>

pub const ZERO: Self

impl<const N: usize> MathVec<usize, N>

pub const ZERO: Self

Methods from Deref<Target = [T; N]>§

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

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

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

§Example

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

§Example

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

§Panics

§Examples

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

§Panics

§Examples

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

§Panics

§Examples

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

§Panics

§Examples

Trait Implementations§

impl<T: AddAssign + Clone, const N: usize> Add<&MathVec<T, N>> for MathVec<T, N>

type Output = MathVec<T, N>

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

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i128where i128: Add<T, Output = T>,

type Output = MathVec<T, N>

fn add(self, rhs: MathVec<T, N>) -> MathVec<T, N>

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i16where i16: Add<T, Output = T>,

type Output = MathVec<T, N>

fn add(self, rhs: MathVec<T, N>) -> MathVec<T, N>

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i32where i32: Add<T, Output = T>,

type Output = MathVec<T, N>

fn add(self, rhs: MathVec<T, N>) -> MathVec<T, N>

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i64where i64: Add<T, Output = T>,

type Output = MathVec<T, N>

fn add(self, rhs: MathVec<T, N>) -> MathVec<T, N>

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i8where i8: Add<T, Output = T>,

type Output = MathVec<T, N>

fn add(self, rhs: MathVec<T, N>) -> MathVec<T, N>

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for isizewhere isize: Add<T, Output = T>,

type Output = MathVec<T, N>

fn add(self, rhs: MathVec<T, N>) -> MathVec<T, N>

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for u128where u128: Add<T, Output = T>,

type Output = MathVec<T, N>

fn add(self, rhs: MathVec<T, N>) -> MathVec<T, N>

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for u16where u16: Add<T, Output = T>,

type Output = MathVec<T, N>

fn add(self, rhs: MathVec<T, N>) -> MathVec<T, N>

Struct MathVec

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i128
where i128: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i16
where i16: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i32
where i32: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i64
where i64: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for i8
where i8: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for isize
where isize: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for u128
where u128: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for u16
where u16: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for u32
where u32: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for u64
where u64: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for u8
where u8: Add<T, Output = T>,

impl<T: Clone, const N: usize> Add<MathVec<T, N>> for usize
where usize: Add<T, Output = T>,