Struct Zip9

pub struct Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>(pub T0, pub T1, pub T2, pub T3, pub T4, pub T5, pub T6, pub T7, pub T8)
where
    Self: Computation;

Tuple Fields

0: T0

1: T1

2: T2

3: T3

4: T4

5: T5

6: T6

7: T7

8: T8

Trait Implementations

impl<Rhs, T0, T1, T2, T3, T4, T5, T6, T7, T8> Add<Rhs> for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

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

type Output = Add<Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>, 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> Clone for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

where Self: Computation,

fn clone(&self) -> Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

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> Computation for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

where T0: Computation, T1: Computation, T2: Computation, T3: Computation, T4: Computation, T5: Computation, T6: Computation, T7: Computation, T8: 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)

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)

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> ComputationFn for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

where Self: Computation, T0: ComputationFn, T1: ComputationFn, T2: ComputationFn, T3: ComputationFn, T4: ComputationFn, T5: ComputationFn, T6: ComputationFn, T7: ComputationFn, T8: ComputationFn, Zip9<T0::Filled, T1::Filled, T2::Filled, T3::Filled, T4::Filled, T5::Filled, T6::Filled, T7::Filled, T8::Filled>: Computation,

type Filled = Zip9<<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>

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> Debug for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

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> Display for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

where Self: Computation, T0: Display, T1: Display, T2: Display, T3: Display, T4: Display, T5: Display, T6: Display, T7: Display, T8: 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> Div<Rhs> for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

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

type Output = Div<Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>, 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> Mul<Rhs> for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

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

type Output = Mul<Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>, 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> Neg for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

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

type Output = Neg<Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>>

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> RunCore for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

where Self: Computation, T0: RunCore, T1: RunCore, T2: RunCore, T3: RunCore, T4: RunCore, T5: RunCore, T6: RunCore, T7: RunCore, T8: 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)

fn run_core(self) -> Self::Output

impl<Rhs, T0, T1, T2, T3, T4, T5, T6, T7, T8> Sub<Rhs> for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

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

type Output = Sub<Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>, 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> Copy for Zip9<T0, T1, T2, T3, T4, T5, T6, T7, T8>

where Self: Computation,