Trait fancy_garbling::BinaryGadgets

source · [−]
pub trait BinaryGadgets: FancyBinary + BundleGadgets {

Show 26 methods    fn bin_constant_bundle(
        &mut self,
        val: u128,
        nbits: usize
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_output(
        &mut self,
        x: &BinaryBundle<Self::Item>
    ) -> Result<Option<u128>, Self::Error> { ... }
    fn bin_outputs(
        &mut self,
        xs: &[BinaryBundle<Self::Item>]
    ) -> Result<Option<Vec<u128>>, Self::Error> { ... }
    fn bin_xor(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        y: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_and(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        y: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_or(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        y: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_addition(
        &mut self,
        xs: &BinaryBundle<Self::Item>,
        ys: &BinaryBundle<Self::Item>
    ) -> Result<(BinaryBundle<Self::Item>, Self::Item), Self::Error> { ... }
    fn bin_addition_no_carry(
        &mut self,
        xs: &BinaryBundle<Self::Item>,
        ys: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_multiplication_lower_half(
        &mut self,
        xs: &BinaryBundle<Self::Item>,
        ys: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_mul(
        &mut self,
        xs: &BinaryBundle<Self::Item>,
        ys: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_div(
        &mut self,
        xs: &BinaryBundle<Self::Item>,
        ys: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_twos_complement(
        &mut self,
        xs: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_subtraction(
        &mut self,
        xs: &BinaryBundle<Self::Item>,
        ys: &BinaryBundle<Self::Item>
    ) -> Result<(BinaryBundle<Self::Item>, Self::Item), Self::Error> { ... }
    fn bin_multiplex_constant_bits(
        &mut self,
        x: &Self::Item,
        c1: u128,
        c2: u128,
        nbits: usize
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_multiplex(
        &mut self,
        b: &Self::Item,
        x: &BinaryBundle<Self::Item>,
        y: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_cmul(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        c: u128,
        nbits: usize
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_abs(
        &mut self,
        x: &BinaryBundle<Self::Item>
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_lt_signed(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        y: &BinaryBundle<Self::Item>
    ) -> Result<Self::Item, Self::Error> { ... }
    fn bin_lt(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        y: &BinaryBundle<Self::Item>
    ) -> Result<Self::Item, Self::Error> { ... }
    fn bin_geq(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        y: &BinaryBundle<Self::Item>
    ) -> Result<Self::Item, Self::Error> { ... }
    fn bin_max(
        &mut self,
        xs: &[BinaryBundle<Self::Item>]
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_demux(
        &mut self,
        x: &BinaryBundle<Self::Item>
    ) -> Result<Vec<Self::Item>, Self::Error> { ... }
    fn bin_rsa(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        c: usize
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_rsl(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        c: usize
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_shr(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        c: usize,
        pad: &Self::Item
    ) -> Result<BinaryBundle<Self::Item>, Self::Error> { ... }
    fn bin_eq_bundles(
        &mut self,
        x: &BinaryBundle<Self::Item>,
        y: &BinaryBundle<Self::Item>
    ) -> Result<Self::Item, Self::Error> { ... }

}
Expand description

Extension trait for Fancy providing gadgets that operate over bundles of mod2 wires.

Provided Methods

Create a constant bundle using base 2 inputs.

Output a binary bundle and interpret the result as a u128.

Output a slice of binary bundles and interpret the results as a u128.

Xor the bits of two bundles together pairwise.

And the bits of two bundles together pairwise.

Or the bits of two bundles together pairwise.

Binary addition. Returns the result and the carry.

Binary addition. Avoids creating extra gates for the final carry.

Binary multiplication.

Returns the lower-order half of the output bits, ie a number with the same number of bits as the inputs.

Full multiplier

Divider

Compute the twos complement of the input bundle (which must be base 2).

Subtract two binary bundles. Returns the result and whether it underflowed.

Due to the way that twos_complement(0) = 0, underflow indicates y != 0 && x >= y.

If x=0 return c1 as a bundle of constant bits, else return c2.

Multiplex gadget for binary bundles

Write the constant in binary and that gives you the shift amounts, Eg.. 7x is 4x+2x+x.

Compute the absolute value of a binary bundle.

Returns 1 if x < y (signed version)

Returns 1 if x < y.

Returns 1 if x >= y.

Compute the maximum bundle in xs.

Demux a binary bundle into a unary vector.

arithmetic right shift (shifts the sign of the MSB into the new spaces)

logical right shift (shifts 0 into the empty spaces)

shift a value right by a constant, filling space on the right by pad

Compute x == y for binary bundles.

Implementors