Struct Mux

pub struct Mux {}

A structure that defines the custom operation Mux that takes three inputs a, b, c and returns b if a is 1 or c if a is 0.

The input a should be arrays of bitstrings. The inputs b and c must have the same type. This operation is applied elementwise.

If input shapes are different, the broadcasting rules are applied (see the NumPy broadcasting rules). For example, if a,b,c are of shapes [2,3], [1,3] and [2,1], the resulting array has shape [2,3].

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 that will be chosen if the first input is 1
• Node containing a binary array or scalar that will be chosen if the first input is 0

Custom operation returns

New Mux node

Example

let c = create_context().unwrap();
let g = c.create_graph().unwrap();
let t1 = array_type(vec![2, 3], BIT);
let t2 = array_type(vec![3], BIT);
let n1 = g.input(t1.clone()).unwrap();
let n2 = g.input(t1.clone()).unwrap();
let n3 = g.input(t2.clone()).unwrap();
let n4 = g.custom_op(CustomOperation::new(Mux {}), vec![n1, n2, n3]).unwrap();

Trait Implementations

impl CustomOperationBody for Mux

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 Mux

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Mux

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Mux

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 Mux

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

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 Mux

impl StructuralPartialEq for Mux