Struct Line 

pub struct Line<P> { /* private fields */ }

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

Implementations

impl<P> Line<P>

where P: CubePrimitive,

pub fn new(val: P) -> Line<P>

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

pub fn __expand_new( scope: &mut Scope, val: <P as CubeType>::ExpandType, ) -> <Line<P> as CubeType>::ExpandType

impl<P> Line<P>

where P: CubePrimitive,

pub fn line_size(&self) -> u32

Get the length of the current line.

impl<P> Line<P>

where P: CubePrimitive + Into<ExpandElementTyped<P>>,

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

Fill the line with the given value.

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

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

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

impl<P> Line<P>

where P: CubePrimitive,

pub fn empty(size: u32) -> Line<P>

Create an empty line of the given size.

Note that a line can’t change in size once it’s fixed.

pub fn __expand_empty( scope: &mut Scope, size: u32, ) -> <Line<P> as CubeType>::ExpandType

impl<P> Line<P>

where P: CubePrimitive,

pub fn size(&self) -> u32

Get the number of individual elements a line 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!(line.size() == 1) {
}

pub fn __expand_size(scope: &mut Scope, element: ExpandElementTyped<P>) -> u32

Expand function of size.

impl<P> Line<P>

where P: CubePrimitive,

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

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

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

impl<P> Line<P>

where P: CubePrimitive,

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

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

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

impl<P> Line<P>

where P: CubePrimitive,

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

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

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

impl<P> Line<P>

where P: CubePrimitive,

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

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

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

impl<P> Line<P>

where P: CubePrimitive,

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

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

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

impl<P> Line<P>

where P: CubePrimitive,

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

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

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

impl Line<bool>

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

Return a new line with the element-wise and of the lines

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

impl Line<bool>

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

Return a new line with the element-wise and of the lines

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

impl<P> Line<P>

where P: CountOnes,

pub fn count_ones(self) -> Line<u32>

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

impl<P> Line<P>

where P: LeadingZeros,

pub fn leading_zeros(self) -> Line<u32>

pub fn __expand_leading_zeros( scope: &mut Scope, this: <Line<P> as CubeType>::ExpandType, ) -> <Line<u32> as CubeType>::ExpandType

impl<P> Line<P>

where P: FindFirstSet,

pub fn find_first_set(self) -> Line<u32>

pub fn __expand_find_first_set( scope: &mut Scope, this: <Line<P> as CubeType>::ExpandType, ) -> <Line<u32> as CubeType>::ExpandType

Trait Implementations

impl<P> Abs for Line<P>

where P: CubePrimitive + Abs,

fn abs(x: Self) -> Self

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

impl<P> Add<f32> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<P> Add<f64> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<P> Add<i32> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<P> Add<i64> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<P> Add<usize> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<P> Add for Line<P>

where P: CubePrimitive + Add<Output = P>,

type Output = Line<P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<P> AddAssign for Line<P>

where P: CubePrimitive + AddAssign,

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

Performs the += operation.

impl<P> BitAnd for Line<P>

where P: CubePrimitive + BitAnd<Output = P>,

type Output = Line<P>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<P> BitAndAssign for Line<P>

where P: CubePrimitive + BitAndAssign,

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

Performs the &= operation.

impl<P> BitOr for Line<P>

where P: CubePrimitive + BitOr<Output = P>,

type Output = Line<P>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<P> BitOrAssign for Line<P>

where P: CubePrimitive + BitOrAssign,

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

Performs the |= operation.

impl<P> BitXor for Line<P>

where P: CubePrimitive + BitXor<Output = P>,

type Output = Line<P>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<P> BitXorAssign for Line<P>

where P: CubePrimitive + BitXorAssign,

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

Performs the ^= operation.

impl<P> BitwiseNot for Line<P>

where P: CubePrimitive + BitwiseNot,

fn bitwise_not(x: Self) -> Self

fn __expand_bitwise_not( scope: &mut Scope, x: Self::ExpandType, ) -> ExpandElementTyped<Self>

impl<P> Ceil for Line<P>

where P: CubePrimitive + Ceil,

fn ceil(x: Self) -> Self

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

impl<P> Clamp for Line<P>

where P: CubePrimitive + Clamp,

fn clamp(input: Self, min_value: Self, max_value: Self) -> Self

Clamp the input value between the max and min values provided.

fn __expand_clamp( scope: &mut Scope, input: Self::ExpandType, min_value: Self::ExpandType, max_value: Self::ExpandType, ) -> Self::ExpandType

impl<P> Clone for Line<P>

where P: CubePrimitive,

fn clone(&self) -> Line<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Cos for Line<P>

where P: CubePrimitive + Cos,

fn cos(x: Self) -> Self

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

impl<E> CubeIndex for Line<E>

where E: CubePrimitive,

type Output = E

type Idx = u32

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> CubeIndexMut for Line<E>

where E: CubePrimitive,

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> CubePrimitive for Line<P>

where P: CubePrimitive,

fn as_type(scope: &Scope) -> StorageType

Return the element type to use on GPU.

fn as_type_native() -> Option<StorageType>

Native or static element type.

fn size() -> Option<usize>

Only native element types have a size.

fn from_const_value(value: ConstantScalarValue) -> Line<P>

fn as_type_native_unchecked() -> StorageType

Native or static element type.

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: ExpandElement) -> Self::ExpandType

fn into_lit_unchecked(self) -> Self

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

where S: ComputeServer,

fn elem_size() -> u32

fn elem_size_bits() -> u32

fn packing_factor() -> u32

fn __expand_elem_size(scope: &Scope) -> u32

fn __expand_elem_size_bits(scope: &Scope) -> u32

fn __expand_packing_factor(scope: &Scope) -> u32

impl<P> CubeType for &Line<P>

where P: CubePrimitive,

type ExpandType = ExpandElementTyped<Line<P>>

fn into_mut(scope: &mut Scope, expand: Self::ExpandType) -> Self::ExpandType

Wrapper around the init method, necessary to type inference.

impl<P> CubeType for &mut Line<P>

where P: CubePrimitive,

type ExpandType = ExpandElementTyped<Line<P>>

fn into_mut(scope: &mut Scope, expand: Self::ExpandType) -> Self::ExpandType

Wrapper around the init method, necessary to type inference.

impl<P> CubeType for Line<P>

where P: CubePrimitive,

type ExpandType = ExpandElementTyped<Line<P>>

fn into_mut(scope: &mut Scope, expand: Self::ExpandType) -> Self::ExpandType

Wrapper around the init method, necessary to type inference.

impl<P> Div<f32> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<P> Div<f64> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<P> Div<i32> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<P> Div<i64> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<P> Div<usize> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<P> Div for Line<P>

where P: CubePrimitive + Div<Output = P>,

type Output = Line<P>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<P> DivAssign for Line<P>

where P: CubePrimitive + DivAssign,

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

Performs the /= operation.

impl<N> Dot for Line<N>

where N: Numeric,

fn dot(self, _rhs: Line<N>) -> Line<N>

fn __expand_dot( scope: &mut Scope, lhs: ExpandElementTyped<Line<N>>, rhs: ExpandElementTyped<Line<N>>, ) -> ExpandElementTyped<Line<N>>

impl<P> Erf for Line<P>

where P: CubePrimitive + Erf,

fn erf(x: Self) -> Self

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

impl<P> Exp for Line<P>

where P: CubePrimitive + Exp,

fn exp(x: Self) -> Self

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

impl<P> ExpandElementIntoMut for Line<P>

where P: CubePrimitive,

fn elem_into_mut(scope: &mut Scope, elem: ExpandElement) -> ExpandElement

impl<P> Floor for Line<P>

where P: CubePrimitive + Floor,

fn floor(x: Self) -> Self

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

impl<P> Into<ExpandElementTyped<Line<P>>> for Line<P>

where P: CubePrimitive + Into<ExpandElementTyped<P>>,

fn into(self) -> ExpandElementTyped<Line<P>>

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

impl<P> IsInf for Line<P>

where P: CubePrimitive + IsInf,

fn is_inf(x: Self) -> bool

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

impl<P> IsNan for Line<P>

where P: CubePrimitive + IsNan,

fn is_nan(x: Self) -> bool

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

impl<E, IO> List<Line<E>> for VirtualTensor<E, IO>

where E: Numeric, IO: Clone,

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

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

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

fn len(&self) -> u32

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

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

impl<E, IO> ListExpand<Line<E>> for VirtualTensorExpand<E, IO>

where E: Numeric, IO: Clone,

fn __expand_read_method( &self, scope: &mut Scope, index: <u32 as CubeType>::ExpandType, ) -> <Line<E> as CubeType>::ExpandType

fn __expand_read_unchecked_method( &self, _scope: &mut Scope, _index: ExpandElementTyped<u32>, ) -> <Line<E> as CubeType>::ExpandType

fn __expand_len_method(&self, scope: &mut Scope) -> ExpandElementTyped<u32>

impl<E> ListMut<Line<E>> for VirtualTensor<E, ReadWrite>

where E: Numeric,

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

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

impl<E> ListMutExpand<Line<E>> for VirtualTensorExpand<E, ReadWrite>

where E: Numeric,

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

impl<P> Log for Line<P>

where P: CubePrimitive + Log,

fn log(x: Self) -> Self

fn __expand_log( scope: &mut Scope, x: Self::ExpandType, ) -> ExpandElementTyped<Self>

impl<P> Log1p for Line<P>

where P: CubePrimitive + Log1p,

fn log1p(x: Self) -> Self

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

impl<P> Max for Line<P>

where P: CubePrimitive + Max,

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

fn __expand_max( scope: &mut Scope, lhs: ExpandElementTyped<Self>, rhs: ExpandElementTyped<Self>, ) -> ExpandElementTyped<Self>

impl<P> Min for Line<P>

where P: CubePrimitive + Min,

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

fn __expand_min( scope: &mut Scope, lhs: ExpandElementTyped<Self>, rhs: ExpandElementTyped<Self>, ) -> ExpandElementTyped<Self>

impl<P> Mul<f32> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<P> Mul<f64> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<P> Mul<i32> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<P> Mul<i64> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<P> Mul<usize> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<P> Mul for Line<P>

where P: CubePrimitive + Mul<Output = P>,

type Output = Line<P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<P> MulAssign for Line<P>

where P: CubePrimitive + MulAssign,

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

Performs the *= operation.

impl<N> MulHi for Line<N>

where N: MulHi + CubePrimitive,

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

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

impl<P> Neg for Line<P>

where P: Neg<Output = P>,

type Output = Line<P>

The resulting type after applying the - operator.

fn neg(self) -> Line<P>

Performs the unary - operation.

impl<P> NumCast for Line<P>

where P: CubePrimitive + NumCast,

fn from<T>(n: T) -> Option<Line<P>>

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<P> PartialEq for Line<P>

where P: CubePrimitive + PartialEq,

fn eq(&self, other: &Line<P>) -> 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> PartialOrd for Line<P>

where P: CubePrimitive + PartialOrd,

fn partial_cmp(&self, other: &Line<P>) -> 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> Powf for Line<P>

where P: CubePrimitive + Powf,

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

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

impl<P, I> Powi<Line<I>> for Line<P>

where P: CubePrimitive + Powi<I>, I: CubePrimitive,

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

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

impl<P> Recip for Line<P>

where P: CubePrimitive + Recip,

fn recip(x: Self) -> Self

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

impl<P> Remainder for Line<P>

where P: CubePrimitive + Remainder,

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

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

impl<P> ReverseBits for Line<P>

where P: CubePrimitive + ReverseBits,

fn reverse_bits(x: Self) -> Self

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

impl<P> Round for Line<P>

where P: CubePrimitive + Round,

fn round(x: Self) -> Self

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

impl<P> SaturatingAdd for Line<P>

where P: CubePrimitive + SaturatingAdd,

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

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

impl<P> SaturatingSub for Line<P>

where P: CubePrimitive + SaturatingSub,

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

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

impl<P> Shl for Line<P>

where P: CubePrimitive + Shl<Output = P>,

type Output = Line<P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<P> ShlAssign for Line<P>

where P: CubePrimitive + ShlAssign,

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

Performs the <<= operation.

impl<P> Shr for Line<P>

where P: CubePrimitive + Shr<Output = P>,

type Output = Line<P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<P> ShrAssign for Line<P>

where P: CubePrimitive + ShrAssign,

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

Performs the >>= operation.

impl<P> Sin for Line<P>

where P: CubePrimitive + Sin,

fn sin(x: Self) -> Self

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

impl<E> SliceMutOperator<Line<E>> for VirtualTensor<E, ReadWrite>

where E: Numeric,

fn slice_mut(&mut self, start: u32, end: u32) -> 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: <u32 as CubeType>::ExpandType, end: <u32 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> SliceMutOperatorExpand<Line<E>> for VirtualTensorExpand<E, ReadWrite>

where E: Numeric,

fn __expand_slice_mut_method( &self, scope: &mut Scope, start: ExpandElementTyped<u32>, end: ExpandElementTyped<u32>, ) -> SliceExpand<Line<E>, ReadWrite>

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

impl<E, IO> SliceOperator<Line<E>> for VirtualTensor<E, IO>

where E: Numeric, IO: Clone,

fn slice(&self, start: u32, end: u32) -> 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: <u32 as CubeType>::ExpandType, end: <u32 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, IO> SliceOperatorExpand<Line<E>> for VirtualTensorExpand<E, IO>

where E: Numeric, IO: Clone,

fn __expand_slice_method( &self, scope: &mut Scope, start: ExpandElementTyped<u32>, end: ExpandElementTyped<u32>, ) -> SliceExpand<Line<E>, ReadOnly>

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

impl<P> Sqrt for Line<P>

where P: CubePrimitive + Sqrt,

fn sqrt(x: Self) -> Self

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

impl<P> Sub<f32> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<P> Sub<f64> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<P> Sub<i32> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<P> Sub<i64> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<P> Sub<usize> for Line<P>

where P: CubePrimitive,

type Output = Line<P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<P> Sub for Line<P>

where P: CubePrimitive + Sub<Output = P>,

type Output = Line<P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<P> SubAssign for Line<P>

where P: CubePrimitive + SubAssign,

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

Performs the -= operation.

impl<P> Tanh for Line<P>

where P: CubePrimitive + Tanh,

fn tanh(x: Self) -> Self

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

impl<P> ToPrimitive for Line<P>

where P: CubePrimitive + NumCast,

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> Trunc for Line<P>

where P: CubePrimitive + Trunc,

fn trunc(x: Self) -> Self

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

impl<P> Copy for Line<P>

where P: CubePrimitive,

impl<P> Eq for Line<P>

where P: CubePrimitive,