Struct LessThanEqualTo

pub struct LessThanEqualTo {
    pub signed_comparison: bool,
}

A structure that defines the custom operation LessThanEqualTo that compares arrays of binary strings elementwise as follows:

If a and b are two bitstrings, then LessThanEqualTo(a,b) = 1 if a <= b and 0 otherwise.

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].

To compare signed numbers, signed_comparison should be set true.

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 LessThanEqualTo node

Example

let c = create_context().unwrap();
let g = c.create_graph().unwrap();
let t = array_type(vec![2, 3], BIT);
let n1 = g.input(t.clone()).unwrap();
let n2 = g.input(t.clone()).unwrap();
let n3 = g.custom_op(CustomOperation::new(LessThanEqualTo {signed_comparison: true}), vec![n1, n2]).unwrap();

Fields

signed_comparison: bool

Boolean value indicating whether input bitstring represent signed integers

Trait Implementations

impl CustomOperationBody for LessThanEqualTo

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 LessThanEqualTo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LessThanEqualTo

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for LessThanEqualTo

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 LessThanEqualTo

fn eq(&self, other: &LessThanEqualTo) -> bool

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

const 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 LessThanEqualTo

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 LessThanEqualTo

impl StructuralPartialEq for LessThanEqualTo