Struct LongDivision 

pub struct LongDivision {
    pub signed: bool,
}

A structure that defines the custom operation LongDivision that computes the quotient and remainder of dividend / divisor, such that: quotient * divisor + remainder == dividend

Custom operation arguments

• Node containing the dividend as a two’s complement length-n bitstring.
• Node containing the divisor as a two’s complement length-n bitstring.

Only n which are powers of two are supported.

Custom operation returns

Node containing the (quotient, remainder) tuple. Both quotient and remainder are bitstrings with lengths equal to dividend and divisor, respectively.

Example

let t = array_type(vec![10, 25], INT32);
let c = simple_context(|g| {
    let input_dividends = g.input(t.clone())?;
    let input_divisors = g.input(t.clone())?;
    let binary_dividends = input_dividends.a2b()?;
    let binary_divisors = input_divisors.a2b()?;
    let result = g.custom_op(
        CustomOperation::new(LongDivision {
            signed: true,
        }),
        vec![binary_dividends, binary_divisors],
    )?;
    let quotient = result.tuple_get(0)?.b2a(INT32)?;
    let remainder = result.tuple_get(1)?.b2a(INT32)?;
    g.create_tuple(vec![quotient, remainder])
}).unwrap();

Fields

signed: bool

Trait Implementations

impl CustomOperationBody for LongDivision

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 LongDivision

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LongDivision

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for LongDivision

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 LongDivision

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

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 LongDivision

impl StructuralPartialEq for LongDivision