Enum SymExpr 

pub enum SymExpr {
    Value(i32),
    Var(Rc<Symbol>),
    Add((Rc<SymExpr>, Rc<SymExpr>)),
    Sub((Rc<SymExpr>, Rc<SymExpr>)),
    Mul((Rc<SymExpr>, Rc<SymExpr>)),
    Div((Rc<SymExpr>, Rc<SymExpr>)),
    DivCeil((Rc<SymExpr>, Rc<SymExpr>)),
    Max((Rc<SymExpr>, Rc<SymExpr>)),
    Min((Rc<SymExpr>, Rc<SymExpr>)),
    Broadcast((Rc<SymExpr>, Rc<SymExpr>)),
    Neg(Rc<SymExpr>),
}

Symbolic expression representing an integer value.

Expressions can be known integer values, named symbols or composite expressions.

Variants

Value(i32)

Element with a known integer value.

Var(Rc<Symbol>)

Symbolic value

Add((Rc<SymExpr>, Rc<SymExpr>))

Addition of two symbolic values

Sub((Rc<SymExpr>, Rc<SymExpr>))

Subtraction of two symbolic values

Mul((Rc<SymExpr>, Rc<SymExpr>))

Multiplication of two symbolic values

Div((Rc<SymExpr>, Rc<SymExpr>))

Flooring division of first expression by second.

DivCeil((Rc<SymExpr>, Rc<SymExpr>))

Ceiling division of first expression by second.

Max((Rc<SymExpr>, Rc<SymExpr>))

Maximum of two symbolic values

Min((Rc<SymExpr>, Rc<SymExpr>))

Minimum of two symbolic values

Broadcast((Rc<SymExpr>, Rc<SymExpr>))

Broadcast two symbolic values.

This behaves like Max, except it implies that both expressions are positive and either equal or 1.

Neg(Rc<SymExpr>)

Negation of a value

Implementations

impl SymExpr

pub fn range(&self) -> (i32, i32)

Return the range of possible values this element may have.

pub fn is_positive(&self) -> bool

Return true if the value of this expression is known to be >= 0.

pub fn max(&self, other: &SymExpr) -> SymExpr

Return the maximum of self and other.

pub fn min(&self, other: &SymExpr) -> SymExpr

Return the minimum of self and other.

pub fn broadcast(&self, other: &SymExpr) -> SymExpr

Return the result of broadcasting self and other.

pub fn div_ceil(&self, other: &SymExpr) -> SymExpr

Return the result of dividing self by other, rounded up.

pub fn simplify(&self) -> SymExpr

Simplify an expression.

This simplifies expressions such as identities (eg. x + 0 becomes x).

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

Create a named symbol, with no assumptions about the value.

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

Create a named symbol representing a positive value (ie. >= 0).

pub fn exact_div(&self, rhs: &SymExpr) -> Option<SymExpr>

Compute self / rhs as an expression, or return None if an exact division is not possible.

Trait Implementations

impl Add for SymExpr

type Output = SymExpr

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for SymExpr

fn add_assign(&mut self, rhs: SymExpr)

Performs the += operation.

impl Clone for SymExpr

fn clone(&self) -> SymExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymExpr

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

Formats the value using the given formatter.

impl Display for SymExpr

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

Formats the value using the given formatter.

impl Div for SymExpr

type Output = SymExpr

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> From<&'a str> for SymExpr

Create a symbol with a given name and an assumption that the value is positive (>= 0).

The rationale for the positivity assumption is that during shape inference, the most common use of symbols is to represent dimension sizes.

fn from(name: &'a str) -> Self

Converts to this type from the input type.

impl From<Symbol> for SymExpr

fn from(val: Symbol) -> Self

Converts to this type from the input type.

impl From<i32> for SymExpr

fn from(val: i32) -> Self

Converts to this type from the input type.

impl Mul for SymExpr

type Output = SymExpr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for SymExpr

type Output = SymExpr

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for SymExpr

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

type Output = SymExpr

The resulting type after applying the - operator.

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

Performs the - operation.