Struct vek::vec::repr_c::rgba::Rgba [−] [src]

#[repr(C)]
pub struct Rgba<T> {
    pub r: T,
    pub g: T,
    pub b: T,
    pub a: T,
}

Vector type suited for RGBA color data.

There is no trait bound on ColorComponent, but if T doesn't implement it, you'll miss some goodies.

Fields

r: T g: T b: T a: T

Methods

`impl<T> Rgba<T>`
[src]

`fn new(r: T, g: T, b: T, a: T) -> Self`
[src]

Creates a vector from elements.

`impl<T> Rgba<T>`
[src]

`fn broadcast(val: T) -> Self where T: Copy,`
[src]

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));

`fn zero() -> Self where T: Zero,`
[src]

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));

`fn one() -> Self where T: One,`
[src]

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));

`fn iota() -> Self where T: Zero + One + AddAssign + Copy,`
[src]

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));

`fn elem_count(&self) -> usize`
[src]

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);

`fn into_tuple(self) -> (T, T, T, T)`
[src]

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

`fn into_array(self) -> [T; 4]`
[src]

Converts this vector into a fixed-size array.

`fn as_slice(&self) -> &[T]`
[src]

View this vector as an immutable slice.

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

View this vector as a mutable slice.

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

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

`fn map<D, F>(self, f: F) -> Rgba<D> where F: FnMut(T) -> D,`
[src]

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));

`fn numcast<D>(self) -> Option<Rgba<D>> where T: NumCast, D: NumCast,`
[src]

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));

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

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));

`fn is_any_negative(&self) -> bool where T: Signed,`
[src]

Is any of the elements negative ?

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

`fn are_all_positive(&self) -> bool where T: Signed,`
[src]

Are all of the elements positive ?

`fn min<V>(a: V, b: V) -> Self where V: Into<Self>, T: Ord,`
[src]

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));

`fn max<V>(a: V, b: V) -> Self where V: Into<Self>, T: Ord,`
[src]

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));

`fn partial_min<V>(a: V, b: V) -> Self where V: Into<Self>, T: Ord,`
[src]

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));

`fn partial_max<V>(a: V, b: V) -> Self where V: Into<Self>, T: Ord,`
[src]

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));

`fn reduce_min(self) -> T where T: Ord,`
[src]

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());

`fn reduce_max(self) -> T where T: Ord,`
[src]

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());

`fn reduce_partial_min(self) -> T where T: PartialOrd,`
[src]

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());

`fn reduce_partial_max(self) -> T where T: PartialOrd,`
[src]

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());

`fn product(self) -> T where T: Product,`
[src]

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

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

`fn sum(self) -> T where T: Sum,`
[src]

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

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

`fn average(self) -> T where T: Sum + Div<T, Output = T> + From<u8>,`
[src]

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);

`fn sqrt(self) -> Self where T: Float,`
[src]

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());

`fn rsqrt(self) -> Self where T: Float,`
[src]

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());

`fn recip(self) -> Self where T: Float,`
[src]

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());

`fn ceil(self) -> Self where T: Float,`
[src]

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));

`fn floor(self) -> Self where T: Float,`
[src]

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));

`fn round(self) -> Self where T: Float,`
[src]

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));

`fn hadd(self, rhs: Self) -> Self where T: Add<T, Output = T>,`
[src]

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));

`fn partial_cmpeq<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: PartialEq,`
[src]

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));

`fn partial_cmpne<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: PartialEq,`
[src]

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));

`fn partial_cmpge<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: PartialOrd,`
[src]

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));

`fn partial_cmpgt<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: PartialOrd,`
[src]

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));

`fn partial_cmple<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: PartialOrd,`
[src]

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));

`fn partial_cmplt<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: PartialOrd,`
[src]

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));

`fn cmpeq<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: Eq,`
[src]

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));

`fn cmpne<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: Eq,`
[src]

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));

`fn cmpge<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: Ord,`
[src]

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));

`fn cmpgt<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: Ord,`
[src]

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));

`fn cmple<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: Ord,`
[src]

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));

`fn cmplt<Rhs: AsRef<Self>>(&self, rhs: &Rhs) -> Rgba<bool> where T: Ord,`
[src]

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));

`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>,`
[src]

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

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

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

`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>,`
[src]

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

`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>,`
[src]

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

`impl<T: ColorComponent> Rgba<T>`
[src]

`fn new_opaque(r: T, g: T, b: T) -> Self`
[src]

`fn new_transparent(r: T, g: T, b: T) -> Self`
[src]

`fn from_opaque<V: Into<Rgb<T>>>(color: V) -> Self`
[src]

`fn from_transparent<V: Into<Rgb<T>>>(color: V) -> Self`
[src]

`impl<T> Rgba<T>`
[src]

`fn from_translucent<V: Into<Rgb<T>>>(color: V, opacity: T) -> Self`
[src]

`impl<T: ColorComponent> Rgba<T>`
[src]

`fn black() -> Self`
[src]

`fn white() -> Self`
[src]

`fn red() -> Self`
[src]

`fn green() -> Self`
[src]

`fn blue() -> Self`
[src]

`fn cyan() -> Self`
[src]

`fn magenta() -> Self`
[src]

`fn yellow() -> Self`
[src]

`fn gray(value: T) -> Self where T: Copy,`
[src]

`fn grey(value: T) -> Self where T: Copy,`
[src]

`fn inverted_rgb(self) -> Self where T: Sub<Output = T>,`
[src]

Returns this color with RGB elements inverted. Alpha is preserved.

let opaque_orange = Rgba::new(255_u8, 128, 0, 255_u8);
assert_eq!(opaque_orange.inverted_rgb(), Rgba::new(0, 127, 255, 255));
assert_eq!(Rgba::<u8>::black().inverted_rgb(), Rgba::white());
assert_eq!(Rgba::<u8>::white().inverted_rgb(), Rgba::black());
assert_eq!(Rgba::<u8>::red().inverted_rgb(), Rgba::cyan());

`fn average_rgb(self) -> T where T: Sum + Div<T, Output = T> + From<u8>,`
[src]

Returns the average of this vector's RGB elements.

This is not the same as average because average takes all elements into account, which includes alpha.

`fn shuffled_argb(self) -> Self`
[src]

`fn shuffled_bgra(self) -> Self`
[src]

`impl<T> Rgba<T>`
[src]

`fn shuffled<M: Into<ShuffleMask4>>(self, mask: M) -> Self where T: Copy,`
[src]

Shuffle elements from this vector, using mask.

The relevant x86 intrinsic is _mm_shuffle_ps(v, v, mask).

let a = Vec4::<u32>::new(0,1,2,3);
assert_eq!(a.shuffled((0,1,2,3)), Vec4::new(0,1,2,3));
assert_eq!(a.shuffled((3,2,1,0)), Vec4::new(3,2,1,0));
assert_eq!(a.shuffled((2,3,4,5)), Vec4::new(2,3,0,1));
assert_eq!(a.shuffled(1), Vec4::new(1,1,1,1));
assert_eq!(a.shuffled(1), Vec4::broadcast(1));

`fn shuffled_0101(self) -> Self where T: Copy,`
[src]

Moves the lower two elements of this vector to the upper two elements of the result. The lower two elements of this vector are passed through to the result.

The relevant x86 intrinsic is _mm_movelh_ps(v, v).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(0,1,0,1);
assert_eq!(a.shuffled_0101(), b);

`fn shuffled_2323(self) -> Self where T: Copy,`
[src]

Moves the upper two elements of this vector to the lower two elements of the result. The upper two elements of this vector are passed through to the result.

The relevant x86 intrinsic is _mm_movehl_ps(v, v).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(2,3,2,3);
assert_eq!(a.shuffled_2323(), b);

`fn shuffle_lo_hi<M: Into<ShuffleMask4>>(lo: Self, hi: Self, mask: M) -> Self where T: Copy,`
[src]

Shuffle elements from lo's low part and hi's high part using mask.

To shuffle a single vector, you may pass it as the first two arguments, or use the shuffled() method.

The relevant x86 intrinsic is _mm_shuffle_ps(lo, hi, mask).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(4,5,6,7);
assert_eq!(Vec4::shuffle_lo_hi(a, b, (0,1,2,3)), Vec4::new(0,1,6,7));
assert_eq!(Vec4::shuffle_lo_hi(a, b, (3,2,1,0)), Vec4::new(3,2,5,4));

`fn interleave_0011(a: Self, b: Self) -> Self`
[src]

Interleaves the lower two elements from a and b.

The relevant x86 intrinsic is _mm_unpacklo_ps(a, b).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(4,5,6,7);
let c = Vec4::<u32>::new(0,4,1,5);
assert_eq!(Vec4::interleave_0011(a, b), c);

`fn interleave_2233(a: Self, b: Self) -> Self`
[src]

Interleaves the upper two elements from a and b.

The relevant x86 intrinsic is _mm_unpackhi_ps(a, b).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(4,5,6,7);
let c = Vec4::<u32>::new(2,6,3,7);
assert_eq!(Vec4::interleave_2233(a, b), c);

`fn shuffle_lo_hi_0101(a: Self, b: Self) -> Self`
[src]

Moves the lower two elements of b to the upper two elements of the result. The lower two elements of a are passed through to the result.

The relevant x86 intrinsic is _mm_movelh_ps(a, b).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(4,5,6,7);
let c = Vec4::<u32>::new(0,1,4,5);
assert_eq!(Vec4::shuffle_lo_hi_0101(a, b), c);

`fn shuffle_hi_lo_2323(a: Self, b: Self) -> Self`
[src]

Moves the upper two elements of b to the lower two elements of the result. The upper two elements of a are passed through to the result.

The relevant x86 intrinsic is _mm_movehl_ps(a, b).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(4,5,6,7);
let c = Vec4::<u32>::new(6,7,2,3);
assert_eq!(Vec4::shuffle_hi_lo_2323(a, b), c);

`fn shuffled_0022(self) -> Self where T: Copy,`
[src]

Returns a copy of this vector with v[1] set to v[0] and v[3] set to v[2].

The relevant x86 intrinsic is _mm_moveldup_ps(v).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(0,0,2,2);
assert_eq!(a.shuffled_0022(), b);

`fn shuffled_1133(self) -> Self where T: Copy,`
[src]

Returns a copy of this vector with v[0] set to v[1] and v[2] set to v[3].

The relevant x86 intrinsic is _mm_movehdup_ps(v).

let a = Vec4::<u32>::new(0,1,2,3);
let b = Vec4::<u32>::new(1,1,3,3);
assert_eq!(a.shuffled_1133(), b);

Methods from Deref<Target = [T]>

`fn len(&self) -> usize`
1.0.0
[src]

Returns the number of elements in the slice.

Examples

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

`fn is_empty(&self) -> bool`
1.0.0
[src]

Returns true if the slice has a length of 0.

Examples

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

`fn first(&self) -> Option<&T>`
1.0.0
[src]

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());

`fn first_mut(&mut self) -> Option<&mut T>`
1.0.0
[src]

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]);

`fn split_first(&self) -> Option<(&T, &[T])>`
1.5.0
[src]

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]);
}

`fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>`
1.5.0
[src]

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]);

`fn split_last(&self) -> Option<(&T, &[T])>`
1.5.0
[src]

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]);
}

`fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>`
1.5.0
[src]

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]);

`fn last(&self) -> Option<&T>`
1.0.0
[src]

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());

`fn last_mut(&mut self) -> Option<&mut T>`
1.0.0
[src]

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]);

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

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));

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

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]);

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

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);
}

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

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]);

`fn as_ptr(&self) -> *const T`
1.0.0
[src]

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));
    }
}

`fn as_mut_ptr(&mut self) -> *mut T`
1.0.0
[src]

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]);

`fn swap(&mut self, a: usize, b: usize)`
1.0.0
[src]

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"]);

`fn reverse(&mut self)`
1.0.0
[src]

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

Examples

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

`fn iter(&self) -> Iter<T>`
1.0.0
[src]

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);

`fn iter_mut(&mut self) -> IterMut<T>`
1.0.0
[src]

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]);

`fn windows(&self, size: usize) -> Windows<T>`
1.0.0
[src]

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());

`fn chunks(&self, size: usize) -> Chunks<T>`
1.0.0
[src]

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

Panics

Panics if 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());

`fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T>`
1.0.0
[src]

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.

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]);

`fn split_at(&self, mid: usize) -> (&[T], &[T])`
1.0.0
[src]

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 == []);
}

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

Divides one &mut 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]);

`fn split<F>(&self, pred: F) -> Split<T, F> where F: FnMut(&T) -> bool,`
1.0.0
[src]

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());

`fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F> where F: FnMut(&T) -> bool,`
1.0.0
[src]

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]);

`fn rsplit<F>(&self, pred: F) -> RSplit<T, F> where F: FnMut(&T) -> bool,`
[src]

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

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

#![feature(slice_rsplit)]

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.

#![feature(slice_rsplit)]

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);

`fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<T, F> where F: FnMut(&T) -> bool,`
[src]

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

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

#![feature(slice_rsplit)]

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]);

`fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F> where F: FnMut(&T) -> bool,`
1.0.0
[src]

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);
}

`fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F> where F: FnMut(&T) -> bool,`
1.0.0
[src]

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]);

`fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F> where F: FnMut(&T) -> bool,`
1.0.0
[src]

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);
}

`fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F> where F: FnMut(&T) -> bool,`
1.0.0
[src]

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]);

`fn contains(&self, x: &T) -> bool where T: PartialEq<T>,`
1.0.0
[src]

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));

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

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(&[]));

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

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(&[]));

`fn binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord,`
1.0.0
[src]

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, });

`fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize> where F: FnMut(&'a T) -> Ordering,`
1.0.0
[src]

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, });

`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,`
1.10.0
[src]

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, });

`fn sort(&mut self) where T: Ord,`
1.0.0
[src]

Sorts the slice.

This sort is stable (i.e. does not reorder equal elements) and O(n log n) worst-case.

When applicable, unstable sorting is preferred because it is generally faster than stable sorting and it doesn't allocate auxiliary memory. See sort_unstable.

Current implementation

The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.

Also, it allocates temporary storage half the size of self, but for short slices a non-allocating insertion sort is used instead.

Examples

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

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

`fn sort_by<F>(&mut self, compare: F) where F: FnMut(&T, &T) -> Ordering,`
1.0.0
[src]

Sorts the slice with a comparator function.

This sort is stable (i.e. does not reorder equal elements) and O(n log n) worst-case.

When applicable, unstable sorting is preferred because it is generally faster than stable sorting and it doesn't allocate auxiliary memory. See sort_unstable_by.

Current implementation

The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.

Also, it allocates temporary storage half the size of self, but for short slices a non-allocating insertion sort is used instead.

Examples

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

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

`fn sort_by_key<B, F>(&mut self, f: F) where B: Ord, F: FnMut(&T) -> B,`
1.7.0
[src]

Sorts the slice with a key extraction function.

This sort is stable (i.e. does not reorder equal elements) and O(n log n) worst-case.

When applicable, unstable sorting is preferred because it is generally faster than stable sorting and it doesn't allocate auxiliary memory. See sort_unstable_by_key.

Current implementation

The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.

Also, it allocates temporary storage half the size of self, but for short slices a non-allocating insertion sort is used instead.

Examples

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

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

`fn sort_unstable(&mut self) where T: Ord,`
1.20.0
[src]

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]);

`fn sort_unstable_by<F>(&mut self, compare: F) where F: FnMut(&T, &T) -> Ordering,`
1.20.0
[src]

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]);

`fn sort_unstable_by_key<B, F>(&mut self, f: F) where B: Ord, F: FnMut(&T) -> B,`
1.20.0
[src]

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(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 = [-5i32, 4, 1, -3, 2];

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

`fn rotate(&mut self, mid: usize)`
[src]

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

Permutes the slice in-place such that self[mid..] moves to the beginning of the slice while self[..mid] moves to the end of the slice. Equivalently, rotates the slice mid places to the left or k = self.len() - mid places to the right.

This is a "k-rotation", a permutation in which item i moves to position i + k, modulo the length of the slice. See Elements of Programming §10.4.

Rotation by mid and rotation by k are inverse operations.

Panics

This function will panic if mid is greater than the length of the slice. (Note that mid == self.len() does not panic; it's a nop rotation with k == 0, the inverse of a rotation with mid == 0.)

Complexity

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

Examples

#![feature(slice_rotate)]

let mut a = [1, 2, 3, 4, 5, 6, 7];
let mid = 2;
a.rotate(mid);
assert_eq!(&a, &[3, 4, 5, 6, 7, 1, 2]);
let k = a.len() - mid;
a.rotate(k);
assert_eq!(&a, &[1, 2, 3, 4, 5, 6, 7]);

use std::ops::Range;
fn slide<T>(slice: &mut [T], range: Range<usize>, to: usize) {
    if to < range.start {
        slice[to..range.end].rotate(range.start-to);
    } else if to > range.end {
        slice[range.start..to].rotate(range.end-range.start);
    }
}
let mut v: Vec<_> = (0..10).collect();
slide(&mut v, 1..4, 7);
assert_eq!(&v, &[0, 4, 5, 6, 1, 2, 3, 7, 8, 9]);
slide(&mut v, 6..8, 1);
assert_eq!(&v, &[0, 3, 7, 4, 5, 6, 1, 2, 8, 9]);

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

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

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

dst.clone_from_slice(&src);
assert!(dst == [1, 2, 3]);

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

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

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

dst.copy_from_slice(&src);
assert_eq!(src, dst);

`fn swap_with_slice(&mut self, src: &mut [T])`
[src]

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

Swaps all elements in self with those in src.

The length of src must be the same as self.

Panics

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

Example

#![feature(swap_with_slice)]

let mut src = [1, 2, 3];
let mut dst = [7, 8, 9];

src.swap_with_slice(&mut dst);
assert_eq!(src, [7, 8, 9]);
assert_eq!(dst, [1, 2, 3]);

`fn to_vec(&self) -> Vec<T> where T: Clone,`
1.0.0
[src]

Copies self into a new Vec.

Examples

let s = [10, 40, 30];
let x = s.to_vec();
// Here, `s` and `x` can be modified independently.

Trait Implementations

`impl<T: Debug> Debug for Rgba<T>`
[src]

`fn fmt(&self, __arg_0: &mut Formatter) -> Result`
[src]

Formats the value using the given formatter.

`impl<T: Default> Default for Rgba<T>`
[src]

`fn default() -> Rgba<T>`
[src]

Returns the "default value" for a type. Read more

`impl<T: Clone> Clone for Rgba<T>`
[src]

`fn clone(&self) -> Rgba<T>`
[src]

Returns a copy of the value. Read more

`fn clone_from(&mut self, source: &Self)`
1.0.0
[src]

Performs copy-assignment from source. Read more

`impl<T: Copy> Copy for Rgba<T>`
[src]

`impl<T: Hash> Hash for Rgba<T>`
[src]

`fn hash<HT: Hasher>(&self, arg_0: &mut __HT)`
[src]

Feeds this value into the given [Hasher]. Read more

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

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

`impl<T: Eq> Eq for Rgba<T>`
[src]

`impl<T: PartialEq> PartialEq for Rgba<T>`
[src]

`fn eq(&self, __arg_0: &Rgba<T>) -> bool`
[src]

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

`fn ne(&self, __arg_0: &Rgba<T>) -> bool`
[src]

This method tests for !=.

`impl<T: Display> Display for Rgba<T>`
[src]

Displays the vector, formatted as .

`fn fmt(&self, f: &mut Formatter) -> Result`
[src]

Formats the value using the given formatter. Read more

`impl<T, Factor> Lerp<Factor> for Rgba<T> where T: Lerp<Factor, Output = T>, Factor: Copy,`
[src]

`type Output = Self`

The resulting type after performing the LERP operation.

`fn lerp_unclamped_precise(from: Self, to: Self, factor: Factor) -> Self`
[src]

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

`fn lerp_unclamped(from: Self, to: Self, factor: Factor) -> Self`
[src]

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

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

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

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

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

`impl<'a, T, Factor> Lerp<Factor> for &'a Rgba<T> where &'a T: Lerp<Factor, Output = T>, Factor: Copy,`
[src]

`type Output = Rgba<T>`

The resulting type after performing the LERP operation.

`fn lerp_unclamped_precise(from: Self, to: Self, factor: Factor) -> Rgba<T>`
[src]

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

`fn lerp_unclamped(from: Self, to: Self, factor: Factor) -> Rgba<T>`
[src]

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

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

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

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

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

`impl<T: Wrap + Copy> Wrap<T> for Rgba<T>`
[src]

`fn wrapped(self, upper: T) -> Self`
[src]

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

`fn wrapped_between(self, lower: T, upper: T) -> Self`
[src]

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

`fn pingpong(self, upper: T) -> Self`
[src]

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

`fn wrap(val: Self, upper: Bound) -> Self`
[src]

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

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

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

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

Alias to wrapped_2pi which doesn't take self. Read more

`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,`
[src]

Alias to wrapped_between which doesn't take self. Read more

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

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>,`
[src]

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

`impl<T: Wrap> Wrap<Rgba<T>> for Rgba<T>`
[src]

`fn wrapped(self, upper: Rgba<T>) -> Self`
[src]

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

`fn wrapped_between(self, lower: Self, upper: Self) -> Self`
[src]

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

`fn pingpong(self, upper: Self) -> Self`
[src]

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

`fn wrap(val: Self, upper: Bound) -> Self`
[src]

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

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

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

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

Alias to wrapped_2pi which doesn't take self. Read more

`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,`
[src]

Alias to wrapped_between which doesn't take self. Read more

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

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>,`
[src]

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

`impl<T: Clamp + Copy> Clamp<T> for Rgba<T>`
[src]

`fn clamped(self, lower: T, upper: T) -> Self`
[src]

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

`fn clamp(val: Self, lower: Bound, upper: Bound) -> Self`
[src]

Alias to clamped, which doesn't take self. Read more

`fn clamped01(self) -> Self where Bound: Zero + One,`
[src]

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

`fn clamp01(val: Self) -> Self where Bound: Zero + One,`
[src]

Alias to clamped01, which doesn't take self.

`impl<T: IsBetween<Output = bool> + Copy> IsBetween<T> for Rgba<T>`
[src]

`type Output = Rgba<bool>`

bool for scalars, or vector of bools for vectors.

`fn is_between(self, lower: T, upper: T) -> Self::Output`
[src]

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

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

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

`impl<T: Clamp> Clamp<Rgba<T>> for Rgba<T>`
[src]

`fn clamped(self, lower: Self, upper: Self) -> Self`
[src]

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

`fn clamp(val: Self, lower: Bound, upper: Bound) -> Self`
[src]

Alias to clamped, which doesn't take self. Read more

`fn clamped01(self) -> Self where Bound: Zero + One,`
[src]

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

`fn clamp01(val: Self) -> Self where Bound: Zero + One,`
[src]

Alias to clamped01, which doesn't take self.

`impl<T: IsBetween<Output = bool>> IsBetween<Rgba<T>> for Rgba<T>`
[src]

`type Output = Rgba<bool>`

bool for scalars, or vector of bools for vectors.

`fn is_between(self, lower: Self, upper: Self) -> Self::Output`
[src]

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

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

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

`impl<T: Zero + PartialEq> Zero for Rgba<T>`
[src]

`fn zero() -> Self`
[src]

Returns the additive identity element of Self, 0. Read more

`fn is_zero(&self) -> bool`
[src]

Returns true if self is equal to the additive identity.

`impl<T: One> One for Rgba<T>`
[src]

`fn one() -> Self`
[src]

Returns the multiplicative identity element of Self, 1. Read more

`impl<T: ApproxEq> ApproxEq for Rgba<T> where T::Epsilon: Copy,`
[src]

`type Epsilon = T::Epsilon`

Used for specifying relative comparisons.

`fn default_epsilon() -> T::Epsilon`
[src]

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

`fn default_max_relative() -> T::Epsilon`
[src]

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

`fn default_max_ulps() -> u32`
[src]

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

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

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`
[src]

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`
[src]

The inverse of ApproxEq::relative_eq.