Enum mcircuit::Operation

pub enum Operation<T: WireValue> {
    Input(usize),
    Random(usize),
    Add(usize, usize, usize),
    AddConst(usize, usize, T),
    Sub(usize, usize, usize),
    SubConst(usize, usize, T),
    Mul(usize, usize, usize),
    MulConst(usize, usize, T),
    AssertZero(usize),
    Const(usize, T),
}

Variants

Input

Read a value from input and emit it on the wire

Tuple Fields of Input

0: usize

Random

Emit a random value on the wire

Tuple Fields of Random

0: usize

Add

Tuple Fields of Add

0: usize1: usize2: usize

AddConst

Tuple Fields of AddConst

0: usize1: usize2: T

Sub

Subtract the final wire from the second wire

Tuple Fields of Sub

0: usize1: usize2: usize

SubConst

Tuple Fields of SubConst

0: usize1: usize2: T

Mul

Tuple Fields of Mul

0: usize1: usize2: usize

MulConst

Tuple Fields of MulConst

0: usize1: usize2: T

AssertZero

Assert that the wire has the const value zero

Tuple Fields of AssertZero

0: usize

Const

Emit the const value on the wire

Tuple Fields of Const

0: usize1: T

Implementations

impl<T: WireValue> Operation<T>

pub const VARIANT_COUNT: usize

Trait Implementations

impl<T: Clone + WireValue> Clone for Operation<T>

fn clone(&self) -> Operation<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + WireValue> Debug for Operation<T>

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

Formats the value using the given formatter.

impl<'de, T: WireValue> Deserialize<'de> for Operation<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: WireValue> Distribution<Operation<T>> for Standard where
    Standard: Distribution<(usize, usize, usize, T)>, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Operation<T>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S> where
    F: Fn(T) -> S, 

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl From<Operation<bool>> for CombineOperation

fn from(op: Operation<bool>) -> Self

Performs the conversion.

impl From<Operation<u64>> for CombineOperation

fn from(op: Operation<u64>) -> Self

Performs the conversion.

impl<T: WireValue> HasConst<T> for Operation<T>

fn constant(&self) -> Option<T>

impl<T: WireValue> HasIO for Operation<T>

fn inputs(&self) -> InputIterator<'_, Operation<T>>

fn outputs(&self) -> OutputIterator<'_, Operation<T>>

fn dst<'a>(&'a self) -> Option<usize> where
    Self: 'a + Sized,
    OutputIterator<'a, Self>: Iterator<Item = usize>, 

impl Identity<bool> for Operation<bool>

fn is_identity(&self) -> bool

fn identity(w_out: usize, w_in: usize) -> Self

impl Identity<u64> for Operation<u64>

fn is_identity(&self) -> bool

fn identity(w_out: usize, w_in: usize) -> Self

impl<T: PartialEq + WireValue> PartialEq<Operation<T>> for Operation<T>

fn eq(&self, other: &Operation<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Operation<T>) -> bool

This method tests for !=.

impl<T: WireValue> Serialize for Operation<T> where
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T: WireValue> Translatable for Operation<T>

fn translate<'a, I1, I2>(&self, win: I1, wout: I2) -> Option<Self> where
    Self: Sized,
    I1: Iterator<Item = usize>,
    I2: Iterator<Item = usize>, 

fn translate_from_hashmap<'a>(
    &'a self,
    translation_table: HashMap<usize, usize>
) -> Option<Self> where
    Self: Sized + HasIO,
    InputIterator<'a, Self>: Iterator<Item = usize>,
    OutputIterator<'a, Self>: Iterator<Item = usize>, 

fn translate_from_fn<'a>(
    &'a self,
    input_mapper: fn(_: usize) -> usize,
    output_mapper: fn(_: usize) -> usize
) -> Option<Self> where
    Self: Sized + HasIO,
    InputIterator<'a, Self>: Iterator<Item = usize>,
    OutputIterator<'a, Self>: Iterator<Item = usize>, 

impl Gate<bool> for Operation<bool>

impl Gate<u64> for Operation<u64>

impl<T: WireValue> StructuralPartialEq for Operation<T>