Struct Zip14

pub struct Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(pub T0, pub T1, pub T2, pub T3, pub T4, pub T5, pub T6, pub T7, pub T8, pub T9, pub T10, pub T11, pub T12, pub T13)
where
    Self: Computation;

Tuple Fields

0: T0

1: T1

2: T2

3: T3

4: T4

5: T5

6: T6

7: T7

8: T8

9: T9

10: T10

11: T11

12: T12

13: T13

Trait Implementations

impl<Rhs, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Add<Rhs> for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

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

type Output = Add<Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, 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, T5: Clone, T6: Clone, T7: Clone, T8: Clone, T9: Clone, T10: Clone, T11: Clone, T12: Clone, T13: Clone> Clone for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

where Self: Computation,

fn clone( &self, ) -> Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Computation for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

where T0: Computation, T1: Computation, T2: Computation, T3: Computation, T4: Computation, T5: Computation, T6: Computation, T7: Computation, T8: Computation, T9: Computation, T10: Computation, T11: Computation, T12: Computation, T13: Computation,

type Dim = (<T0 as Computation>::Dim, <T1 as Computation>::Dim, <T2 as Computation>::Dim, <T3 as Computation>::Dim, <T4 as Computation>::Dim, <T5 as Computation>::Dim, <T6 as Computation>::Dim, <T7 as Computation>::Dim, <T8 as Computation>::Dim, <T9 as Computation>::Dim, <T10 as Computation>::Dim, <T11 as Computation>::Dim, <T12 as Computation>::Dim, <T13 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, <T5 as Computation>::Item, <T6 as Computation>::Item, <T7 as Computation>::Item, <T8 as Computation>::Item, <T9 as Computation>::Item, <T10 as Computation>::Item, <T11 as Computation>::Item, <T12 as Computation>::Item, <T13 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, T5, T6, T7, T8, T9, T10, T11, T12, T13> ComputationFn for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

where Self: Computation, T0: ComputationFn, T1: ComputationFn, T2: ComputationFn, T3: ComputationFn, T4: ComputationFn, T5: ComputationFn, T6: ComputationFn, T7: ComputationFn, T8: ComputationFn, T9: ComputationFn, T10: ComputationFn, T11: ComputationFn, T12: ComputationFn, T13: ComputationFn, Zip14<T0::Filled, T1::Filled, T2::Filled, T3::Filled, T4::Filled, T5::Filled, T6::Filled, T7::Filled, T8::Filled, T9::Filled, T10::Filled, T11::Filled, T12::Filled, T13::Filled>: Computation,

type Filled = Zip14<<T0 as ComputationFn>::Filled, <T1 as ComputationFn>::Filled, <T2 as ComputationFn>::Filled, <T3 as ComputationFn>::Filled, <T4 as ComputationFn>::Filled, <T5 as ComputationFn>::Filled, <T6 as ComputationFn>::Filled, <T7 as ComputationFn>::Filled, <T8 as ComputationFn>::Filled, <T9 as ComputationFn>::Filled, <T10 as ComputationFn>::Filled, <T11 as ComputationFn>::Filled, <T12 as ComputationFn>::Filled, <T13 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, T5: Debug, T6: Debug, T7: Debug, T8: Debug, T9: Debug, T10: Debug, T11: Debug, T12: Debug, T13: Debug> Debug for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

where Self: Computation,

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

Formats the value using the given formatter.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Display for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

where Self: Computation, T0: Display, T1: Display, T2: Display, T3: Display, T4: Display, T5: Display, T6: Display, T7: Display, T8: Display, T9: Display, T10: Display, T11: Display, T12: Display, T13: Display,

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

Formats the value using the given formatter.

impl<Rhs, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Div<Rhs> for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

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

type Output = Div<Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, 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, T5, T6, T7, T8, T9, T10, T11, T12, T13> Mul<Rhs> for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

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

type Output = Mul<Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, Rhs>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Neg for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

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

type Output = Neg<Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> RunCore for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

where Self: Computation, T0: RunCore, T1: RunCore, T2: RunCore, T3: RunCore, T4: RunCore, T5: RunCore, T6: RunCore, T7: RunCore, T8: RunCore, T9: RunCore, T10: RunCore, T11: RunCore, T12: RunCore, T13: RunCore,

type Output = (<T0 as RunCore>::Output, <T1 as RunCore>::Output, <T2 as RunCore>::Output, <T3 as RunCore>::Output, <T4 as RunCore>::Output, <T5 as RunCore>::Output, <T6 as RunCore>::Output, <T7 as RunCore>::Output, <T8 as RunCore>::Output, <T9 as RunCore>::Output, <T10 as RunCore>::Output, <T11 as RunCore>::Output, <T12 as RunCore>::Output, <T13 as RunCore>::Output)

fn run_core(self) -> Self::Output

impl<Rhs, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Sub<Rhs> for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

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

type Output = Sub<Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, 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, T5: Copy, T6: Copy, T7: Copy, T8: Copy, T9: Copy, T10: Copy, T11: Copy, T12: Copy, T13: Copy> Copy for Zip14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>

where Self: Computation,