Struct Ge

pub struct Ge<A, B>(pub A, pub B)
where
    Self: Computation;

Tuple Fields

0: A

1: B

Trait Implementations

impl<Rhs, A, B> Add<Rhs> for Ge<A, B>

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

type Output = Add<Ge<A, B>, Rhs>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<A: Clone, B: Clone> Clone for Ge<A, B>

where Self: Computation,

fn clone(&self) -> Ge<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A, B> Computation for Ge<A, B>

where A: Computation<Dim = Zero>, B: Computation<Dim = Zero>, A::Item: PartialOrd<B::Item>,

type Dim = Zero

type Item = bool

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 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 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<A, B> ComputationFn for Ge<A, B>

where Self: Computation, A: ComputationFn, B: ComputationFn, Ge<A::Filled, B::Filled>: Computation,

type Filled = Ge<<A as ComputationFn>::Filled, <B 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<A: Debug, B: Debug> Debug for Ge<A, B>

where Self: Computation,

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

Formats the value using the given formatter.

impl<A, B> Display for Ge<A, B>

where Self: Computation, A: Display, B: Display,

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

Formats the value using the given formatter.

impl<Rhs, A, B> Div<Rhs> for Ge<A, B>

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

type Output = Div<Ge<A, B>, Rhs>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Rhs, A, B> Mul<Rhs> for Ge<A, B>

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

type Output = Mul<Ge<A, B>, Rhs>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<A, B> Neg for Ge<A, B>

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

type Output = Neg<Ge<A, B>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, B> RunCore for Ge<A, B>

where Self: Computation, A: RunCore, B: RunCore, A::Output: PartialOrd<B::Output>,

type Output = bool

fn run_core(self) -> Self::Output

impl<Rhs, A, B> Sub<Rhs> for Ge<A, B>

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

type Output = Sub<Ge<A, B>, Rhs>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<A: Copy, B: Copy> Copy for Ge<A, B>

where Self: Computation,