Enum 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 = 10usize

Trait Implementations

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

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

Returns a duplicate 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> Deserialize<'de> for Operation<T>

where T: Deserialize<'de> + WireValue,

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

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

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

Converts to this type from the input type.

impl From<Operation<u64>> for CombineOperation

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

Converts to this type from the input type.

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 for Operation<T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Operation<T>

where T: Serialize + WireValue,

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>