Struct Zip15

pub struct Zip15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(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, pub T14)
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

14: T14

Trait Implementations

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

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

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

where Self: Computation,

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

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, T14> Computation for Zip15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

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, T14: 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, <T14 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, <T14 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, T14> ComputationFn for Zip15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

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, T14: ComputationFn, Zip15<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, T14::Filled>: Computation,

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

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, T14> Display for Zip15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

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, T14: 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, T14> Div<Rhs> for Zip15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

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

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

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

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

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

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

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, T14> RunCore for Zip15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

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, T14: 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, <T14 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, T14> Sub<Rhs> for Zip15<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>

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

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

where Self: Computation,