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),
}

Defines the individual logic gate operations we can support

Variants

Input(usize)

Read a value from input and emit it on the wire

Random(usize)

Emit a random value on the wire

Add(usize, usize, usize)

Add the two wires together

AddConst(usize, usize, T)

Add the wire and the constant

Sub(usize, usize, usize)

Subtract the final wire from the second wire

SubConst(usize, usize, T)

Subtract the constant value from the wire

Mul(usize, usize, usize)

Multiply the two wires together

MulConst(usize, usize, T)

Multiply the first wire by the constant value

AssertZero(usize)

Assert that the wire has the const value zero

Const(usize, T)

Emit the const value on the wire

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>

For gates that include constant data (AddConst, MulConst, etc) provides a method to access the constant. Returns None for all other types of gates.

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>, 

For convenience, allows access to the (optional) output, since each gate only ever has one at most.

impl Identity<bool> for Operation<bool>

fn is_identity(&self) -> bool

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

Used to produce an identity gate on the current field when needed.

impl Identity<u64> for Operation<u64>

fn is_identity(&self) -> bool

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

Used to produce an identity gate on the current field when needed.

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>, 

takes an iterator of input wires and an iterator of output wires, and creates a new gate of the same type using the inputs and outputs. The current input and output wires have no bearing on the new wires, just the gate type.

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>, 

Takes a hashmap, and looks for existing wires in the keys. Replaces any existing wire keys with the value from the hashmap.

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>, 

Calls a function on the I/O wires and replaces them with the output of the function.

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

impl Gate<bool> for Operation<bool>

impl Gate<u64> for Operation<u64>

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