Struct Zip5

pub struct Zip5<T0, T1, T2, T3, T4>(pub T0, pub T1, pub T2, pub T3, pub T4)
where
    Self: Computation;

Tuple Fields

0: T0

1: T1

2: T2

3: T3

4: T4

Trait Implementations

impl<Rhs, T0, T1, T2, T3, T4> Add<Rhs> for Zip5<T0, T1, T2, T3, T4>

where Self: Computation, Add<Self, Rhs>: Computation,

type Output = Add<Zip5<T0, T1, T2, T3, T4>, Rhs>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T0: Clone, T1: Clone, T2: Clone, T3: Clone, T4: Clone> Clone for Zip5<T0, T1, T2, T3, T4>

where Self: Computation,

fn clone(&self) -> Zip5<T0, T1, T2, T3, T4>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T0, T1, T2, T3, T4> Computation for Zip5<T0, T1, T2, T3, T4>

where T0: Computation, T1: Computation, T2: Computation, T3: Computation, T4: Computation,

type Dim = (<T0 as Computation>::Dim, <T1 as Computation>::Dim, <T2 as Computation>::Dim, <T3 as Computation>::Dim, <T4 as Computation>::Dim)

type Item = (<T0 as Computation>::Item, <T1 as Computation>::Item, <T2 as Computation>::Item, <T3 as Computation>::Item, <T4 as Computation>::Item)

fn add<Rhs>(self, rhs: Rhs) -> Add<Self, Rhs>

where Self: Sized, Add<Self, Rhs>: Computation,

fn sub<Rhs>(self, rhs: Rhs) -> Sub<Self, Rhs>

where Self: Sized, Sub<Self, Rhs>: Computation,

fn mul<Rhs>(self, rhs: Rhs) -> Mul<Self, Rhs>

where Self: Sized, Mul<Self, Rhs>: Computation,

fn div<Rhs>(self, rhs: Rhs) -> Div<Self, Rhs>

where Self: Sized, Div<Self, Rhs>: Computation,

fn pow<Rhs>(self, rhs: Rhs) -> Pow<Self, Rhs>

where Self: Sized, Pow<Self, Rhs>: Computation,

fn neg(self) -> Neg<Self>

where Self: Sized, Neg<Self>: Computation,

fn abs(self) -> Abs<Self>

where Self: Sized, Abs<Self>: Computation,

fn sin(self) -> Sin<Self>

where Self: Sized, Sin<Self>: Computation,

fn cos(self) -> Cos<Self>

where Self: Sized, Cos<Self>: Computation,

fn tan(self) -> Tan<Self>

where Self: Sized, Tan<Self>: Computation,

fn asin(self) -> Asin<Self>

where Self: Sized, Asin<Self>: Computation,

fn acos(self) -> Acos<Self>

where Self: Sized, Acos<Self>: Computation,

fn atan(self) -> Atan<Self>

where Self: Sized, Atan<Self>: Computation,

fn eq<Rhs>(self, rhs: Rhs) -> Eq<Self, Rhs>

where Self: Sized, Eq<Self, Rhs>: Computation,

fn ne<Rhs>(self, rhs: Rhs) -> Ne<Self, Rhs>

where Self: Sized, Ne<Self, Rhs>: Computation,

fn lt<Rhs>(self, rhs: Rhs) -> Lt<Self, Rhs>

where Self: Sized, Lt<Self, Rhs>: Computation,

fn le<Rhs>(self, rhs: Rhs) -> Le<Self, Rhs>

where Self: Sized, Le<Self, Rhs>: Computation,

fn gt<Rhs>(self, rhs: Rhs) -> Gt<Self, Rhs>

where Self: Sized, Gt<Self, Rhs>: Computation,

fn ge<Rhs>(self, rhs: Rhs) -> Ge<Self, Rhs>

where Self: Sized, Ge<Self, Rhs>: Computation,

fn enumerate<F>(self, f: Function<(Name, Name), F>) -> Enumerate<Self, F>

where Self: Sized, Enumerate<Self, F>: Computation,

fn zip<Rhs>(self, rhs: Rhs) -> Zip<Self, Rhs>

where Self: Sized, Zip<Self, Rhs>: Computation,

fn black_box<F, FDim, FItem>(self, f: F) -> BlackBox<Self, F, FDim, FItem>

where Self: Sized, BlackBox<Self, F, FDim, FItem>: Computation,

Run the given regular function F.

fn if_<ArgNames, P, FTrue, FFalse>( self, arg_names: ArgNames, predicate: P, f_true: FTrue, f_false: FFalse, ) -> If<Self, ArgNames, P, FTrue, FFalse>

where Self: Sized, If<Self, ArgNames, P, FTrue, FFalse>: Computation,

fn loop_while<ArgNames, F, P>( self, arg_names: ArgNames, f: F, predicate: P, ) -> LoopWhile<Self, ArgNames, F, P>

where Self: Sized, LoopWhile<Self, ArgNames, F, P>: Computation,

fn then<ArgNames, F>(self, f: Function<ArgNames, F>) -> Then<Self, ArgNames, F>

where Self: Sized, Then<Self, ArgNames, F>: Computation,

fn identity_matrix<T>(self) -> IdentityMatrix<Self, T>

where Self: Sized, IdentityMatrix<Self, T>: Computation,

Return a self by self identity-matrix.

fn scalar_product<Rhs>(self, rhs: Rhs) -> ScalarProduct<Self, Rhs>

where Self: Sized, Mul<Self, Rhs>: Computation, ScalarProduct<Self, Rhs>: Computation,

Multiply and sum the elements of two vectors.

fn mat_mul<Rhs>(self, rhs: Rhs) -> MatMul<Self, Rhs>

where Self: Sized, MatMul<Self, Rhs>: Computation,

Perform matrix-multiplication.

fn mul_out<Rhs>(self, rhs: Rhs) -> MulOut<Self, Rhs>

where Self: Sized, MulOut<Self, Rhs>: Computation,

Multiply elements from the Cartesian product of two vectors.

fn mul_col<Rhs>(self, rhs: Rhs) -> MulCol<Self, Rhs>

where Self: Sized, MulCol<Self, Rhs>: Computation,

Matrix-multiply a matrix by a column-matrix, returning a vector.

impl<T0, T1, T2, T3, T4> ComputationFn for Zip5<T0, T1, T2, T3, T4>

where Self: Computation, T0: ComputationFn, T1: ComputationFn, T2: ComputationFn, T3: ComputationFn, T4: ComputationFn, Zip5<T0::Filled, T1::Filled, T2::Filled, T3::Filled, T4::Filled>: Computation,

type Filled = Zip5<<T0 as ComputationFn>::Filled, <T1 as ComputationFn>::Filled, <T2 as ComputationFn>::Filled, <T3 as ComputationFn>::Filled, <T4 as ComputationFn>::Filled>

fn fill(self, named_args: NamedArgs) -> Self::Filled

Fill arguments will values, replacing Args with Vals.

fn arg_names(&self) -> Names

impl<T0: Debug, T1: Debug, T2: Debug, T3: Debug, T4: Debug> Debug for Zip5<T0, T1, T2, T3, T4>

where Self: Computation,

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

Formats the value using the given formatter.

impl<T0, T1, T2, T3, T4> Display for Zip5<T0, T1, T2, T3, T4>

where Self: Computation, T0: Display, T1: Display, T2: Display, T3: Display, T4: Display,

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

Formats the value using the given formatter.

impl<Rhs, T0, T1, T2, T3, T4> Div<Rhs> for Zip5<T0, T1, T2, T3, T4>

where Self: Computation, Div<Self, Rhs>: Computation,

type Output = Div<Zip5<T0, T1, T2, T3, T4>, Rhs>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs, T0, T1, T2, T3, T4> Mul<Rhs> for Zip5<T0, T1, T2, T3, T4>

where Self: Computation, Mul<Self, Rhs>: Computation,

type Output = Mul<Zip5<T0, T1, T2, T3, T4>, Rhs>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T0, T1, T2, T3, T4> Neg for Zip5<T0, T1, T2, T3, T4>

where Self: Computation, Neg<Self>: Computation,

type Output = Neg<Zip5<T0, T1, T2, T3, T4>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T0, T1, T2, T3, T4> RunCore for Zip5<T0, T1, T2, T3, T4>

where Self: Computation, T0: RunCore, T1: RunCore, T2: RunCore, T3: RunCore, T4: RunCore,

type Output = (<T0 as RunCore>::Output, <T1 as RunCore>::Output, <T2 as RunCore>::Output, <T3 as RunCore>::Output, <T4 as RunCore>::Output)

fn run_core(self) -> Self::Output

impl<Rhs, T0, T1, T2, T3, T4> Sub<Rhs> for Zip5<T0, T1, T2, T3, T4>

where Self: Computation, Sub<Self, Rhs>: Computation,

type Output = Sub<Zip5<T0, T1, T2, T3, T4>, Rhs>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T0: Copy, T1: Copy, T2: Copy, T3: Copy, T4: Copy> Copy for Zip5<T0, T1, T2, T3, T4>

where Self: Computation,