Enum ClOp 

#[non_exhaustive]
pub enum ClOp {
    INVALID,
    BitAnd,
    BitOr,
    BitXor,
    BitEq,
    BitNeq,
    BitNot,
    BitZero,
    BitOne,
    RegAnd,
    RegOr,
    RegXor,
    RegEq,
    RegNeq,
    RegNot,
    RegZero,
    RegOne,
    RegLt,
    RegGt,
    RegLeq,
    RegGeq,
    RegAdd,
    RegSub,
    RegMul,
    RegDiv,
    RegPow,
    RegLsh,
    RegRsh,
    RegNeg,
}

List of supported classical expressions.

Corresponds to pytket.circuit.ClOp.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

INVALID

Invalid operation

BitAnd

Bitwise AND

BitOr

Bitwise OR

BitXor

Bitwise XOR

BitEq

Bitwise equality

BitNeq

Bitwise inequality

BitNot

Bitwise NOT

BitZero

Constant zero bit

BitOne

Constant one bit

RegAnd

Registerwise AND

RegOr

Registerwise OR

RegXor

Registerwise XOR

RegEq

Registerwise equality

RegNeq

Registerwise inequality

RegNot

Registerwise NOT

RegZero

Constant all-zeros register

RegOne

Constant all-ones register

RegLt

Integer less-than comparison

RegGt

Integer greater-than comparison

RegLeq

Integer less-than-or-equal comparison

RegGeq

Integer greater-than-or-equal comparison

RegAdd

Integer addition

RegSub

Integer subtraction

RegMul

Integer multiplication

RegDiv

Integer division

RegPow

Integer exponentiation

RegLsh

Left shift

RegRsh

Right shift

RegNeg

Integer negation

Trait Implementations

impl Clone for ClOp

fn clone(&self) -> ClOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ClOp

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

Formats the value using the given formatter.

impl Default for ClOp

fn default() -> ClOp

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ClOp

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromStr for ClOp

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<ClOp, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for ClOp

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 ClOp

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for ClOp

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<ClOp, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl Eq for ClOp

impl StructuralPartialEq for ClOp