Struct Expression 

pub struct Expression { /* private fields */ }

A symbolic mathematical expression.

This type wraps egg’s RecExpr and provides a user-friendly API for symbolic computation.

Implementations

impl Expression

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

Create a new symbolic variable

Example

use quantrs2_symengine_pure::Expression;
let x = Expression::symbol("x");

pub fn int(value: i64) -> Self

Create an integer constant

pub fn float(value: f64) -> SymEngineResult<Self>

Create a floating-point constant

Errors

Returns an error if the value is NaN

pub fn float_unchecked(value: f64) -> Self

Create a floating-point constant, using 0 for NaN

pub fn zero() -> Self

Create the constant zero

pub fn one() -> Self

Create the constant one

pub fn i() -> Self

Create the imaginary unit i

pub fn pi() -> Self

Create the constant π

pub fn e() -> Self

Create the constant e (Euler’s number)

pub fn from_complex64(c: Complex64) -> Self

Create from a complex number

If imaginary part is negligible, returns just the real part.

pub fn parse(input: &str) -> SymEngineResult<Self>

Parse an expression from a string

Errors

Returns an error if parsing fails

pub fn new(input: impl AsRef<str>) -> Self

Create an expression from a string (alias for parse)

pub fn is_symbol(&self) -> bool

Check if this expression is a symbol (variable or number literal)

pub fn is_number(&self) -> bool

Check if this expression is a number

pub fn is_zero(&self) -> bool

Check if this expression is zero

pub fn is_one(&self) -> bool

Check if this expression is one

pub fn as_symbol(&self) -> Option<&str>

Get the symbol name if this is a symbol

pub fn to_f64(&self) -> Option<f64>

Convert to f64 if this is a numeric constant

pub fn to_i64(&self) -> Option<i64>

Convert to i64 if this is an integer constant

pub fn is_add(&self) -> bool

Check if this expression is an addition operation

pub fn is_mul(&self) -> bool

Check if this expression is a multiplication operation

pub fn is_pow(&self) -> bool

Check if this expression is a power operation

pub fn is_neg(&self) -> bool

Check if this expression is a negation operation

pub fn as_neg(&self) -> Option<Self>

Get the inner expression if this is a negation

pub fn as_add(&self) -> Option<Vec<Self>>

Get the operands if this is an addition operation

pub fn as_mul(&self) -> Option<Vec<Self>>

Get the operands if this is a multiplication operation

pub fn as_pow(&self) -> Option<(Self, Self)>

Get the base and exponent if this is a power operation

pub fn add(&self, other: &Self) -> Self

Add two expressions

pub fn sub(&self, other: &Self) -> Self

Subtract two expressions

pub fn mul(&self, other: &Self) -> Self

Multiply two expressions

pub fn div(&self, other: &Self) -> Self

Divide two expressions

pub fn pow(&self, exp: &Self) -> Self

Raise to a power

pub fn neg(&self) -> Self

Negate the expression

pub fn conjugate(&self) -> Self

Complex conjugate

pub fn diff(&self, var: &Self) -> Self

Compute the derivative with respect to a variable

pub fn gradient(&self, vars: &[Self]) -> Vec<Self>

Compute the gradient with respect to multiple variables

pub fn hessian(&self, vars: &[Self]) -> Vec<Vec<Self>>

Compute the Hessian matrix (second derivatives)

pub fn expand(&self) -> Self

Expand the expression (distribute products over sums)

pub fn simplify(&self) -> Self

Simplify the expression

pub fn eval(&self, values: &HashMap<String, f64>) -> SymEngineResult<f64>

Evaluate the expression with given variable values

Errors

Returns an error if a variable is not found in the values map

pub fn eval_complex( &self, values: &HashMap<String, f64>, ) -> SymEngineResult<Complex64>

Evaluate the expression to a complex number.

This can handle expressions containing the imaginary unit I, which is essential for quantum computing applications.

Arguments

• values - Map of variable names to real values

Returns

The complex result of the evaluation.

Errors

Returns an error if a variable is not found in the values map

pub fn substitute(&self, var: &Self, value: &Self) -> Self

Substitute a variable with an expression

pub fn substitute_many(&self, values: &HashMap<Self, Self>) -> Self

Substitute multiple variables

Trait Implementations

impl Add for Expression

type Output = Expression

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Display for Expression

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

Formats the value using the given formatter.

impl Div for Expression

type Output = Expression

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl From<Complex<f64>> for Expression

fn from(c: Complex64) -> Self

Converts to this type from the input type.

impl From<f64> for Expression

fn from(f: f64) -> Self

Converts to this type from the input type.

impl From<i32> for Expression

fn from(n: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Expression

fn from(n: i64) -> Self

Converts to this type from the input type.

impl Hash for Expression

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 Mul for Expression

type Output = Expression

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Neg for Expression

type Output = Expression

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Expression

fn eq(&self, other: &Self) -> 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 Sub for Expression

type Output = Expression

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl Eq for Expression