Enum Pattern 

pub enum Pattern {
    Wildcard(String),
    Constant(f64),
    Symbol(String),
    Zero,
    One,
    Add(Box<Self>, Box<Self>),
    Mul(Box<Self>, Box<Self>),
    Pow(Box<Self>, Box<Self>),
    Neg(Box<Self>),
    Sin(Box<Self>),
    Cos(Box<Self>),
    Exp(Box<Self>),
    Log(Box<Self>),
    Commutator(Box<Self>, Box<Self>),
    Anticommutator(Box<Self>, Box<Self>),
    TensorProduct(Box<Self>, Box<Self>),
    Dagger(Box<Self>),
}

A pattern that can match against expressions.

Variants

Wildcard(String)

Match any expression and capture it

Constant(f64)

Match a specific constant

Symbol(String)

Match a specific symbol

Zero

Match zero

One

Match one

Add(Box<Self>, Box<Self>)

Match an addition pattern

Mul(Box<Self>, Box<Self>)

Match a multiplication pattern

Pow(Box<Self>, Box<Self>)

Match a power pattern

Neg(Box<Self>)

Match a negation pattern

Sin(Box<Self>)

Match a sine pattern

Cos(Box<Self>)

Match a cosine pattern

Exp(Box<Self>)

Match an exponential pattern

Log(Box<Self>)

Match a logarithm pattern

Commutator(Box<Self>, Box<Self>)

Match a commutator pattern

Anticommutator(Box<Self>, Box<Self>)

Match an anticommutator pattern

TensorProduct(Box<Self>, Box<Self>)

Match a tensor product pattern

Dagger(Box<Self>)

Match a dagger pattern

Implementations

impl Pattern

pub fn wildcard(name: &str) -> Self

Create a wildcard pattern with the given name

pub fn symbol(name: &str) -> Self

Create a symbol pattern

pub const fn constant(value: f64) -> Self

Create a constant pattern

pub fn add(left: Self, right: Self) -> Self

Create an addition pattern

pub fn mul(left: Self, right: Self) -> Self

Create a multiplication pattern

pub fn pow(base: Self, exp: Self) -> Self

Create a power pattern

pub fn sin(arg: Self) -> Self

Create a sine pattern

pub fn cos(arg: Self) -> Self

Create a cosine pattern

pub fn commutator(a: Self, b: Self) -> Self

Create a commutator pattern [A, B]

pub fn anticommutator(a: Self, b: Self) -> Self

Create an anticommutator pattern {A, B}

pub fn tensor(a: Self, b: Self) -> Self

Create a tensor product pattern A ⊗ B

pub fn dagger(a: Self) -> Self

Create a dagger pattern A†

Trait Implementations

impl Clone for Pattern

fn clone(&self) -> Pattern

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Pattern

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

Formats the value using the given formatter.