Struct If

pub struct If<A, ArgNames, P, FTrue, FFalse>
where
    Self: Computation,
{
    pub child: A,
    pub arg_names: ArgNames,
    pub predicate: P,
    pub f_true: FTrue,
    pub f_false: FFalse,
}

Fields

child: A

arg_names: ArgNames

predicate: P

f_true: FTrue

f_false: FFalse

Trait Implementations

impl<Rhs, A, ArgNames, P, FTrue, FFalse> Add<Rhs> for If<A, ArgNames, P, FTrue, FFalse>

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

type Output = Add<If<A, ArgNames, P, FTrue, FFalse>, Rhs>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<A: Clone, ArgNames: Clone, P: Clone, FTrue: Clone, FFalse: Clone> Clone for If<A, ArgNames, P, FTrue, FFalse>

where Self: Computation,

fn clone(&self) -> If<A, ArgNames, P, FTrue, FFalse>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, ArgNames, P, FTrue, FFalse, FDim, FItem> Computation for If<A, ArgNames, P, FTrue, FFalse>

where A: Computation, P: ComputationFn<Dim = Zero, Item = bool>, FTrue: ComputationFn<Dim = FDim, Item = FItem>, FFalse: ComputationFn<Dim = FDim, Item = FItem>,

type Dim = FDim

type Item = FItem

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 max(self) -> Max<Self>

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

fn not(self) -> Not<Self>

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

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

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

fn sum(self) -> Sum<Self>

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

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

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

fn fst(self) -> Fst<Self>

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

fn snd(self) -> Snd<Self>

where Self: Sized, Snd<Self>: 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.

fn len(self) -> Len<Self>

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

impl<A, ArgNames, P, FTrue, FFalse> ComputationFn for If<A, ArgNames, P, FTrue, FFalse>

where Self: Computation, A: ComputationFn, If<A::Filled, ArgNames, P, FTrue, FFalse>: Computation,

type Filled = If<<A as ComputationFn>::Filled, ArgNames, P, FTrue, FFalse>

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

Fill arguments will values, replacing Args with Vals.

fn arg_names(&self) -> Names

impl<A: Debug, ArgNames: Debug, P: Debug, FTrue: Debug, FFalse: Debug> Debug for If<A, ArgNames, P, FTrue, FFalse>

where Self: Computation,

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

Formats the value using the given formatter.

impl<A, ArgNames, P, FTrue, FFalse> Display for If<A, ArgNames, P, FTrue, FFalse>

where Self: Computation, A: Display, ArgNames: Debug, P: Display, FTrue: Display, FFalse: Display,

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

Formats the value using the given formatter.

impl<Rhs, A, ArgNames, P, FTrue, FFalse> Div<Rhs> for If<A, ArgNames, P, FTrue, FFalse>

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

type Output = Div<If<A, ArgNames, P, FTrue, FFalse>, Rhs>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs, A, ArgNames, P, FTrue, FFalse> Mul<Rhs> for If<A, ArgNames, P, FTrue, FFalse>

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

type Output = Mul<If<A, ArgNames, P, FTrue, FFalse>, Rhs>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<A, ArgNames, P, FTrue, FFalse> Neg for If<A, ArgNames, P, FTrue, FFalse>

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

type Output = Neg<If<A, ArgNames, P, FTrue, FFalse>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, ArgNames, P, FTrue, FFalse, Collected, Out> RunCore for If<A, ArgNames, P, FTrue, FFalse>

where Self: Computation, A: Computation + RunCore, A::Output: Collect<A::Dim, Collected = Collected>, Collected: Clone, ArgNames: Clone, (ArgNames, Collected): Into<NamedArgs>, P: ComputationFn, P::Filled: Run<Output = bool>, FTrue: ComputationFn, FTrue::Filled: RunCore, <FTrue::Filled as RunCore>::Output: Collect<FTrue::Dim, Collected = Out>, FFalse: ComputationFn, FFalse::Filled: RunCore, <FFalse::Filled as RunCore>::Output: Collect<FFalse::Dim, Collected = Out>,

type Output = Out

fn run_core(self) -> Self::Output

impl<Rhs, A, ArgNames, P, FTrue, FFalse> Sub<Rhs> for If<A, ArgNames, P, FTrue, FFalse>

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

type Output = Sub<If<A, ArgNames, P, FTrue, FFalse>, Rhs>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<A: Copy, ArgNames: Copy, P: Copy, FTrue: Copy, FFalse: Copy> Copy for If<A, ArgNames, P, FTrue, FFalse>

where Self: Computation,