Struct Vector 

pub struct Vector<P, N>
where
    P: Scalar,
    N: Size,
{ /* private fields */ }

A contiguous list of elements that supports auto-vectorized operations.

Implementations

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn new(val: P) -> Vector<P, N>

Create a new vector of size 1 using the given value.

pub fn __expand_new( scope: &mut Scope, val: NativeExpand<P>, ) -> NativeExpand<Vector<P, N>>

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn vector_size(&self) -> usize

Get the length of the current vector.

impl<P, N> Vector<P, N>

where P: Numeric, N: Size,

pub fn min_value() -> Vector<P, N>

pub fn max_value() -> Vector<P, N>

pub fn from_int(val: i64) -> Vector<P, N>

Create a new constant numeric.

Note: since this must work for both integer and float only the less expressive of both can be created (int) If a number with decimals is needed, use Float::new.

This method panics when unexpanded. For creating an element with a val, use the new method of the sub type.

pub fn __expand_min_value( scope: &mut Scope, ) -> <Vector<P, N> as CubeType>::ExpandType

pub fn __expand_max_value( scope: &mut Scope, ) -> <Vector<P, N> as CubeType>::ExpandType

pub fn __expand_from_int( scope: &mut Scope, val: <i64 as CubeType>::ExpandType, ) -> <Vector<P, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn fill(self, value: P) -> Vector<P, N>

Fill the vector with the given value.

If you want to fill the vector with different values, consider using the index API instead.

let mut vector = Vector::<u32>::empty(2);
vector[0] = 1;
vector[1] = 2;

pub fn __expand_fill( scope: &mut Scope, this: <Vector<P, N> as CubeType>::ExpandType, value: <P as CubeType>::ExpandType, ) -> <Vector<P, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn empty() -> Vector<P, N>

pub fn __expand_empty( scope: &mut Scope, ) -> <Vector<P, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar + Zeroable, N: Size,

pub fn zeroed() -> Vector<P, N>

pub fn __expand_zeroed( scope: &mut Scope, ) -> <Vector<P, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn size(&self) -> usize

Get the number of individual elements a vector contains.

The size is available at comptime and may be used in combination with the comptime macro.

// The if statement is going to be executed at comptime.
if comptime!(vector.size() == 1) {
}

pub fn __expand_size( scope: &mut Scope, element: NativeExpand<Vector<P, N>>, ) -> usize

Expand function of size.

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn equal(self, other: Vector<P, N>) -> Vector<bool, N>

Return a new vector with the element-wise comparison of the first vector being equal to the second vector.

pub fn __expand_equal( scope: &mut Scope, this: <Vector<P, N> as CubeType>::ExpandType, other: <Vector<P, N> as CubeType>::ExpandType, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn not_equal(self, other: Vector<P, N>) -> Vector<bool, N>

Return a new vector with the element-wise comparison of the first vector being not equal to the second vector.

pub fn __expand_not_equal( scope: &mut Scope, this: <Vector<P, N> as CubeType>::ExpandType, other: <Vector<P, N> as CubeType>::ExpandType, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn less_than(self, other: Vector<P, N>) -> Vector<bool, N>

Return a new vector with the element-wise comparison of the first vector being less than the second vector.

pub fn __expand_less_than( scope: &mut Scope, this: <Vector<P, N> as CubeType>::ExpandType, other: <Vector<P, N> as CubeType>::ExpandType, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn greater_than(self, other: Vector<P, N>) -> Vector<bool, N>

Return a new vector with the element-wise comparison of the first vector being greater than the second vector.

pub fn __expand_greater_than( scope: &mut Scope, this: <Vector<P, N> as CubeType>::ExpandType, other: <Vector<P, N> as CubeType>::ExpandType, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn less_equal(self, other: Vector<P, N>) -> Vector<bool, N>

Return a new vector with the element-wise comparison of the first vector being less than or equal to the second vector.

pub fn __expand_less_equal( scope: &mut Scope, this: <Vector<P, N> as CubeType>::ExpandType, other: <Vector<P, N> as CubeType>::ExpandType, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: Scalar, N: Size,

pub fn greater_equal(self, other: Vector<P, N>) -> Vector<bool, N>

Return a new vector with the element-wise comparison of the first vector being greater than or equal to the second vector.

pub fn __expand_greater_equal( scope: &mut Scope, this: <Vector<P, N> as CubeType>::ExpandType, other: <Vector<P, N> as CubeType>::ExpandType, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<N> Vector<bool, N>

where N: Size,

pub fn and(self, other: Vector<bool, N>) -> Vector<bool, N>

Return a new vector with the element-wise and of the vectors

pub fn __expand_and( scope: &mut Scope, this: <Vector<bool, N> as CubeType>::ExpandType, other: <Vector<bool, N> as CubeType>::ExpandType, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<N> Vector<bool, N>

where N: Size,

pub fn or(self, other: Vector<bool, N>) -> Vector<bool, N>

Return a new vector with the element-wise and of the vectors

pub fn __expand_or( scope: &mut Scope, this: <Vector<bool, N> as CubeType>::ExpandType, other: <Vector<bool, N> as CubeType>::ExpandType, ) -> <Vector<bool, N> as CubeType>::ExpandType

impl<P, N> Vector<P, N>

where P: CountOnes + Scalar, N: Size,

pub fn count_ones(self) -> Vector<u32, N>

pub fn __expand_count_ones( scope: &mut Scope, this: <Vector<P, N> as CubeType>::ExpandType, ) -> <Vector<u32, N> as CubeType>::ExpandType

Trait Implementations

impl<P, N> Abs for Vector<P, N>

where P: Scalar + Abs, N: Size,

fn abs(self) -> Self

fn __expand_abs(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> Add<f32> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the + operator.

fn add(self, _rhs: f32) -> <Vector<P, N> as Add<f32>>::Output

Performs the + operation.

impl<P, N> Add<f64> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the + operator.

fn add(self, _rhs: f64) -> <Vector<P, N> as Add<f64>>::Output

Performs the + operation.

impl<P, N> Add<i32> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the + operator.

fn add(self, _rhs: i32) -> <Vector<P, N> as Add<i32>>::Output

Performs the + operation.

impl<P, N> Add<i64> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the + operator.

fn add(self, _rhs: i64) -> <Vector<P, N> as Add<i64>>::Output

Performs the + operation.

impl<P, N> Add<usize> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the + operator.

fn add(self, _rhs: usize) -> <Vector<P, N> as Add<usize>>::Output

Performs the + operation.

impl<P, N> Add for Vector<P, N>

where N: Size, P: Scalar + Add<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the + operator.

fn add(self, rhs: Vector<P, N>) -> <Vector<P, N> as Add>::Output

Performs the + operation.

impl<P, N> AddAssign for Vector<P, N>

where N: Size, P: Scalar + AddAssign,

fn add_assign(&mut self, rhs: Vector<P, N>)

Performs the += operation.

impl<P, N> ArcCos for Vector<P, N>

where P: Scalar + ArcCos, N: Size,

fn acos(self) -> Self

fn __expand_acos(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> ArcCosh for Vector<P, N>

where P: Scalar + ArcCosh, N: Size,

fn acosh(self) -> Self

fn __expand_acosh( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> ArcSin for Vector<P, N>

where P: Scalar + ArcSin, N: Size,

fn asin(self) -> Self

fn __expand_asin(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> ArcSinh for Vector<P, N>

where P: Scalar + ArcSinh, N: Size,

fn asinh(self) -> Self

fn __expand_asinh( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> ArcTan for Vector<P, N>

where P: Scalar + ArcTan, N: Size,

fn atan(self) -> Self

fn __expand_atan(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> ArcTan2 for Vector<P, N>

where P: Scalar + ArcTan2, N: Size,

fn atan2(self, _rhs: Self) -> Self

fn __expand_atan2( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> ArcTanh for Vector<P, N>

where P: Scalar + ArcTanh, N: Size,

fn atanh(self) -> Self

fn __expand_atanh( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> BitAnd for Vector<P, N>

where N: Size, P: Scalar + BitAnd<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the & operator.

fn bitand(self, rhs: Vector<P, N>) -> <Vector<P, N> as BitAnd>::Output

Performs the & operation.

impl<P, N> BitAndAssign for Vector<P, N>

where N: Size, P: Scalar + BitAndAssign,

fn bitand_assign(&mut self, rhs: Vector<P, N>)

Performs the &= operation.

impl<P, N> BitOr for Vector<P, N>

where N: Size, P: Scalar + BitOr<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the | operator.

fn bitor(self, rhs: Vector<P, N>) -> <Vector<P, N> as BitOr>::Output

Performs the | operation.

impl<P, N> BitOrAssign for Vector<P, N>

where N: Size, P: Scalar + BitOrAssign,

fn bitor_assign(&mut self, rhs: Vector<P, N>)

Performs the |= operation.

impl<P, N> BitXor for Vector<P, N>

where N: Size, P: Scalar + BitXor<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Vector<P, N>) -> <Vector<P, N> as BitXor>::Output

Performs the ^ operation.

impl<P, N> BitXorAssign for Vector<P, N>

where N: Size, P: Scalar + BitXorAssign,

fn bitxor_assign(&mut self, rhs: Vector<P, N>)

Performs the ^= operation.

impl<P, N> Ceil for Vector<P, N>

where P: Scalar + Ceil, N: Size,

fn ceil(self) -> Self

fn __expand_ceil(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> Clone for Vector<P, N>

where P: Scalar, N: Size,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P, N> Cos for Vector<P, N>

where P: Scalar + Cos, N: Size,

fn cos(self) -> Self

fn __expand_cos(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> Cosh for Vector<P, N>

where P: Scalar + Cosh, N: Size,

fn cosh(self) -> Self

fn __expand_cosh(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<E, N> CubeIndex for Vector<E, N>

where E: Scalar, N: Size,

type Output = E

type Idx = usize

fn cube_idx(&self, _i: Self::Idx) -> &Self::Output

fn expand_index( scope: &mut Scope, array: Self::ExpandType, index: <Self::Idx as CubeType>::ExpandType, ) -> <Self::Output as CubeType>::ExpandType

fn expand_index_unchecked( scope: &mut Scope, array: Self::ExpandType, index: <Self::Idx as CubeType>::ExpandType, ) -> <Self::Output as CubeType>::ExpandType

impl<E, N> CubeIndexMut for Vector<E, N>

where E: Scalar, N: Size,

fn cube_idx_mut(&mut self, _i: Self::Idx) -> &mut Self::Output

fn expand_index_mut( scope: &mut Scope, array: Self::ExpandType, index: <Self::Idx as CubeType>::ExpandType, value: <Self::Output as CubeType>::ExpandType, )

impl<P, N> CubeNot for Vector<P, N>

where P: Scalar + CubeNot, N: Size,

fn __expand_not(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> CubePrimitive for Vector<P, N>

where P: Scalar, N: Size,

type Scalar = P

type Size = N

type WithScalar<S: Scalar> = Vector<S, N>

fn as_type(scope: &Scope) -> Type

Return the element type to use on GPU.

fn as_type_native() -> Option<Type>

Native or static element type.

fn from_const_value(value: ConstantValue) -> Vector<P, N>

fn as_type_native_unchecked() -> Type

Native or static element type.

fn size() -> Option<usize>

Only native element types have a size.

fn size_bits() -> Option<usize>

Only native element types have a size.

fn size_bits_unchecked() -> usize

Only native element types have a size.

fn from_expand_elem(elem: ManagedVariable) -> Self::ExpandType

fn into_lit_unchecked(self) -> Self

fn supported_uses<R>(client: &ComputeClient<R>) -> EnumSet<TypeUsage>

where R: Runtime,

fn type_size() -> usize

fn type_size_bits() -> usize

fn packing_factor() -> usize

fn vector_size() -> usize

fn __expand_type_size(scope: &Scope) -> usize

fn __expand_type_size_bits(scope: &Scope) -> usize

fn __expand_packing_factor(scope: &Scope) -> usize

fn __expand_vector_size(scope: &Scope) -> usize

impl<P, N> CubeType for &Vector<P, N>

where P: Scalar, N: Size,

type ExpandType = NativeExpand<Vector<P, N>>

impl<P, N> CubeType for &mut Vector<P, N>

where P: Scalar, N: Size,

type ExpandType = NativeExpand<Vector<P, N>>

impl<P, N> CubeType for Vector<P, N>

where P: Scalar, N: Size,

type ExpandType = NativeExpand<Vector<P, N>>

impl<P, N> Debug for Vector<P, N>

where P: Debug + Scalar, N: Debug + Size,

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

Formats the value using the given formatter.

impl<T, N> Default for Vector<T, N>

where T: Scalar + Default, N: Size,

fn default() -> Vector<T, N>

Returns the “default value” for a type.

impl<P, N> Degrees for Vector<P, N>

where P: Scalar + Degrees, N: Size,

fn to_degrees(self) -> Self

fn __expand_to_degrees( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> Div<f32> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the / operator.

fn div(self, _rhs: f32) -> <Vector<P, N> as Div<f32>>::Output

Performs the / operation.

impl<P, N> Div<f64> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the / operator.

fn div(self, _rhs: f64) -> <Vector<P, N> as Div<f64>>::Output

Performs the / operation.

impl<P, N> Div<i32> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the / operator.

fn div(self, _rhs: i32) -> <Vector<P, N> as Div<i32>>::Output

Performs the / operation.

impl<P, N> Div<i64> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the / operator.

fn div(self, _rhs: i64) -> <Vector<P, N> as Div<i64>>::Output

Performs the / operation.

impl<P, N> Div<usize> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the / operator.

fn div(self, _rhs: usize) -> <Vector<P, N> as Div<usize>>::Output

Performs the / operation.

impl<P, N> Div for Vector<P, N>

where N: Size, P: Scalar + Div<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the / operator.

fn div(self, rhs: Vector<P, N>) -> <Vector<P, N> as Div>::Output

Performs the / operation.

impl<P, N> DivAssign for Vector<P, N>

where N: Size, P: Scalar + DivAssign,

fn div_assign(&mut self, rhs: Vector<P, N>)

Performs the /= operation.

impl<T, N> Dot for Vector<T, N>

where T: Dot + Scalar, N: Size,

fn dot(self, _rhs: Self) -> Self::Scalar

fn __expand_dot( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self::Scalar>

impl<P, N> Erf for Vector<P, N>

where P: Scalar + Erf, N: Size,

fn erf(self) -> Self

fn __expand_erf(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> Exp for Vector<P, N>

where P: Scalar + Exp, N: Size,

fn exp(self) -> Self

fn __expand_exp(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> FindFirstSet for Vector<P, N>

where P: FindFirstSet + Scalar, N: Size,

fn find_first_set(self) -> Self::WithScalar<u32>

fn __expand_find_first_set( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self::WithScalar<u32>>

impl<T, N> FloatOps for Vector<T, N>

where T: FloatOps + Scalar, N: Size,

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

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

fn clamp(self, min: Self, max: Self) -> Self

fn __expand_min( scope: &mut Scope, this: Self::ExpandType, other: Self::ExpandType, ) -> Self::ExpandType

fn __expand_max( scope: &mut Scope, this: Self::ExpandType, other: Self::ExpandType, ) -> Self::ExpandType

fn __expand_clamp( scope: &mut Scope, this: Self::ExpandType, min: Self::ExpandType, max: Self::ExpandType, ) -> Self::ExpandType

impl<P, N> Floor for Vector<P, N>

where P: Scalar + Floor, N: Size,

fn floor(self) -> Self

fn __expand_floor( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<T, N> From<Vector<T, N>> for ConstantValue

where T: Scalar + Into<ConstantValue>, N: Size,

fn from(value: Vector<T, N>) -> ConstantValue

Converts to this type from the input type.

impl<T, N> Hypot for Vector<T, N>

where T: Hypot + Scalar, N: Size,

fn hypot(self, _rhs: Self) -> Self

fn __expand_hypot( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> Into<NativeExpand<Vector<P, N>>> for Vector<P, N>

where P: Scalar + Into<NativeExpand<P>>, N: Size,

fn into(self) -> NativeExpand<Vector<P, N>>

Converts this type into the (usually inferred) input type.

impl<T, N> IntoRuntime for Vector<T, N>

where T: Scalar + IntoRuntime, N: Size,

fn __expand_runtime_method( self, scope: &mut Scope, ) -> <Vector<T, N> as CubeType>::ExpandType

fn runtime(self) -> Self

impl<P, N> InverseSqrt for Vector<P, N>

where P: Scalar + InverseSqrt, N: Size,

fn inverse_sqrt(self) -> Self

fn __expand_inverse_sqrt( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> IsInf for Vector<P, N>

where P: Scalar + IsInf, N: Size,

fn is_inf(self) -> Self::WithScalar<bool>

fn __expand_is_inf( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self::WithScalar<bool>>

impl<P, N> IsNan for Vector<P, N>

where P: Scalar + IsNan, N: Size,

fn is_nan(self) -> Self::WithScalar<bool>

fn __expand_is_nan( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self::WithScalar<bool>>

impl<P, N> LeadingZeros for Vector<P, N>

where P: LeadingZeros + Scalar, N: Size,

fn leading_zeros(self) -> Self::WithScalar<u32>

fn __expand_leading_zeros( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self::WithScalar<u32>>

impl<E, N, IO> List<Vector<E, N>> for VirtualTensor<E, N, IO>

where E: Numeric, N: Size, IO: Clone,

fn __expand_read( scope: &mut Scope, this: VirtualTensorExpand<E, N, IO>, index: <usize as CubeType>::ExpandType, ) -> <Vector<E, N> as CubeType>::ExpandType

fn read(&self, index: usize) -> T

fn read_unchecked(&self, index: usize) -> T

fn len(&self) -> usize

fn __expand_read_unchecked( scope: &mut Scope, this: Self::ExpandType, index: <usize as CubeType>::ExpandType, ) -> <T as CubeType>::ExpandType

fn __expand_len( scope: &mut Scope, this: Self::ExpandType, ) -> <usize as CubeType>::ExpandType

impl<E, N, IO> ListExpand<Vector<E, N>> for VirtualTensorExpand<E, N, IO>

where E: Numeric, N: Size, IO: Clone,

fn __expand_read_method( &self, scope: &mut Scope, index: <usize as CubeType>::ExpandType, ) -> <Vector<E, N> as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _index: NativeExpand<usize>, ) -> <Vector<E, N> as CubeType>::ExpandType

fn __expand_len_method(&self, scope: &mut Scope) -> NativeExpand<usize>

impl<E, N> ListMut<Vector<E, N>> for VirtualTensor<E, N, ReadWrite>

where E: Numeric, N: Size,

fn __expand_write( scope: &mut Scope, this: VirtualTensorExpand<E, N, ReadWrite>, index: <usize as CubeType>::ExpandType, value: <Vector<E, N> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

fn write(&self, index: usize, value: T)

impl<E, N> ListMutExpand<Vector<E, N>> for VirtualTensorExpand<E, N, ReadWrite>

where E: Numeric, N: Size,

fn __expand_write_method( &self, scope: &mut Scope, index: <usize as CubeType>::ExpandType, value: <Vector<E, N> as CubeType>::ExpandType, ) -> <() as CubeType>::ExpandType

impl<P, N> Log for Vector<P, N>

where P: Scalar + Log, N: Size,

fn ln(self) -> Self

fn __expand_ln(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> Log1p for Vector<P, N>

where P: Scalar + Log1p, N: Size,

fn log1p(self) -> Self

fn __expand_log1p( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> Magnitude for Vector<P, N>

where P: Scalar + Magnitude, N: Size,

fn magnitude(self) -> Self

fn __expand_magnitude( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self::Scalar>

impl<P, N> Mul<f32> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the * operator.

fn mul(self, _rhs: f32) -> <Vector<P, N> as Mul<f32>>::Output

Performs the * operation.

impl<P, N> Mul<f64> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the * operator.

fn mul(self, _rhs: f64) -> <Vector<P, N> as Mul<f64>>::Output

Performs the * operation.

impl<P, N> Mul<i32> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the * operator.

fn mul(self, _rhs: i32) -> <Vector<P, N> as Mul<i32>>::Output

Performs the * operation.

impl<P, N> Mul<i64> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the * operator.

fn mul(self, _rhs: i64) -> <Vector<P, N> as Mul<i64>>::Output

Performs the * operation.

impl<P, N> Mul<usize> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the * operator.

fn mul(self, _rhs: usize) -> <Vector<P, N> as Mul<usize>>::Output

Performs the * operation.

impl<P, N> Mul for Vector<P, N>

where N: Size, P: Scalar + Mul<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<P, N>) -> <Vector<P, N> as Mul>::Output

Performs the * operation.

impl<P, N> MulAssign for Vector<P, N>

where N: Size, P: Scalar + MulAssign,

fn mul_assign(&mut self, rhs: Vector<P, N>)

Performs the *= operation.

impl<T, N> MulHi for Vector<T, N>

where T: MulHi + Scalar, N: Size,

fn mul_hi(self, _rhs: Self) -> Self

fn __expand_mul_hi( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> NativeAssign for Vector<P, N>

where P: Scalar, N: Size,

fn elem_init_mut(scope: &mut Scope, elem: ManagedVariable) -> ManagedVariable

impl<P, N> Neg for Vector<P, N>

where P: Scalar + Neg<Output = P>, N: Size,

type Output = Vector<P, N>

The resulting type after applying the - operator.

fn neg(self) -> <Vector<P, N> as Neg>::Output

Performs the unary - operation.

impl<P, N> Normalize for Vector<P, N>

where P: Scalar + Normalize, N: Size,

fn normalize(self) -> Self

fn __expand_normalize( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> Not for Vector<P, N>

where P: Not<Output = P> + Scalar, N: Size,

type Output = Vector<P, N>

The resulting type after applying the ! operator.

fn not(self) -> <Vector<P, N> as Not>::Output

Performs the unary ! operation.

impl<P, N> NumCast for Vector<P, N>

where P: Scalar + NumCast, N: Size,

fn from<T>(n: T) -> Option<Vector<P, N>>

where T: ToPrimitive,

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

impl<T, N> One for Vector<T, N>

where T: Scalar + One, N: Size,

fn one() -> Vector<T, N>

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<P, N> Ord for Vector<P, N>

where P: Scalar + Ord, N: Size,

fn cmp(&self, other: &Vector<P, N>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<P, N> PartialEq for Vector<P, N>

where N: Size, P: Scalar + PartialEq,

fn eq(&self, other: &Vector<P, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P, N> PartialOrd for Vector<P, N>

where N: Size, P: Scalar + PartialOrd,

fn partial_cmp(&self, other: &Vector<P, N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<P, N> Powf for Vector<P, N>

where P: Scalar + Powf, N: Size,

fn powf(self, _rhs: Self) -> Self

fn __expand_powf( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, I, N> Powi<Vector<I, N>> for Vector<P, N>

where P: Scalar + Powi<I>, I: Scalar, N: Size,

fn powi(self, _rhs: Rhs) -> Self

fn __expand_powi( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Rhs>, ) -> NativeExpand<Self>

impl<P, N> Radians for Vector<P, N>

where P: Scalar + Radians, N: Size,

fn to_radians(self) -> Self

fn __expand_to_radians( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> Recip for Vector<P, N>

where P: Scalar + Recip, N: Size,

fn recip(self) -> Self

fn __expand_recip( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> Remainder for Vector<P, N>

where P: Scalar + Remainder, N: Size,

fn rem(self, _rhs: Self) -> Self

fn __expand_rem( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> ReverseBits for Vector<P, N>

where P: Scalar + ReverseBits, N: Size,

fn reverse_bits(self) -> Self

fn __expand_reverse_bits( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<T, N> Rhypot for Vector<T, N>

where T: Rhypot + Scalar, N: Size,

fn rhypot(self, _rhs: Self) -> Self

fn __expand_rhypot( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> Round for Vector<P, N>

where P: Scalar + Round, N: Size,

fn round(self) -> Self

fn __expand_round( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> SaturatingAdd for Vector<P, N>

where P: Scalar + SaturatingAdd, N: Size,

fn saturating_add(self, _rhs: Self) -> Self

fn __expand_saturating_add( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> SaturatingSub for Vector<P, N>

where P: Scalar + SaturatingSub, N: Size,

fn saturating_sub(self, _rhs: Self) -> Self

fn __expand_saturating_sub( scope: &mut Scope, lhs: NativeExpand<Self>, rhs: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> Shl for Vector<P, N>

where N: Size, P: Scalar + Shl<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the << operator.

fn shl(self, rhs: Vector<P, N>) -> <Vector<P, N> as Shl>::Output

Performs the << operation.

impl<P, N> ShlAssign for Vector<P, N>

where N: Size, P: Scalar + ShlAssign,

fn shl_assign(&mut self, rhs: Vector<P, N>)

Performs the <<= operation.

impl<P, N> Shr for Vector<P, N>

where N: Size, P: Scalar + Shr<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the >> operator.

fn shr(self, rhs: Vector<P, N>) -> <Vector<P, N> as Shr>::Output

Performs the >> operation.

impl<P, N> ShrAssign for Vector<P, N>

where N: Size, P: Scalar + ShrAssign,

fn shr_assign(&mut self, rhs: Vector<P, N>)

Performs the >>= operation.

impl<P, N> Sin for Vector<P, N>

where P: Scalar + Sin, N: Size,

fn sin(self) -> Self

fn __expand_sin(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> Sinh for Vector<P, N>

where P: Scalar + Sinh, N: Size,

fn sinh(self) -> Self

fn __expand_sinh(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<E, N> SliceMutOperator<Vector<E, N>> for VirtualTensor<E, N, ReadWrite>

where E: Numeric, N: Size,

fn slice_mut(&mut self, start: usize, end: usize) -> Slice<E, ReadWrite>

Return a read-write view of all elements comprise between the start and end indices. In checked mode, if the end index is out-of-bound, it is replaced by the length of self.

fn to_slice_mut(&mut self) -> Slice<E, ReadWrite>

Reinterprete the current type as a read-write slice.

fn __expand_slice_mut( scope: &mut Scope, this: Self::ExpandType, start: <usize as CubeType>::ExpandType, end: <usize as CubeType>::ExpandType, ) -> <Slice<E, ReadWrite> as CubeType>::ExpandType

fn __expand_to_slice_mut( scope: &mut Scope, this: Self::ExpandType, ) -> <Slice<E, ReadWrite> as CubeType>::ExpandType

impl<E, N> SliceMutOperatorExpand<Vector<E, N>> for VirtualTensorExpand<E, N, ReadWrite>

where E: Numeric, N: Size,

fn __expand_slice_mut_method( &self, scope: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<Vector<E, N>, ReadWrite>

fn __expand_to_slice_mut_method( &self, scope: &mut Scope, ) -> SliceExpand<Vector<E, N>, ReadWrite>

impl<E, N, IO> SliceOperator<Vector<E, N>> for VirtualTensor<E, N, IO>

where E: Numeric, N: Size, IO: Clone,

fn slice(&self, start: usize, end: usize) -> Slice<E>

Return a read-only view of all elements comprise between the start and end indices. In checked mode, if the end index is out-of-bound, it is replaced by the length of self.

fn to_slice(&self) -> Slice<E>

Reinterprete the current type as a read-only slice.

fn __expand_slice( scope: &mut Scope, this: Self::ExpandType, start: <usize as CubeType>::ExpandType, end: <usize as CubeType>::ExpandType, ) -> <Slice<E> as CubeType>::ExpandType

fn __expand_to_slice( scope: &mut Scope, this: Self::ExpandType, ) -> <Slice<E> as CubeType>::ExpandType

impl<E, N, IO> SliceOperatorExpand<Vector<E, N>> for VirtualTensorExpand<E, N, IO>

where E: Numeric, N: Size, IO: Clone,

fn __expand_slice_method( &self, scope: &mut Scope, start: NativeExpand<usize>, end: NativeExpand<usize>, ) -> SliceExpand<Vector<E, N>, ReadOnly>

fn __expand_to_slice_method( &self, scope: &mut Scope, ) -> SliceExpand<Vector<E, N>, ReadOnly>

impl<P, N> Sqrt for Vector<P, N>

where P: Scalar + Sqrt, N: Size,

fn sqrt(self) -> Self

fn __expand_sqrt(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> Sub<f32> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the - operator.

fn sub(self, _rhs: f32) -> <Vector<P, N> as Sub<f32>>::Output

Performs the - operation.

impl<P, N> Sub<f64> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the - operator.

fn sub(self, _rhs: f64) -> <Vector<P, N> as Sub<f64>>::Output

Performs the - operation.

impl<P, N> Sub<i32> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the - operator.

fn sub(self, _rhs: i32) -> <Vector<P, N> as Sub<i32>>::Output

Performs the - operation.

impl<P, N> Sub<i64> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the - operator.

fn sub(self, _rhs: i64) -> <Vector<P, N> as Sub<i64>>::Output

Performs the - operation.

impl<P, N> Sub<usize> for Vector<P, N>

where N: Size, P: Scalar,

type Output = Vector<P, N>

The resulting type after applying the - operator.

fn sub(self, _rhs: usize) -> <Vector<P, N> as Sub<usize>>::Output

Performs the - operation.

impl<P, N> Sub for Vector<P, N>

where N: Size, P: Scalar + Sub<Output = P>,

type Output = Vector<P, N>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector<P, N>) -> <Vector<P, N> as Sub>::Output

Performs the - operation.

impl<P, N> SubAssign for Vector<P, N>

where N: Size, P: Scalar + SubAssign,

fn sub_assign(&mut self, rhs: Vector<P, N>)

Performs the -= operation.

impl<P, N> Tan for Vector<P, N>

where P: Scalar + Tan, N: Size,

fn tan(self) -> Self

fn __expand_tan(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> Tanh for Vector<P, N>

where P: Scalar + Tanh, N: Size,

fn tanh(self) -> Self

fn __expand_tanh(scope: &mut Scope, x: NativeExpand<Self>) -> NativeExpand<Self>

impl<P, N> ToPrimitive for Vector<P, N>

where P: Scalar + NumCast, N: Size,

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl<P, N> TrailingZeros for Vector<P, N>

where P: TrailingZeros + Scalar, N: Size,

fn trailing_zeros(self) -> Self::WithScalar<u32>

fn __expand_trailing_zeros( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self::WithScalar<u32>>

impl<P, N> Trunc for Vector<P, N>

where P: Scalar + Trunc, N: Size,

fn trunc(self) -> Self

fn __expand_trunc( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self>

impl<P, N> VectorSum for Vector<P, N>

where P: Scalar + VectorSum, N: Size,

fn vector_sum(self) -> Self

fn __expand_vector_sum( scope: &mut Scope, x: NativeExpand<Self>, ) -> NativeExpand<Self::Scalar>

impl<T, N> Zero for Vector<T, N>

where T: Scalar + Zero, N: Size,

fn zero() -> Vector<T, N>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<P, N> Copy for Vector<P, N>

where P: Scalar, N: Size,

impl<P, N> Eq for Vector<P, N>

where P: Scalar, N: Size,