Struct BinaryAdd

pub struct BinaryAdd {
    pub overflow_bit: bool,
}

A structure that defines the custom operation BinaryAdd that implements the binary adder.

The binary adder takes two arrays of length-n bitstrings and returns the elementwise binary sum of these arrays. If overflow_bit is true, the output is a tuple (sum, overflow_bit) instead.

Only n which are powers of two are supported.

The last dimension of both inputs must be the same; it defines the length of input bitstrings. If input shapes are different, the broadcasting rules are applied (see the NumPy broadcasting rules). For example, if input arrays are of shapes [2,3], and [1,3], the resulting array has shape [2,3].

This operation is needed for conversion between arithmetic and boolean additive MPC shares (i.e. A2B and B2A operations in MPC).

To use this and other custom operations in computation graphs, see Graph::custom_op.

Custom operation arguments

• Node containing a binary array or scalar
• Node containing a binary array or scalar

Custom operation returns

New BinaryAdd node

Example

let c = create_context().unwrap();
let g = c.create_graph().unwrap();
let t = array_type(vec![2, 4], BIT);
let n1 = g.input(t.clone()).unwrap();
let n2 = g.input(t.clone()).unwrap();
let n3 = g.custom_op(CustomOperation::new(BinaryAdd { overflow_bit: false }), vec![n1, n2]).unwrap();

Fields

overflow_bit: bool

Trait Implementations

impl CustomOperationBody for BinaryAdd

fn instantiate( &self, context: Context, arguments_types: Vec<Type>, ) -> Result<Graph>

Defines the logic of a custom operation.

fn get_name(&self) -> String

Specifies and returns the name of this custom operation.

impl Debug for BinaryAdd

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BinaryAdd

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for BinaryAdd

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BinaryAdd

fn eq(&self, other: &BinaryAdd) -> 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 Serialize for BinaryAdd

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BinaryAdd

impl StructuralPartialEq for BinaryAdd