Enum Expr 

pub enum Expr {
    Const(f64),
    Var(&'static str),
    Add(Box<Expr>, Box<Expr>),
    Mul(Box<Expr>, Box<Expr>),
    Pow(Box<Expr>, Box<Expr>),
    Exp(Box<Expr>),
    Log(Box<Expr>),
    Sqrt(Box<Expr>),
}

A symbolic math expression over problem size variables.

Variants

Const(f64)

Numeric constant.

Var(&'static str)

Named variable (e.g., “num_vertices”).

Add(Box<Expr>, Box<Expr>)

Addition: a + b.

Mul(Box<Expr>, Box<Expr>)

Multiplication: a * b.

Pow(Box<Expr>, Box<Expr>)

Exponentiation: base ^ exponent.

Exp(Box<Expr>)

Exponential function: exp(a).

Log(Box<Expr>)

Natural logarithm: log(a).

Sqrt(Box<Expr>)

Square root: sqrt(a).

Implementations

impl Expr

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

Convenience constructor for exponentiation.

pub fn scale(self, c: f64) -> Self

Multiply expression by a scalar constant.

pub fn eval(&self, vars: &ProblemSize) -> f64

Evaluate the expression given concrete variable values.

pub fn variables(&self) -> HashSet<&'static str>

Collect all variable names referenced in this expression.

pub fn substitute(&self, mapping: &HashMap<&str, &Expr>) -> Expr

Substitute variables with other expressions.

pub fn parse(input: &str) -> Expr

Parse an expression string into an Expr at runtime.

Memory note: Variable names are leaked to &'static str via Box::leak since Expr::Var requires static lifetimes. Each unique variable name leaks a small allocation that is never freed. This is acceptable for testing and one-time cross-check evaluation, but should not be used in hot loops with dynamic input.

Panics

Panics if the expression string has invalid syntax.

pub fn try_parse(input: &str) -> Result<Expr, String>

Parse an expression string into an Expr, returning a normal error on failure.

pub fn is_polynomial(&self) -> bool

Check if this expression is a polynomial (no exp/log/sqrt, integer exponents only).

pub fn is_valid_complexity_notation(&self) -> bool

Check whether this expression is suitable for asymptotic complexity notation.

This is intentionally conservative for symbolic size formulas:

• rejects explicit multiplicative constant factors like 3 * n
• rejects additive constant terms like n + 1
• allows constants used as exponents (e.g. n^(1/3))
• allows constants used as exponential bases (e.g. 2^n)

The goal is to accept expressions that already look like reduced asymptotic notation, rather than exact-count formulas.

Trait Implementations

impl Add for Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Deserialize<'static> for Expr

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

where __D: Deserializer<'static>,

Deserialize this value from the given Serde deserializer.

impl Display for Expr

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

Formats the value using the given formatter.

impl Div for Expr

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Mul for Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Expr

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl StructuralPartialEq for Expr