Struct Dummy 

pub struct Dummy {}

Simple struct that performs the fancy computation over u16.

Implementations

impl Dummy

pub fn new() -> Dummy

Create a new Dummy.

Trait Implementations

impl Default for Dummy

fn default() -> Self

Returns the “default value” for a type.

impl Fancy for Dummy

type Item = DummyVal

The underlying wire datatype created by an object implementing Fancy.

fn constant( &mut self, val: u16, modulus: u16, _: &mut Channel<'_>, ) -> Result<DummyVal>

Create a constant x with modulus q.

fn output(&mut self, x: &DummyVal, _: &mut Channel<'_>) -> Result<Option<u16>>

Process this wire as output. Some Fancy implementers don’t actually return output, but they need to be involved in the process, so they can return None.

fn outputs( &mut self, xs: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Option<Vec<u16>>>

Output a slice of wires.

impl FancyArithmetic for Dummy

fn add(&mut self, x: &DummyVal, y: &DummyVal) -> DummyVal

Add x and y.

fn sub(&mut self, x: &DummyVal, y: &DummyVal) -> DummyVal

Subtract x and y.

fn cmul(&mut self, x: &DummyVal, c: u16) -> DummyVal

Multiply x times the constant c.

fn mul( &mut self, x: &DummyVal, y: &DummyVal, _: &mut Channel<'_>, ) -> Result<DummyVal>

Multiply x and y.

fn proj( &mut self, x: &DummyVal, modulus: u16, tt: Option<Vec<u16>>, _: &mut Channel<'_>, ) -> Result<DummyVal>

Project x according to the truth table tt. Resulting wire has modulus q.

fn add_many(&mut self, args: &[Self::Item]) -> Self::Item

Sum up a slice of wires.

fn mod_change( &mut self, x: &Self::Item, to_modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Change the modulus of x to to_modulus using a projection gate.

impl FancyBinary for Dummy

fn xor(&mut self, x: &Self::Item, y: &Self::Item) -> Self::Item

Binary Xor

fn and( &mut self, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Binary And

fn negate(&mut self, x: &Self::Item) -> Self::Item

Binary Not

fn or( &mut self, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Uses Demorgan’s Rule implemented with an and gate and negation.

fn adder( &mut self, x: &Self::Item, y: &Self::Item, carry_in: Option<&Self::Item>, channel: &mut Channel<'_>, ) -> Result<(Self::Item, Self::Item)>

Binary adder. Returns the result and the carry.

fn and_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if all wires equal 1.

fn or_many( &mut self, args: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Self::Item>

Returns 1 if any wire equals 1.

fn xor_many(&mut self, args: &[Self::Item]) -> Self::Item

XOR many wires together.

fn mux_constant_bits( &mut self, x: &Self::Item, b1: bool, b2: bool, channel: &mut Channel<'_>, ) -> Result<Self::Item>

If x = 0 returns the constant b1 else return b2. Folds constants if possible.

fn mux( &mut self, b: &Self::Item, x: &Self::Item, y: &Self::Item, channel: &mut Channel<'_>, ) -> Result<Self::Item>

If b = 0 returns x else y.

impl FancyInput for Dummy

fn encode( &mut self, value: u16, modulus: u16, _: &mut Channel<'_>, ) -> Result<DummyVal>

Encode a single dummy value.

fn encode_many( &mut self, xs: &[u16], moduli: &[u16], _: &mut Channel<'_>, ) -> Result<Vec<DummyVal>>

Encode a slice of inputs and a slice of moduli as DummyVals.

type Item = DummyVal

The type that this Fancy object operates over.

fn receive_many( &mut self, _moduli: &[u16], _: &mut Channel<'_>, ) -> Result<Vec<DummyVal>>

Receive many values where the input is not known.

fn receive( &mut self, modulus: u16, channel: &mut Channel<'_>, ) -> Result<Self::Item>

Receive a single value.

fn encode_bundle( &mut self, values: &[u16], moduli: &[u16], channel: &mut Channel<'_>, ) -> Result<Bundle<Self::Item>>

Encode a bundle.

fn receive_bundle( &mut self, moduli: &[u16], channel: &mut Channel<'_>, ) -> Result<Bundle<Self::Item>>

Receive a bundle.

fn encode_bundles( &mut self, values: &[Vec<u16>], moduli: &[Vec<u16>], channel: &mut Channel<'_>, ) -> Result<Vec<Bundle<Self::Item>>>

Encode many input bundles.

fn receive_many_bundles( &mut self, moduli: &[Vec<u16>], channel: &mut Channel<'_>, ) -> Result<Vec<Bundle<Self::Item>>>

Receive many input bundles.

fn crt_encode( &mut self, value: u128, modulus: u128, channel: &mut Channel<'_>, ) -> Result<CrtBundle<Self::Item>>

Encode a CRT input bundle.

fn crt_receive( &mut self, modulus: u128, channel: &mut Channel<'_>, ) -> Result<CrtBundle<Self::Item>>

Receive an CRT input bundle.

fn crt_encode_many( &mut self, values: &[u128], modulus: u128, channel: &mut Channel<'_>, ) -> Result<Vec<CrtBundle<Self::Item>>>

Encode many CRT input bundles.

fn crt_receive_many( &mut self, n: usize, modulus: u128, channel: &mut Channel<'_>, ) -> Result<Vec<CrtBundle<Self::Item>>>

Receive many CRT input bundles.

fn bin_encode( &mut self, value: u128, nbits: usize, channel: &mut Channel<'_>, ) -> Result<BinaryBundle<Self::Item>>

Encode a binary input bundle.

fn bin_receive( &mut self, nbits: usize, channel: &mut Channel<'_>, ) -> Result<BinaryBundle<Self::Item>>

Receive an binary input bundle.

fn bin_encode_many( &mut self, values: &[u128], nbits: usize, channel: &mut Channel<'_>, ) -> Result<Vec<BinaryBundle<Self::Item>>>

Encode many binary input bundles.

fn bin_receive_many( &mut self, ninputs: usize, nbits: usize, channel: &mut Channel<'_>, ) -> Result<Vec<BinaryBundle<Self::Item>>>

Receive many binary input bundles.

impl FancyReveal for Dummy

fn reveal(&mut self, x: &DummyVal, _: &mut Channel<'_>) -> Result<u16>

Reveal the contents of x to all parties.

fn reveal_many( &mut self, xs: &[Self::Item], channel: &mut Channel<'_>, ) -> Result<Vec<u16>>

Reveal a slice of items to all parties.

fn reveal_bundle( &mut self, x: &Bundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<Vec<u16>>

Reveal a bundle to all parties.

fn reveal_many_bundles( &mut self, xs: &[Bundle<Self::Item>], channel: &mut Channel<'_>, ) -> Result<Vec<Vec<u16>>>

Reveal many bundles to all parties.

fn crt_reveal( &mut self, x: &CrtBundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<u128>

Reveal a CRT bundle to all parties.

fn crt_reveal_many( &mut self, xs: &[CrtBundle<Self::Item>], channel: &mut Channel<'_>, ) -> Result<Vec<u128>>

Reveal many CRT bundles to all parties.

fn bin_reveal( &mut self, x: &BinaryBundle<Self::Item>, channel: &mut Channel<'_>, ) -> Result<u128>

Reveal a binary bundle to all parties.

fn bin_reveal_many( &mut self, xs: &[BinaryBundle<Self::Item>], channel: &mut Channel<'_>, ) -> Result<Vec<u128>>

Reveal many binary bundles to all parties.