Struct vek::vec::repr_c::extent3::Extent3

#[repr(C)]
pub struct Extent3<T> {
    pub w: T,
    pub h: T,
    pub d: T,
}

Vector type suited for 3D extents (width, height and depth).

There is no Unsigned trait bound because it is not practical, since we sometimes want to be able to express extents as floating-point numbers, for instance.

If you want to assert unsignedness at runtime, you can use the is_all_positive() or is_any_negative() methods.

Fields

w: T

h: T

d: T

Methods

impl<T> Extent3<T>

pub fn new(w: T, h: T, d: T) -> Self

Creates a vector from elements.

impl<T> Extent3<T>

pub fn broadcast(val: T) -> Self where     T: Copy,

Broadcasts a single value to all elements of a new vector.

This function is also named splat() in some libraries, or set1() in Intel intrinsics.

"Broadcast" was chosen as the name because it is explicit enough and is the same wording as the description in relevant Intel intrinsics.

assert_eq!(Vec4::broadcast(5), Vec4::new(5,5,5,5));
assert_eq!(Vec4::broadcast(5), Vec4::from(5));

pub fn zero() -> Self where     T: Zero,

Creates a new vector with all elements set to zero.

assert_eq!(Vec4::zero(), Vec4::new(0,0,0,0));
assert_eq!(Vec4::zero(), Vec4::broadcast(0));
assert_eq!(Vec4::zero(), Vec4::from(0));

pub fn one() -> Self where     T: One,

Creates a new vector with all elements set to one.

assert_eq!(Vec4::one(), Vec4::new(1,1,1,1));
assert_eq!(Vec4::one(), Vec4::broadcast(1));
assert_eq!(Vec4::one(), Vec4::from(1));

pub fn iota() -> Self where     T: Zero + One + AddAssign + Copy,

Produces a vector of the first n integers, starting from zero, where n is the number of elements for this vector type.

The iota (ι) function, originating from APL.

See this StackOverflow answer.

This is mostly useful for debugging purposes and tests.

assert_eq!(Vec4::iota(), Vec4::new(0, 1, 2, 3));

pub fn elem_count(&self) -> usize

Convenience method which returns the number of elements of this vector.

let v = Vec4::new(0,1,2,3);
assert_eq!(v.elem_count(), 4);

pub const ELEM_COUNT: usize

ELEM_COUNT: usize = 3

Convenience constant representing the number of elements for this vector type.

pub fn into_tuple(self) -> (T, T, T)

Converts this into a tuple with the same number of elements by consuming.

pub fn into_array(self) -> [T; 3]

Converts this vector into a fixed-size array.

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

View this vector as an immutable slice.

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

View this vector as a mutable slice.

pub fn from_slice(slice: &[T]) -> Self where     T: Default + Copy,

Collects the content of a slice into a new vector. Elements are initialized to their default values.

pub fn map<D, F>(self, f: F) -> Extent3<D> where     F: FnMut(T) -> D,

Returns a memberwise-converted copy of this vector, using the given conversion closure.

let v = Vec4::new(0_f32, 1., 1.8, 3.14);
let i = v.map(|x| x.round() as i32);
assert_eq!(i, Vec4::new(0, 1, 2, 3));

Performing LERP on integer vectors by concisely converting them to floats:

let a = Vec4::new(0,1,2,3).map(|x| x as f32);
let b = Vec4::new(2,3,4,5).map(|x| x as f32);
let v = Vec4::lerp(a, b, 0.5_f32).map(|x| x.round() as i32);
assert_eq!(v, Vec4::new(1,2,3,4));

pub fn numcast<D>(self) -> Option<Extent3<D>> where     T: NumCast,     D: NumCast,

Returns a memberwise-converted copy of this vector, using NumCast.

let v = Vec4::new(0_f32, 1., 2., 3.);
let i: Vec4<i32> = v.numcast().unwrap();
assert_eq!(i, Vec4::new(0, 1, 2, 3));

pub fn mul_add<V: Into<Self>>(self, mul: V, add: V) -> Self where     T: MulAdd<T, T, Output = T>,

Fused multiply-add. Returns self * mul + add, and may be implemented efficiently by the hardware.

The compiler is often able to detect this kind of operation, so generally you don't need to use it. However, it can make your intent clear.

The name for this method is the one used by the same operation on primitive floating-point types.

let a = Vec4::new(0,1,2,3);
let b = Vec4::new(4,5,6,7);
let c = Vec4::new(8,9,0,1);
assert_eq!(a*b+c, a.mul_add(b, c));

pub fn is_any_negative(&self) -> bool where     T: Signed,

Is any of the elements negative ?

This was intended for checking the validity of extent vectors, but can make sense for other types too.

pub fn are_all_positive(&self) -> bool where     T: Signed,

Are all of the elements positive ?

pub fn min<V>(a: V, b: V) -> Self where     V: Into<Self>,     T: Ord,

Compares elements of a and b, and returns the minimum values into a new vector, using total ordering.

let a = Vec4::new(0,1,2,3);
let b = Vec4::new(3,2,1,0);
let m = Vec4::new(0,1,1,0);
assert_eq!(m, Vec4::min(a, b));

pub fn max<V>(a: V, b: V) -> Self where     V: Into<Self>,     T: Ord,

Compares elements of a and b, and returns the maximum values into a new vector, using total ordering.

let a = Vec4::new(0,1,2,3);
let b = Vec4::new(3,2,1,0);
let m = Vec4::new(3,2,2,3);
assert_eq!(m, Vec4::max(a, b));

pub fn partial_min<V>(a: V, b: V) -> Self where     V: Into<Self>,     T: PartialOrd,

Compares elements of a and b, and returns the minimum values into a new vector, using partial ordering.

let a = Vec4::new(0,1,2,3);
let b = Vec4::new(3,2,1,0);
let m = Vec4::new(0,1,1,0);
assert_eq!(m, Vec4::partial_min(a, b));

pub fn partial_max<V>(a: V, b: V) -> Self where     V: Into<Self>,     T: PartialOrd,

Compares elements of a and b, and returns the minimum values into a new vector, using partial ordering.

let a = Vec4::new(0,1,2,3);
let b = Vec4::new(3,2,1,0);
let m = Vec4::new(3,2,2,3);
assert_eq!(m, Vec4::partial_max(a, b));

pub fn reduce_min(self) -> T where     T: Ord,

Returns the element which has the lowest value in this vector, using total ordering.

assert_eq!(-5, Vec4::new(0, 5, -5, 8).reduce_min());

pub fn reduce_max(self) -> T where     T: Ord,

Returns the element which has the highest value in this vector, using total ordering.

assert_eq!(8, Vec4::new(0, 5, -5, 8).reduce_max());

pub fn reduce_partial_min(self) -> T where     T: PartialOrd,

Returns the element which has the lowest value in this vector, using partial ordering.

assert_eq!(-5_f32, Vec4::new(0_f32, 5., -5., 8.).reduce_partial_min());

pub fn reduce_partial_max(self) -> T where     T: PartialOrd,

Returns the element which has the highest value in this vector, using partial ordering.

assert_eq!(8_f32, Vec4::new(0_f32, 5., -5., 8.).reduce_partial_max());

pub fn reduce_bitand(self) -> T where     T: BitAnd<T, Output = T>,

Returns the result of bitwise-AND (&) on all elements of this vector.

assert_eq!(true,  Vec4::new(true, true, true, true).reduce_bitand());
assert_eq!(false, Vec4::new(true, false, true, true).reduce_bitand());
assert_eq!(false, Vec4::new(true, true, true, false).reduce_bitand());

pub fn reduce_bitor(self) -> T where     T: BitOr<T, Output = T>,

Returns the result of bitwise-OR (|) on all elements of this vector.

assert_eq!(false, Vec4::new(false, false, false, false).reduce_bitor());
assert_eq!(true,  Vec4::new(false, false, true, false).reduce_bitor());

pub fn reduce_bitxor(self) -> T where     T: BitXor<T, Output = T>,

Returns the result of bitwise-XOR (^) on all elements of this vector.

assert_eq!(false, Vec4::new(true, true, true, true).reduce_bitxor());
assert_eq!(true,  Vec4::new(true, false, true, true).reduce_bitxor());

pub fn reduce<F>(self, f: F) -> T where     F: FnMut(T, T) -> T,

Reduces this vector with the given accumulator closure.

pub fn product(self) -> T where     T: Product,

Returns the product of each of this vector's elements.

assert_eq!(1*2*3*4, Vec4::new(1, 2, 3, 4).product());

pub fn sum(self) -> T where     T: Sum,

Returns the sum of each of this vector's elements.

assert_eq!(1+2+3+4, Vec4::new(1, 2, 3, 4).sum());

pub fn average(self) -> T where     T: Sum + Div<T, Output = T> + From<u8>,

Returns the average of this vector's elements.

assert_eq!(2.5_f32, Vec4::new(1_f32, 2., 3., 4.).average());

You should avoid using it on u8 vectors, not only because integer overflows cause panics in debug mode, but also because of integer division, the result may not be the one you expect.

// This causes a panic!
let red = Vec4::new(255u8, 1, 0, 0);
let grey_level = red.average();
assert_eq!(grey_level, 128);

You may want to convert the elements to bigger integers (or floating-point) instead:

let red = Vec4::new(255u8, 1, 128, 128);

let red = red.map(|c| c as u16);
let grey_level = red.average() as u8;
assert_eq!(grey_level, 128);

let red = red.map(|c| c as f32);
let grey_level = red.average().round() as u8;
assert_eq!(grey_level, 128);

pub fn sqrt(self) -> Self where     T: Real,

Returns a new vector which elements are the respective square roots of this vector's elements.

let v = Vec4::new(1f32, 2f32, 3f32, 4f32);
let s = Vec4::new(1f32, 4f32, 9f32, 16f32);
assert_eq!(v, s.sqrt());

pub fn rsqrt(self) -> Self where     T: Real,

Returns a new vector which elements are the respective reciprocal square roots of this vector's elements.

let v = Vec4::new(1f32, 0.5f32, 1f32/3f32, 0.25f32);
let s = Vec4::new(1f32, 4f32, 9f32, 16f32);
assert_eq!(v, s.rsqrt());

pub fn recip(self) -> Self where     T: Real,

Returns a new vector which elements are the respective reciprocal of this vector's elements.

let v = Vec4::new(1f32, 0.5f32, 0.25f32, 0.125f32);
let s = Vec4::new(1f32, 2f32, 4f32, 8f32);
assert_eq!(v, s.recip());
assert_eq!(s, v.recip());

pub fn ceil(self) -> Self where     T: Real,

Returns a new vector which elements are rounded to the nearest greater integer.

let v = Vec4::new(0_f32, 1., 1.8, 3.14);
assert_eq!(v.ceil(), Vec4::new(0f32, 1f32, 2f32, 4f32));

pub fn floor(self) -> Self where     T: Real,

Returns a new vector which elements are rounded down to the nearest lower integer.

let v = Vec4::new(0_f32, 1., 1.8, 3.14);
assert_eq!(v.floor(), Vec4::new(0f32, 1f32, 1f32, 3f32));

pub fn round(self) -> Self where     T: Real,

Returns a new vector which elements are rounded to the nearest integer.

let v = Vec4::new(0_f32, 1., 1.8, 3.14);
assert_eq!(v.round(), Vec4::new(0f32, 1f32, 2f32, 3f32));

pub fn hadd(self, rhs: Self) -> Self where     T: Add<T, Output = T>,

Horizontally adds adjacent pairs of elements in self and rhs into a new vector.

let a = Vec4::new(0, 1, 2, 3);
let b = Vec4::new(4, 5, 6, 7);
let h = Vec4::new(0+1, 2+3, 4+5, 6+7);
assert_eq!(h, a.hadd(b));

pub fn partial_cmpeq<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: PartialEq,

Compares each element of two vectors with the partial equality test, returning a boolean vector.

let u = Vec4::new(0,2,2,6);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.partial_cmpeq(&v), Vec4::new(true, false, true, false));

pub fn partial_cmpne<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: PartialEq,

Compares each element of two vectors with the partial not-equal test, returning a boolean vector.

let u = Vec4::new(0,2,2,6);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.partial_cmpne(&v), Vec4::new(false, true, false, true));

pub fn partial_cmpge<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: PartialOrd,

Compares each element of two vectors with the partial greater-or-equal test, returning a boolean vector.

let u = Vec4::new(0,2,2,2);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.partial_cmpge(&v), Vec4::new(true, true, true, false));

pub fn partial_cmpgt<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: PartialOrd,

Compares each element of two vectors with the partial greater-than test, returning a boolean vector.

let u = Vec4::new(0,2,2,6);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.partial_cmpgt(&v), Vec4::new(false, true, false, true));

pub fn partial_cmple<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: PartialOrd,

Compares each element of two vectors with the partial less-or-equal test, returning a boolean vector.

let u = Vec4::new(0,2,2,2);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.partial_cmple(&v), Vec4::new(true, false, true, true));

pub fn partial_cmplt<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: PartialOrd,

Compares each element of two vectors with the partial less-than test, returning a boolean vector.

let u = Vec4::new(0,2,2,2);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.partial_cmplt(&v), Vec4::new(false, false, false, true));

pub fn cmpeq<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: Eq,

Compares each element of two vectors with the partial equality test, returning a boolean vector.

let u = Vec4::new(0,2,2,6);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.cmpeq(&v), Vec4::new(true, false, true, false));

pub fn cmpne<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: Eq,

Compares each element of two vectors with the total not-equal test, returning a boolean vector.

let u = Vec4::new(0,2,2,6);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.cmpne(&v), Vec4::new(false, true, false, true));

pub fn cmpge<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: Ord,

Compares each element of two vectors with the total greater-or-equal test, returning a boolean vector.

let u = Vec4::new(0,2,2,2);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.cmpge(&v), Vec4::new(true, true, true, false));

pub fn cmpgt<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: Ord,

Compares each element of two vectors with the total greater-than test, returning a boolean vector.

let u = Vec4::new(0,2,2,6);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.cmpgt(&v), Vec4::new(false, true, false, true));

pub fn cmple<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: Ord,

Compares each element of two vectors with the total less-or-equal test, returning a boolean vector.

let u = Vec4::new(0,2,2,2);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.cmple(&v), Vec4::new(true, false, true, true));

pub fn cmplt<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Extent3<bool> where     T: Ord,

Compares each element of two vectors with the total less-than test, returning a boolean vector.

let u = Vec4::new(0,2,2,2);
let v = Vec4::new(0,1,2,3);
assert_eq!(u.cmplt(&v), Vec4::new(false, false, false, true));

pub fn lerp_unclamped_precise<S: Into<Self>>(     from: Self,     to: Self,     factor: S ) -> Self where     T: Copy + One + Mul<Output = T> + Sub<Output = T> + MulAdd<T, T, Output = T>,

Returns the linear interpolation of from to to with factor unconstrained.
See the Lerp trait.

pub fn lerp_unclamped<S: Into<Self>>(from: Self, to: Self, factor: S) -> Self where     T: Copy + Sub<Output = T> + MulAdd<T, T, Output = T>,

Same as lerp_unclamped_precise, implemented as a possibly faster but less precise operation. See the Lerp trait.

pub fn lerp<S: Into<Self> + Clamp + Zero + One>(     from: Self,     to: Self,     factor: S ) -> Self where     T: Copy + Sub<Output = T> + MulAdd<T, T, Output = T>,

Returns the linear interpolation of from to to with factor constrained to be between 0 and 1.
See the Lerp trait.

pub fn lerp_precise<S: Into<Self> + Clamp + Zero + One>(     from: Self,     to: Self,     factor: S ) -> Self where     T: Copy + One + Mul<Output = T> + Sub<Output = T> + MulAdd<T, T, Output = T>,

Returns the linear interpolation of from to to with factor constrained to be between 0 and 1.
See the Lerp trait.

impl Extent3<bool>

pub fn reduce_and(self) -> bool

Returns the result of logical AND (&&) on all elements of this vector.

assert_eq!(true,  Vec4::new(true, true, true, true).reduce_and());
assert_eq!(false, Vec4::new(true, false, true, true).reduce_and());
assert_eq!(false, Vec4::new(true, true, true, false).reduce_and());

pub fn reduce_or(self) -> bool

Returns the result of logical OR (||) on all elements of this vector.

assert_eq!(false, Vec4::new(false, false, false, false).reduce_or());
assert_eq!(true,  Vec4::new(false, false, true, false).reduce_or());

pub fn reduce_ne(self) -> bool

Reduces this vector using total inequality.

assert_eq!(false, Vec4::new(true, true, true, true).reduce_ne());
assert_eq!(true,  Vec4::new(true, false, true, true).reduce_ne());

impl<T> Extent3<T>

pub fn dot(self, v: Self) -> T where     T: Sum + Mul<Output = T>,

Dot product between this vector and another.

pub fn magnitude_squared(self) -> T where     T: Copy + Sum + Mul<Output = T>,

The squared magnitude of a vector is its spatial length, squared. It is slightly cheaper to compute than magnitude because it avoids a square root.

pub fn magnitude(self) -> T where     T: Sum + Real,

The magnitude of a vector is its spatial length.

pub fn distance_squared(self, v: Self) -> T where     T: Copy + Sum + Sub<Output = T> + Mul<Output = T>,

Squared distance between two point vectors. It is slightly cheaper to compute than distance because it avoids a square root.

pub fn distance(self, v: Self) -> T where     T: Sum + Real,

Distance between two point vectors.

pub fn normalized(self) -> Self where     T: Sum + Real,

Get a copy of this direction vector such that its length equals 1.

pub fn normalize(&mut self) where     T: Sum + Real,

Divide this vector's components such that its length equals 1.

pub fn is_normalized(self) -> bool where     T: ApproxEq + Sum + Real,

Is this vector normalized ? (Uses ApproxEq)

pub fn angle_between(self, v: Self) -> T where     T: Sum + Real,

Get the smallest angle, in radians, between two direction vectors.

pub fn angle_between_degrees(self, v: Self) -> T where     T: From<u16> + Sum + Real,

Get the smallest angle, in degrees, between two direction vectors.

pub fn reflected(self, surface_normal: Self) -> Self where     T: Copy + Sum + Mul<Output = T> + Sub<Output = T> + Add<Output = T>,

The reflection direction for this vector on a surface which normal is given.

pub fn refracted(self, surface_normal: Self, eta: T) -> Self where     T: Real + Sum + Mul<Output = T>,

The refraction vector for this incident vector, a surface normal and a ratio of indices of refraction (eta).

pub fn face_forward(self, incident: Self, reference: Self) -> Self where     T: Sum + Mul<Output = T> + Zero + PartialOrd + Neg<Output = T>,

Orients a vector to point away from a surface as defined by its normal.

Methods from Deref<Target = [T]>

pub const fn len(&self) -> usize

Returns the number of elements in the slice.

Examples

let a = [1, 2, 3];
assert_eq!(a.len(), 3);

pub const fn is_empty(&self) -> bool

Returns true if the slice has a length of 0.

Examples

let a = [1, 2, 3];
assert!(!a.is_empty());

pub fn first(&self) -> Option<&T>

Returns the first element of the slice, or None if it is empty.

Examples

let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());

pub fn first_mut(&mut self) -> Option<&mut T>

Returns a mutable pointer to the first element of the slice, or None if it is empty.

Examples

let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

pub fn split_first(&self) -> Option<(&T, &[T])>

Returns the first and all the rest of the elements of the slice, or None if it is empty.

Examples

let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}

pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>

Returns the first and all the rest of the elements of the slice, or None if it is empty.

Examples

let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_mut() {
    *first = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[3, 4, 5]);

pub fn split_last(&self) -> Option<(&T, &[T])>

Returns the last and all the rest of the elements of the slice, or None if it is empty.

Examples

let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}

pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>

Returns the last and all the rest of the elements of the slice, or None if it is empty.

Examples

let x = &mut [0, 1, 2];

if let Some((last, elements)) = x.split_last_mut() {
    *last = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[4, 5, 3]);

pub fn last(&self) -> Option<&T>

Returns the last element of the slice, or None if it is empty.

Examples

let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());

pub fn last_mut(&mut self) -> Option<&mut T>

Returns a mutable pointer to the last item in the slice.

Examples

let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output> where     I: SliceIndex<[T]>,

Returns a reference to an element or subslice depending on the type of index.

• If given a position, returns a reference to the element at that position or None if out of bounds.
• If given a range, returns the subslice corresponding to that range, or None if out of bounds.

Examples

let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));

pub fn get_mut<I>(     &mut self,     index: I ) -> Option<&mut <I as SliceIndex<[T]>>::Output> where     I: SliceIndex<[T]>,

Returns a mutable reference to an element or subslice depending on the type of index (see get) or None if the index is out of bounds.

Examples

let x = &mut [0, 1, 2];

if let Some(elem) = x.get_mut(1) {
    *elem = 42;
}
assert_eq!(x, &[0, 42, 2]);

pub unsafe fn get_unchecked<I>(     &self,     index: I ) -> &<I as SliceIndex<[T]>>::Output where     I: SliceIndex<[T]>,

Returns a reference to an element or subslice, without doing bounds checking.

This is generally not recommended, use with caution! For a safe alternative see get.

Examples

let x = &[1, 2, 4];

unsafe {
    assert_eq!(x.get_unchecked(1), &2);
}

pub unsafe fn get_unchecked_mut<I>(     &mut self,     index: I ) -> &mut <I as SliceIndex<[T]>>::Output where     I: SliceIndex<[T]>,

Returns a mutable reference to an element or subslice, without doing bounds checking.

This is generally not recommended, use with caution! For a safe alternative see get_mut.

Examples

let x = &mut [1, 2, 4];

unsafe {
    let elem = x.get_unchecked_mut(1);
    *elem = 13;
}
assert_eq!(x, &[1, 13, 4]);

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

Returns a raw pointer to the slice's buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.

Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.

Examples

let x = &[1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(x.get_unchecked(i), &*x_ptr.offset(i as isize));
    }
}

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

Returns an unsafe mutable pointer to the slice's buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.

Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.

Examples

let x = &mut [1, 2, 4];
let x_ptr = x.as_mut_ptr();

unsafe {
    for i in 0..x.len() {
        *x_ptr.offset(i as isize) += 2;
    }
}
assert_eq!(x, &[3, 4, 6]);

pub fn swap(&mut self, a: usize, b: usize)

Swaps two elements in the slice.

Arguments

• a - The index of the first element
• b - The index of the second element

Panics

Panics if a or b are out of bounds.

Examples

let mut v = ["a", "b", "c", "d"];
v.swap(1, 3);
assert!(v == ["a", "d", "c", "b"]);

pub fn reverse(&mut self)

Reverses the order of elements in the slice, in place.

Examples

let mut v = [1, 2, 3];
v.reverse();
assert!(v == [3, 2, 1]);

pub fn iter(&self) -> Iter<T>

Returns an iterator over the slice.

Examples

let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);

pub fn iter_mut(&mut self) -> IterMut<T>

Returns an iterator that allows modifying each value.

Examples

let x = &mut [1, 2, 4];
for elem in x.iter_mut() {
    *elem += 2;
}
assert_eq!(x, &[3, 4, 6]);

pub fn windows(&self, size: usize) -> Windows<T>

Returns an iterator over all contiguous windows of length size. The windows overlap. If the slice is shorter than size, the iterator returns no values.

Panics

Panics if size is 0.

Examples

let slice = ['r', 'u', 's', 't'];
let mut iter = slice.windows(2);
assert_eq!(iter.next().unwrap(), &['r', 'u']);
assert_eq!(iter.next().unwrap(), &['u', 's']);
assert_eq!(iter.next().unwrap(), &['s', 't']);
assert!(iter.next().is_none());

If the slice is shorter than size:

let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());

pub fn chunks(&self, chunk_size: usize) -> Chunks<T>

Returns an iterator over chunk_size elements of the slice at a time. The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See exact_chunks for a variant of this iterator that returns chunks of always exactly chunk_size elements.

Panics

Panics if chunk_size is 0.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.chunks(2);
assert_eq!(iter.next().unwrap(), &['l', 'o']);
assert_eq!(iter.next().unwrap(), &['r', 'e']);
assert_eq!(iter.next().unwrap(), &['m']);
assert!(iter.next().is_none());

pub fn exact_chunks(&self, chunk_size: usize) -> ExactChunks<T>

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

Returns an iterator over chunk_size elements of the slice at a time. The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted.

Due to each chunk having exactly chunk_size elements, the compiler can often optimize the resulting code better than in the case of chunks.

Panics

Panics if chunk_size is 0.

Examples

#![feature(exact_chunks)]

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.exact_chunks(2);
assert_eq!(iter.next().unwrap(), &['l', 'o']);
assert_eq!(iter.next().unwrap(), &['r', 'e']);
assert!(iter.next().is_none());

pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T>

Returns an iterator over chunk_size elements of the slice at a time. The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See exact_chunks_mut for a variant of this iterator that returns chunks of always exactly chunk_size elements.

Panics

Panics if chunk_size is 0.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.chunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 3]);

pub fn exact_chunks_mut(&mut self, chunk_size: usize) -> ExactChunksMut<T>

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

Returns an iterator over chunk_size elements of the slice at a time. The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted.

Due to each chunk having exactly chunk_size elements, the compiler can often optimize the resulting code better than in the case of chunks_mut.

Panics

Panics if chunk_size is 0.

Examples

#![feature(exact_chunks)]

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.exact_chunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 0]);

pub fn split_at(&self, mid: usize) -> (&[T], &[T])

Divides one slice into two at an index.

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

Panics

Panics if mid > len.

Examples

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

{
   let (left, right) = v.split_at(0);
   assert!(left == []);
   assert!(right == [1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_at(2);
    assert!(left == [1, 2]);
    assert!(right == [3, 4, 5, 6]);
}

{
    let (left, right) = v.split_at(6);
    assert!(left == [1, 2, 3, 4, 5, 6]);
    assert!(right == []);
}

pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])

Divides one mutable slice into two at an index.

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

Panics

Panics if mid > len.

Examples

let mut v = [1, 0, 3, 0, 5, 6];
// scoped to restrict the lifetime of the borrows
{
    let (left, right) = v.split_at_mut(2);
    assert!(left == [1, 0]);
    assert!(right == [3, 0, 5, 6]);
    left[1] = 2;
    right[1] = 4;
}
assert!(v == [1, 2, 3, 4, 5, 6]);

pub fn split<F>(&self, pred: F) -> Split<T, F> where     F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred. The matched element is not contained in the subslices.

Examples

let slice = [10, 40, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

If the first element is matched, an empty slice will be the first item returned by the iterator. Similarly, if the last element in the slice is matched, an empty slice will be the last item returned by the iterator:

let slice = [10, 40, 33];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[]);
assert!(iter.next().is_none());

If two matched elements are directly adjacent, an empty slice will be present between them:

let slice = [10, 6, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10]);
assert_eq!(iter.next().unwrap(), &[]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F> where     F: FnMut(&T) -> bool,

Returns an iterator over mutable subslices separated by elements that match pred. The matched element is not contained in the subslices.

Examples

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.split_mut(|num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(v, [1, 40, 30, 1, 60, 1]);

pub fn rsplit<F>(&self, pred: F) -> RSplit<T, F> where     F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.

Examples

let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);

As with split(), if the first or last element is matched, an empty slice will be the first (or last) item returned by the iterator.

let v = &[0, 1, 1, 2, 3, 5, 8];
let mut it = v.rsplit(|n| *n % 2 == 0);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next().unwrap(), &[3, 5]);
assert_eq!(it.next().unwrap(), &[1, 1]);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next(), None);

pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<T, F> where     F: FnMut(&T) -> bool,

Returns an iterator over mutable subslices separated by elements that match pred, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.

Examples

let mut v = [100, 400, 300, 200, 600, 500];

let mut count = 0;
for group in v.rsplit_mut(|num| *num % 3 == 0) {
    count += 1;
    group[0] = count;
}
assert_eq!(v, [3, 400, 300, 2, 600, 1]);

pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F> where     F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred, limited to returning at most n items. The matched element is not contained in the subslices.

The last element returned, if any, will contain the remainder of the slice.

Examples

Print the slice split once by numbers divisible by 3 (i.e. [10, 40], [20, 60, 50]):

let v = [10, 40, 30, 20, 60, 50];

for group in v.splitn(2, |num| *num % 3 == 0) {
    println!("{:?}", group);
}

pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F> where     F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred, limited to returning at most n items. The matched element is not contained in the subslices.

The last element returned, if any, will contain the remainder of the slice.

Examples

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.splitn_mut(2, |num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(v, [1, 40, 30, 1, 60, 50]);

pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F> where     F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred limited to returning at most n items. This starts at the end of the slice and works backwards. The matched element is not contained in the subslices.

The last element returned, if any, will contain the remainder of the slice.

Examples

Print the slice split once, starting from the end, by numbers divisible by 3 (i.e. [50], [10, 40, 30, 20]):

let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{:?}", group);
}

pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F> where     F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred limited to returning at most n items. This starts at the end of the slice and works backwards. The matched element is not contained in the subslices.

The last element returned, if any, will contain the remainder of the slice.

Examples

let mut s = [10, 40, 30, 20, 60, 50];

for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(s, [1, 40, 30, 20, 60, 1]);

pub fn contains(&self, x: &T) -> bool where     T: PartialEq<T>,

Returns true if the slice contains an element with the given value.

Examples

let v = [10, 40, 30];
assert!(v.contains(&30));
assert!(!v.contains(&50));

pub fn starts_with(&self, needle: &[T]) -> bool where     T: PartialEq<T>,

Returns true if needle is a prefix of the slice.

Examples

let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));

Always returns true if needle is an empty slice:

let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));

pub fn ends_with(&self, needle: &[T]) -> bool where     T: PartialEq<T>,

Returns true if needle is a suffix of the slice.

Examples

let v = [10, 40, 30];
assert!(v.ends_with(&[30]));
assert!(v.ends_with(&[40, 30]));
assert!(!v.ends_with(&[50]));
assert!(!v.ends_with(&[50, 30]));

Always returns true if needle is an empty slice:

let v = &[10, 40, 30];
assert!(v.ends_with(&[]));
let v: &[u8] = &[];
assert!(v.ends_with(&[]));

pub fn binary_search(&self, x: &T) -> Result<usize, usize> where     T: Ord,

Binary searches this sorted slice for a given element.

If the value is found then Ok is returned, containing the index of the matching element; if the value is not found then Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

Examples

Looks up a series of four elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r { Ok(1...4) => true, _ => false, });

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize> where     F: FnMut(&'a T) -> Ordering,

Binary searches this sorted slice with a comparator function.

The comparator function should implement an order consistent with the sort order of the underlying slice, returning an order code that indicates whether its argument is Less, Equal or Greater the desired target.

If a matching value is found then returns Ok, containing the index for the matched element; if no match is found then Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

Examples

Looks up a series of four elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let seek = 13;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
let seek = 4;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
let seek = 100;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
let seek = 1;
let r = s.binary_search_by(|probe| probe.cmp(&seek));
assert!(match r { Ok(1...4) => true, _ => false, });

pub fn binary_search_by_key<'a, B, F>(     &'a self,     b: &B,     f: F ) -> Result<usize, usize> where     B: Ord,     F: FnMut(&'a T) -> B,

Binary searches this sorted slice with a key extraction function.

Assumes that the slice is sorted by the key, for instance with sort_by_key using the same key extraction function.

If a matching value is found then returns Ok, containing the index for the matched element; if no match is found then Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

Examples

Looks up a series of four elements in a slice of pairs sorted by their second elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a,b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a,b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a,b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a,b)| b);
assert!(match r { Ok(1...4) => true, _ => false, });

pub fn sort_unstable(&mut self) where     T: Ord,

Sorts the slice, but may not preserve the order of equal elements.

This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate), and O(n log n) worst-case.

Current implementation

The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.

It is typically faster than stable sorting, except in a few special cases, e.g. when the slice consists of several concatenated sorted sequences.

Examples

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

v.sort_unstable();
assert!(v == [-5, -3, 1, 2, 4]);

pub fn sort_unstable_by<F>(&mut self, compare: F) where     F: FnMut(&T, &T) -> Ordering,

Sorts the slice with a comparator function, but may not preserve the order of equal elements.

This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate), and O(n log n) worst-case.

Current implementation

The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.

It is typically faster than stable sorting, except in a few special cases, e.g. when the slice consists of several concatenated sorted sequences.

Examples

let mut v = [5, 4, 1, 3, 2];
v.sort_unstable_by(|a, b| a.cmp(b));
assert!(v == [1, 2, 3, 4, 5]);

// reverse sorting
v.sort_unstable_by(|a, b| b.cmp(a));
assert!(v == [5, 4, 3, 2, 1]);

pub fn sort_unstable_by_key<K, F>(&mut self, f: F) where     F: FnMut(&T) -> K,     K: Ord,

Sorts the slice with a key extraction function, but may not preserve the order of equal elements.

This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate), and O(m n log(m n)) worst-case, where the key function is O(m).

Current implementation

The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.

Examples

let mut v = [-5i32, 4, 1, -3, 2];

v.sort_unstable_by_key(|k| k.abs());
assert!(v == [1, 2, -3, 4, -5]);

pub fn rotate_left(&mut self, mid: usize)

Rotates the slice in-place such that the first mid elements of the slice move to the end while the last self.len() - mid elements move to the front. After calling rotate_left, the element previously at index mid will become the first element in the slice.

Panics

This function will panic if mid is greater than the length of the slice. Note that mid == self.len() does not panic and is a no-op rotation.

Complexity

Takes linear (in self.len()) time.

Examples

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.rotate_left(2);
assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);

Rotating a subslice:

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a[1..5].rotate_left(1);
assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);

pub fn rotate_right(&mut self, k: usize)

Rotates the slice in-place such that the first self.len() - k elements of the slice move to the end while the last k elements move to the front. After calling rotate_right, the element previously at index self.len() - k will become the first element in the slice.

Panics

This function will panic if k is greater than the length of the slice. Note that k == self.len() does not panic and is a no-op rotation.

Complexity

Takes linear (in self.len()) time.

Examples

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.rotate_right(2);
assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);

Rotate a subslice:

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a[1..5].rotate_right(1);
assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);

pub fn clone_from_slice(&mut self, src: &[T]) where     T: Clone,

Copies the elements from src into self.

The length of src must be the same as self.

If src implements Copy, it can be more performant to use copy_from_slice.

Panics

This function will panic if the two slices have different lengths.

Examples

Cloning two elements from a slice into another:

let src = [1, 2, 3, 4];
let mut dst = [0, 0];

dst.clone_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);

Rust enforces that there can only be one mutable reference with no immutable references to a particular piece of data in a particular scope. Because of this, attempting to use clone_from_slice on a single slice will result in a compile failure:

let mut slice = [1, 2, 3, 4, 5];

slice[..2].clone_from_slice(&slice[3..]); // compile fail!

To work around this, we can use split_at_mut to create two distinct sub-slices from a slice:

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.clone_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);

pub fn copy_from_slice(&mut self, src: &[T]) where     T: Copy,

Copies all elements from src into self, using a memcpy.

The length of src must be the same as self.

If src does not implement Copy, use clone_from_slice.

Panics

This function will panic if the two slices have different lengths.

Examples

Copying two elements from a slice into another:

let src = [1, 2, 3, 4];
let mut dst = [0, 0];

dst.copy_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);

Rust enforces that there can only be one mutable reference with no immutable references to a particular piece of data in a particular scope. Because of this, attempting to use copy_from_slice on a single slice will result in a compile failure:

let mut slice = [1, 2, 3, 4, 5];

slice[..2].copy_from_slice(&slice[3..]); // compile fail!

To work around this, we can use split_at_mut to create two distinct sub-slices from a slice:

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.copy_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);

pub fn swap_with_slice(&mut self, other: &mut [T])

Swaps all elements in self with those in other.

The length of other must be the same as self.

Panics

This function will panic if the two slices have different lengths.

Example

Swapping two elements across slices:

let mut slice1 = [0, 0];
let mut slice2 = [1, 2, 3, 4];

slice1.swap_with_slice(&mut slice2[2..]);

assert_eq!(slice1, [3, 4]);
assert_eq!(slice2, [1, 2, 0, 0]);

Rust enforces that there can only be one mutable reference to a particular piece of data in a particular scope. Because of this, attempting to use swap_with_slice on a single slice will result in a compile failure:

let mut slice = [1, 2, 3, 4, 5];
slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!

To work around this, we can use split_at_mut to create two distinct mutable sub-slices from a slice:

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.swap_with_slice(&mut right[1..]);
}

assert_eq!(slice, [4, 5, 3, 1, 2]);

pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])

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

Transmute the slice to a slice of another type, ensuring aligment of the types is maintained.

This method splits the slice into three distinct slices: prefix, correctly aligned middle slice of a new type, and the suffix slice. The middle slice will have the greatest length possible for a given type and input slice.

This method has no purpose when either input element T or output element U are zero-sized and will return the original slice without splitting anything.

Unsafety

This method is essentially a transmute with respect to the elements in the returned middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

Examples

Basic usage:

unsafe {
    let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
    let (prefix, shorts, suffix) = bytes.align_to::<u16>();
    // less_efficient_algorithm_for_bytes(prefix);
    // more_efficient_algorithm_for_aligned_shorts(shorts);
    // less_efficient_algorithm_for_bytes(suffix);
}

pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])

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

Transmute the slice to a slice of another type, ensuring aligment of the types is maintained.

This method splits the slice into three distinct slices: prefix, correctly aligned middle slice of a new type, and the suffix slice. The middle slice will have the greatest length possible for a given type and input slice.

This method has no purpose when either input element T or output element U are zero-sized and will return the original slice without splitting anything.

Unsafety

This method is essentially a transmute with respect to the elements in the returned middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

Examples

Basic usage:

unsafe {
    let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
    let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>();
    // less_efficient_algorithm_for_bytes(prefix);
    // more_efficient_algorithm_for_aligned_shorts(shorts);
    // less_efficient_algorithm_for_bytes(suffix);
}

Trait Implementations

impl<T> From<Extent3<T>> for Vec3<T>

fn from(v: Extent3<T>) -> Self

Performs the conversion.

impl<T: Debug> Debug for Extent3<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Extent3<T>

fn default() -> Extent3<T>

Returns the "default value" for a type.

impl<T: Clone> Clone for Extent3<T>

fn clone(&self) -> Extent3<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Extent3<T>

impl<T: Hash> Hash for Extent3<T>

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

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<T: Eq> Eq for Extent3<T>

impl<T: PartialEq> PartialEq for Extent3<T>

fn eq(&self, other: &Extent3<T>) -> bool

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

fn ne(&self, other: &Extent3<T>) -> bool

This method tests for !=.

impl<T: Display> Display for Extent3<T>

Displays the vector, formatted as ({}, {}, {}).

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

Formats the value using the given formatter.

impl<T, Factor> Lerp<Factor> for Extent3<T> where     T: Lerp<Factor, Output = T>,     Factor: Copy,

type Output = Self

The resulting type after performing the LERP operation.

fn lerp_unclamped_precise(from: Self, to: Self, factor: Factor) -> Self

Returns the linear interpolation of from to to with factor unconstrained, using a possibly slower but more precise operation.

fn lerp_unclamped(from: Self, to: Self, factor: Factor) -> Self

Returns the linear interpolation of from to to with factor unconstrained, using the supposedly fastest but less precise implementation.

fn lerp(from: Self, to: Self, factor: Factor) -> Self::Output where     Factor: Clamp + Zero + One,

Alias to lerp_unclamped which constrains factor to be between 0 and 1 (inclusive).

fn lerp_precise(from: Self, to: Self, factor: Factor) -> Self::Output where     Factor: Clamp + Zero + One,

Alias to lerp_unclamped_precise which constrains factor to be between 0 and 1 (inclusive).

impl<'a, T, Factor> Lerp<Factor> for &'a Extent3<T> where     &'a T: Lerp<Factor, Output = T>,     Factor: Copy,

type Output = Extent3<T>

The resulting type after performing the LERP operation.

fn lerp_unclamped_precise(from: Self, to: Self, factor: Factor) -> Extent3<T>

Returns the linear interpolation of from to to with factor unconstrained, using a possibly slower but more precise operation.

fn lerp_unclamped(from: Self, to: Self, factor: Factor) -> Extent3<T>

Returns the linear interpolation of from to to with factor unconstrained, using the supposedly fastest but less precise implementation.

fn lerp(from: Self, to: Self, factor: Factor) -> Self::Output where     Factor: Clamp + Zero + One,

Alias to lerp_unclamped which constrains factor to be between 0 and 1 (inclusive).

fn lerp_precise(from: Self, to: Self, factor: Factor) -> Self::Output where     Factor: Clamp + Zero + One,

Alias to lerp_unclamped_precise which constrains factor to be between 0 and 1 (inclusive).

impl<T: Wrap + Copy> Wrap<T> for Extent3<T>

fn wrapped(self, upper: T) -> Self

Returns this value, wrapped between zero and some upper bound (both inclusive).

fn wrapped_between(self, lower: T, upper: T) -> Self

Returns this value, wrapped between lower (inclusive) and upper (exclusive).

fn pingpong(self, upper: T) -> Self

Wraps a value such that it goes back and forth from zero to upper (inclusive) as it increases.

fn wrap(val: Self, upper: Bound) -> Self

Alias to wrapped() which doesn't take self.

fn wrapped_2pi(self) -> Self where     Bound: FloatConst + Add<Output = Bound>,

Returns this value, wrapped between zero and two times 𝛑 (inclusive).

fn wrap_2pi(val: Self) -> Self where     Bound: FloatConst + Add<Output = Bound>,

Alias to wrapped_2pi which doesn't take self.

fn wrap_between(val: Self, lower: Bound, upper: Bound) -> Self where     Self: Sub<Output = Self> + Add<Output = Self> + From<Bound>,     Bound: Copy + Sub<Output = Bound> + PartialOrd,

Alias to wrapped_between which doesn't take self.

fn delta_angle(self, target: Self) -> Self where     Self: From<Bound> + Sub<Output = Self> + PartialOrd,     Bound: FloatConst + Add<Output = Bound>,

Calculates the shortest difference between two given angles, in radians.

fn delta_angle_degrees(self, target: Self) -> Self where     Self: From<Bound> + Sub<Output = Self> + PartialOrd,     Bound: From<u16>,

Calculates the shortest difference between two given angles, in degrees.

impl<T: Wrap> Wrap<Extent3<T>> for Extent3<T>

fn wrapped(self, upper: Extent3<T>) -> Self

Returns this value, wrapped between zero and some upper bound (both inclusive).

fn wrapped_between(self, lower: Self, upper: Self) -> Self

Returns this value, wrapped between lower (inclusive) and upper (exclusive).

fn pingpong(self, upper: Self) -> Self

Wraps a value such that it goes back and forth from zero to upper (inclusive) as it increases.

fn wrap(val: Self, upper: Bound) -> Self

Alias to wrapped() which doesn't take self.

fn wrapped_2pi(self) -> Self where     Bound: FloatConst + Add<Output = Bound>,

Returns this value, wrapped between zero and two times 𝛑 (inclusive).

fn wrap_2pi(val: Self) -> Self where     Bound: FloatConst + Add<Output = Bound>,

Alias to wrapped_2pi which doesn't take self.

fn wrap_between(val: Self, lower: Bound, upper: Bound) -> Self where     Self: Sub<Output = Self> + Add<Output = Self> + From<Bound>,     Bound: Copy + Sub<Output = Bound> + PartialOrd,

Alias to wrapped_between which doesn't take self.

fn delta_angle(self, target: Self) -> Self where     Self: From<Bound> + Sub<Output = Self> + PartialOrd,     Bound: FloatConst + Add<Output = Bound>,

Calculates the shortest difference between two given angles, in radians.

fn delta_angle_degrees(self, target: Self) -> Self where     Self: From<Bound> + Sub<Output = Self> + PartialOrd,     Bound: From<u16>,

Calculates the shortest difference between two given angles, in degrees.

impl<T: Clamp + Copy> Clamp<T> for Extent3<T>

fn clamped(self, lower: T, upper: T) -> Self

Constrains this value to be between lower and upper (inclusive).

fn clamp(val: Self, lower: Bound, upper: Bound) -> Self

Alias to clamped, which doesn't take self.

fn clamped01(self) -> Self where     Bound: Zero + One,

Constrains this value to be between 0 and 1 (inclusive).

fn clamp01(val: Self) -> Self where     Bound: Zero + One,

Alias to clamped01, which doesn't take self.

impl<T: IsBetween<Output = bool> + Copy> IsBetween<T> for Extent3<T>

type Output = Extent3<bool>

bool for scalars, or vector of bools for vectors.

fn is_between(self, lower: T, upper: T) -> Self::Output

Returns whether this value is between lower and upper (inclusive).

fn is_between01(self) -> Self::Output where     Bound: Zero + One,

Returns whether this value is between 0 and 1 (inclusive).

impl<T: Clamp> Clamp<Extent3<T>> for Extent3<T>

fn clamped(self, lower: Self, upper: Self) -> Self

Constrains this value to be between lower and upper (inclusive).

fn clamp(val: Self, lower: Bound, upper: Bound) -> Self

Alias to clamped, which doesn't take self.

fn clamped01(self) -> Self where     Bound: Zero + One,

Constrains this value to be between 0 and 1 (inclusive).

fn clamp01(val: Self) -> Self where     Bound: Zero + One,

Alias to clamped01, which doesn't take self.

impl<T: IsBetween<Output = bool>> IsBetween<Extent3<T>> for Extent3<T>

type Output = Extent3<bool>

bool for scalars, or vector of bools for vectors.

fn is_between(self, lower: Self, upper: Self) -> Self::Output

Returns whether this value is between lower and upper (inclusive).

fn is_between01(self) -> Self::Output where     Bound: Zero + One,

Returns whether this value is between 0 and 1 (inclusive).

impl<T: Zero + PartialEq> Zero for Extent3<T>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

impl<T: One> One for Extent3<T>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool where     Self: PartialEq<Self>,

Returns true if self is equal to the multiplicative identity.

impl<T: ApproxEq> ApproxEq for Extent3<T> where     T::Epsilon: Copy,

type Epsilon = T::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> T::Epsilon

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

fn default_max_relative() -> T::Epsilon

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

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

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

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

fn ulps_eq(&self, other: &Self, epsilon: T::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

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

The inverse of ApproxEq::relative_eq.

fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl<T> MulAdd<Extent3<T>, Extent3<T>> for Extent3<T> where     T: MulAdd<T, T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the fused multiply-add operation.

fn mul_add(self, a: Extent3<T>, b: Extent3<T>) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

impl<'c, T> MulAdd<Extent3<T>, Extent3<T>> for &'c Extent3<T> where     &'c T: MulAdd<T, T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the fused multiply-add operation.

fn mul_add(self, a: Extent3<T>, b: Extent3<T>) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

impl<'b, T> MulAdd<Extent3<T>, &'b Extent3<T>> for Extent3<T> where     T: MulAdd<T, &'b T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the fused multiply-add operation.

fn mul_add(self, a: Extent3<T>, b: &'b Extent3<T>) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

impl<'b, 'c, T> MulAdd<Extent3<T>, &'b Extent3<T>> for &'c Extent3<T> where     &'c T: MulAdd<T, &'b T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the fused multiply-add operation.

fn mul_add(self, a: Extent3<T>, b: &'b Extent3<T>) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

impl<'a, T> MulAdd<&'a Extent3<T>, Extent3<T>> for Extent3<T> where     T: MulAdd<&'a T, T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the fused multiply-add operation.

fn mul_add(self, a: &'a Extent3<T>, b: Extent3<T>) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

impl<'a, 'c, T> MulAdd<&'a Extent3<T>, Extent3<T>> for &'c Extent3<T> where     &'c T: MulAdd<&'a T, T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the fused multiply-add operation.

fn mul_add(self, a: &'a Extent3<T>, b: Extent3<T>) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

impl<'a, 'b, T> MulAdd<&'a Extent3<T>, &'b Extent3<T>> for Extent3<T> where     T: MulAdd<&'a T, &'b T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the fused multiply-add operation.

fn mul_add(self, a: &'a Extent3<T>, b: &'b Extent3<T>) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

impl<'a, 'b, 'c, T> MulAdd<&'a Extent3<T>, &'b Extent3<T>> for &'c Extent3<T> where     &'c T: MulAdd<&'a T, &'b T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the fused multiply-add operation.

fn mul_add(self, a: &'a Extent3<T>, b: &'b Extent3<T>) -> Self::Output

Returns (self * mul) + add as a possibly faster and more precise single operation.

impl<T> Neg for Extent3<T> where     T: Neg<Output = T>,

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<V, T> Add<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: Add<T, Output = T>,

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T> Add<&'a Extent3<T>> for Extent3<T> where     T: Add<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the + operation.

impl<'a, T> Add<Extent3<T>> for &'a Extent3<T> where     &'a T: Add<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, T> Add<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: Add<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the + operation.

impl<'a, T> Add<T> for &'a Extent3<T> where     &'a T: Add<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, T> Add<&'a T> for &'b Extent3<T> where     &'b T: Add<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the + operator.

fn add(self, rhs: &'a T) -> Self::Output

Performs the + operation.

impl<V, T> Sub<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: Sub<T, Output = T>,

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T> Sub<&'a Extent3<T>> for Extent3<T> where     T: Sub<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the - operation.

impl<'a, T> Sub<Extent3<T>> for &'a Extent3<T> where     &'a T: Sub<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T> Sub<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: Sub<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the - operation.

impl<'a, T> Sub<T> for &'a Extent3<T> where     &'a T: Sub<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, T> Sub<&'a T> for &'b Extent3<T> where     &'b T: Sub<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a T) -> Self::Output

Performs the - operation.

impl<V, T> Mul<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: Mul<T, Output = T>,

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> Mul<&'a Extent3<T>> for Extent3<T> where     T: Mul<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the * operation.

impl<'a, T> Mul<Extent3<T>> for &'a Extent3<T> where     &'a T: Mul<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: Mul<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the * operation.

impl<'a, T> Mul<T> for &'a Extent3<T> where     &'a T: Mul<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, T> Mul<&'a T> for &'b Extent3<T> where     &'b T: Mul<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<V, T> Div<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: Div<T, Output = T>,

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T> Div<&'a Extent3<T>> for Extent3<T> where     T: Div<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the / operation.

impl<'a, T> Div<Extent3<T>> for &'a Extent3<T> where     &'a T: Div<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, T> Div<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: Div<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the / operation.

impl<'a, T> Div<T> for &'a Extent3<T> where     &'a T: Div<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, T> Div<&'a T> for &'b Extent3<T> where     &'b T: Div<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<V, T> Rem<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: Rem<T, Output = T>,

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: V) -> Self::Output

Performs the % operation.

impl<'a, T> Rem<&'a Extent3<T>> for Extent3<T> where     T: Rem<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the % operation.

impl<'a, T> Rem<Extent3<T>> for &'a Extent3<T> where     &'a T: Rem<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Extent3<T>) -> Self::Output

Performs the % operation.

impl<'a, 'b, T> Rem<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: Rem<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the % operation.

impl<'a, T> Rem<T> for &'a Extent3<T> where     &'a T: Rem<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a, 'b, T> Rem<&'a T> for &'b Extent3<T> where     &'b T: Rem<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a T) -> Self::Output

Performs the % operation.

impl<V, T> AddAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: AddAssign<T>,

fn add_assign(&mut self, rhs: V)

Performs the += operation.

impl<V, T> SubAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: SubAssign<T>,

fn sub_assign(&mut self, rhs: V)

Performs the -= operation.

impl<V, T> MulAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: MulAssign<T>,

fn mul_assign(&mut self, rhs: V)

Performs the *= operation.

impl<V, T> DivAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: DivAssign<T>,

fn div_assign(&mut self, rhs: V)

Performs the /= operation.

impl<V, T> RemAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: RemAssign<T>,

fn rem_assign(&mut self, rhs: V)

Performs the %= operation.

impl<V, T> Shl<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: Shl<T, Output = T>,

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: V) -> Self::Output

Performs the << operation.

impl<'a, T> Shl<&'a Extent3<T>> for Extent3<T> where     T: Shl<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the << operation.

impl<'a, T> Shl<Extent3<T>> for &'a Extent3<T> where     &'a T: Shl<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the << operator.

fn shl(self, rhs: Extent3<T>) -> Self::Output

Performs the << operation.

impl<'a, 'b, T> Shl<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: Shl<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the << operation.

impl<'a, T> Shl<T> for &'a Extent3<T> where     &'a T: Shl<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'a, 'b, T> Shl<&'a T> for &'b Extent3<T> where     &'b T: Shl<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a T) -> Self::Output

Performs the << operation.

impl<V, T> Shr<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: Shr<T, Output = T>,

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: V) -> Self::Output

Performs the >> operation.

impl<'a, T> Shr<&'a Extent3<T>> for Extent3<T> where     T: Shr<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the >> operation.

impl<'a, T> Shr<Extent3<T>> for &'a Extent3<T> where     &'a T: Shr<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the >> operator.

fn shr(self, rhs: Extent3<T>) -> Self::Output

Performs the >> operation.

impl<'a, 'b, T> Shr<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: Shr<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the >> operation.

impl<'a, T> Shr<T> for &'a Extent3<T> where     &'a T: Shr<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a, 'b, T> Shr<&'a T> for &'b Extent3<T> where     &'b T: Shr<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a T) -> Self::Output

Performs the >> operation.

impl<V, T> ShlAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: ShlAssign<T>,

fn shl_assign(&mut self, rhs: V)

Performs the <<= operation.

impl<V, T> ShrAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: ShrAssign<T>,

fn shr_assign(&mut self, rhs: V)

Performs the >>= operation.

impl<V, T> BitAnd<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: BitAnd<T, Output = T>,

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: V) -> Self::Output

Performs the & operation.

impl<'a, T> BitAnd<&'a Extent3<T>> for Extent3<T> where     T: BitAnd<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the & operation.

impl<'a, T> BitAnd<Extent3<T>> for &'a Extent3<T> where     &'a T: BitAnd<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: Extent3<T>) -> Self::Output

Performs the & operation.

impl<'a, 'b, T> BitAnd<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: BitAnd<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the & operation.

impl<'a, T> BitAnd<T> for &'a Extent3<T> where     &'a T: BitAnd<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b, T> BitAnd<&'a T> for &'b Extent3<T> where     &'b T: BitAnd<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a T) -> Self::Output

Performs the & operation.

impl<V, T> BitOr<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: BitOr<T, Output = T>,

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: V) -> Self::Output

Performs the | operation.

impl<'a, T> BitOr<&'a Extent3<T>> for Extent3<T> where     T: BitOr<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the | operation.

impl<'a, T> BitOr<Extent3<T>> for &'a Extent3<T> where     &'a T: BitOr<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: Extent3<T>) -> Self::Output

Performs the | operation.

impl<'a, 'b, T> BitOr<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: BitOr<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the | operation.

impl<'a, T> BitOr<T> for &'a Extent3<T> where     &'a T: BitOr<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b, T> BitOr<&'a T> for &'b Extent3<T> where     &'b T: BitOr<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a T) -> Self::Output

Performs the | operation.

impl<V, T> BitXor<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: BitXor<T, Output = T>,

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: V) -> Self::Output

Performs the ^ operation.

impl<'a, T> BitXor<&'a Extent3<T>> for Extent3<T> where     T: BitXor<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the ^ operation.

impl<'a, T> BitXor<Extent3<T>> for &'a Extent3<T> where     &'a T: BitXor<T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Extent3<T>) -> Self::Output

Performs the ^ operation.

impl<'a, 'b, T> BitXor<&'a Extent3<T>> for &'b Extent3<T> where     &'b T: BitXor<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Extent3<T>) -> Self::Output

Performs the ^ operation.

impl<'a, T> BitXor<T> for &'a Extent3<T> where     &'a T: BitXor<T, Output = T>,     T: Copy,

type Output = Extent3<T>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b, T> BitXor<&'a T> for &'b Extent3<T> where     &'b T: BitXor<&'a T, Output = T>,

type Output = Extent3<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a T) -> Self::Output

Performs the ^ operation.

impl<V, T> BitAndAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: BitAndAssign<T>,

fn bitand_assign(&mut self, rhs: V)

Performs the &= operation.

impl<V, T> BitOrAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: BitOrAssign<T>,

fn bitor_assign(&mut self, rhs: V)

Performs the |= operation.

impl<V, T> BitXorAssign<V> for Extent3<T> where     V: Into<Extent3<T>>,     T: BitXorAssign<T>,

fn bitxor_assign(&mut self, rhs: V)

Performs the ^= operation.

impl<T> Not for Extent3<T> where     T: Not<Output = T>,

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> AsRef<[T]> for Extent3<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T> AsMut<[T]> for Extent3<T>

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<T> Borrow<[T]> for Extent3<T>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<T> BorrowMut<[T]> for Extent3<T>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<T> AsRef<Extent3<T>> for Extent3<T>

fn as_ref(&self) -> &Self

Performs the conversion.

impl<T> AsMut<Extent3<T>> for Extent3<T>

fn as_mut(&mut self) -> &mut Self

Performs the conversion.

impl<'a, T> IntoIterator for &'a Extent3<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut Extent3<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> Deref for Extent3<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<T> DerefMut for Extent3<T>

fn deref_mut(&mut self) -> &mut [T]

Mutably dereferences the value.

impl<T> IntoIterator for Extent3<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Default> FromIterator<T> for Extent3<T>

fn from_iter<I>(iter: I) -> Self where     I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<T> From<(T, T, T)> for Extent3<T>

fn from(tuple: (T, T, T)) -> Self

Performs the conversion.

impl<T> From<[T; 3]> for Extent3<T>

fn from(array: [T; 3]) -> Self

Performs the conversion.

impl<T: Copy> From<T> for Extent3<T>

A vector can be obtained from a single scalar by broadcasting it.

This conversion is important because it allows scalars to be smoothly accepted as operands in most vector operations.

For instance :

assert_eq!(Vec4::min(4, 5), Vec4::broadcast(4));
assert_eq!(Vec4::max(4, 5), Vec4::broadcast(5));
assert_eq!(Vec4::from(4), Vec4::broadcast(4));
assert_eq!(Vec4::from(4).mul_add(4, 5), Vec4::broadcast(21));

// scaling_3d() logically accepts a Vec3...
let _ = Mat4::<f32>::scaling_3d(Vec3::broadcast(5.0));
// ... but there you go; quick uniform scale, thanks to Into !
let _ = Mat4::scaling_3d(5_f32);

On the other hand, it also allows writing nonsense.
To minimize surprises, the names of operations try to be as explicit as possible.

// This creates a matrix that translates to (5,5,5), but it's probably not what you meant.
// Hopefully the `_3d` suffix would help you catch this.
let _ = Mat4::translation_3d(5_f32);
// translation_3d() takes V: Into<Vec3> because it allows it to accept
// Vec2, Vec3 and Vec4, and also with both repr(C) and repr(simd) layouts.

fn from(val: T) -> Self

Performs the conversion.

impl<T> From<Vec3<T>> for Extent3<T>

fn from(v: Vec3<T>) -> Self

Performs the conversion.