Enum dypdl::expression::ElementExpression

pub enum ElementExpression {
    Constant(Element),
    Variable(usize),
    ResourceVariable(usize),
    BinaryOperation(BinaryOperator, Box<ElementExpression>, Box<ElementExpression>),
    Last(Box<VectorExpression>),
    At(Box<VectorExpression>, Box<ElementExpression>),
    Table(Box<TableExpression<Element>>),
    If(Box<Condition>, Box<ElementExpression>, Box<ElementExpression>),
}

Element expression .

Variants

Constant(Element)

Constant.

Variable(usize)

Variable index.

ResourceVariable(usize)

Resource variable index.

BinaryOperation(BinaryOperator, Box<ElementExpression>, Box<ElementExpression>)

Binary arithmetic operation.

Last(Box<VectorExpression>)

The last value of a vector expression.

At(Box<VectorExpression>, Box<ElementExpression>)

An item in a vector expression.

Table(Box<TableExpression<Element>>)

A constant in a element table.

If(Box<Condition>, Box<ElementExpression>, Box<ElementExpression>)

If-then-else expression, which returns the first one if the condition holds and the second one otherwise.

Implementations

impl ElementExpression

pub fn eval<T: StateInterface>( &self, state: &T, registry: &TableRegistry ) -> Element

Returns the evaluation result.

Panics

Panics if the cost of the transition state is used or a min/max reduce operation is performed on an empty set or vector.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object_type", 2).unwrap();
let variable = model.add_element_variable("variable", object_type, 1).unwrap();
let state = model.target.clone();

let expression = ElementExpression::from(variable);
assert_eq!(expression.eval(&state, &model.table_registry), 1);

pub fn simplify(&self, registry: &TableRegistry) -> ElementExpression

Returns a simplified version by precomputation.

Panics

Panics if a min/max reduce operation is performed on an empty set or vector.

Trait Implementations

impl Add<ElementExpression> for ElementResourceVariable

fn add(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the addition.

type Output = ElementExpression

The resulting type after applying the + operator.

impl Add<ElementExpression> for ElementVariable

fn add(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the addition.

type Output = ElementExpression

The resulting type after applying the + operator.

impl Add<ElementExpression> for Element

fn add(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the addition.

type Output = ElementExpression

The resulting type after applying the + operator.

impl Add<ElementResourceVariable> for ElementExpression

fn add(self, rhs: ElementResourceVariable) -> ElementExpression

Returns an expression representing the addition.

type Output = ElementExpression

The resulting type after applying the + operator.

impl Add<ElementVariable> for ElementExpression

fn add(self, rhs: ElementVariable) -> ElementExpression

Returns an expression representing the addition.

type Output = ElementExpression

The resulting type after applying the + operator.

impl Add<usize> for ElementExpression

fn add(self, rhs: Element) -> ElementExpression

Returns an expression representing the addition.

type Output = ElementExpression

The resulting type after applying the + operator.

impl Add for ElementExpression

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

Returns an expression representing the addition.

Examples

use dypdl::prelude::*;

let model = Model::default();
let state = model.target.clone();
let a = ElementExpression::from(2);
let b = ElementExpression::from(3);
let expression = a + b;

assert_eq!(expression.eval(&state, &model.table_registry), 5);

type Output = ElementExpression

The resulting type after applying the + operator.

impl AddEffect<ElementResourceVariable, ElementExpression> for Transition

fn add_effect<V>( &mut self, v: ElementResourceVariable, expression: V ) -> Result<(), ModelErr>

where ElementExpression: From<V>,

Adds an effect.

impl AddEffect<ElementVariable, ElementExpression> for Transition

fn add_effect<V>( &mut self, v: ElementVariable, expression: V ) -> Result<(), ModelErr>

where ElementExpression: From<V>,

Adds an effect.

impl CheckExpression<ElementExpression> for Model

fn check_expression( &self, expression: &ElementExpression, allow_cost: bool ) -> Result<(), ModelErr>

Checks if an expression is valid.

impl Clone for ElementExpression

fn clone(&self) -> ElementExpression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ElementExpression

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

Formats the value using the given formatter.

impl Default for ElementExpression

fn default() -> Self

Returns an expression representing a constant zero.

impl Div<ElementExpression> for ElementResourceVariable

fn div(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the division.

type Output = ElementExpression

The resulting type after applying the / operator.

impl Div<ElementExpression> for ElementVariable

fn div(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the division.

type Output = ElementExpression

The resulting type after applying the / operator.

impl Div<ElementExpression> for Element

fn div(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the division.

type Output = ElementExpression

The resulting type after applying the / operator.

impl Div<ElementResourceVariable> for ElementExpression

fn div(self, rhs: ElementResourceVariable) -> ElementExpression

Returns an expression representing the division.

type Output = ElementExpression

The resulting type after applying the / operator.

impl Div<ElementVariable> for ElementExpression

fn div(self, rhs: ElementVariable) -> ElementExpression

Returns an expression representing the division.

type Output = ElementExpression

The resulting type after applying the / operator.

impl Div<usize> for ElementExpression

fn div(self, rhs: Element) -> ElementExpression

Returns an expression representing the division.

type Output = ElementExpression

The resulting type after applying the / operator.

impl Div for ElementExpression

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

Returns an expression representing the division.

Examples

use dypdl::prelude::*;

let model = Model::default();
let state = model.target.clone();
let a = ElementExpression::from(2);
let b = ElementExpression::from(3);
let expression = a / b;

assert_eq!(expression.eval(&state, &model.table_registry), 0);

type Output = ElementExpression

The resulting type after applying the / operator.

impl From<ElementExpression> for ArgumentExpression

fn from(v: ElementExpression) -> ArgumentExpression

Converts to this type from the input type.

impl From<ElementResourceVariable> for ElementExpression

fn from(v: ElementResourceVariable) -> ElementExpression

Converts to this type from the input type.

impl From<ElementVariable> for ElementExpression

fn from(v: ElementVariable) -> ElementExpression

Converts to this type from the input type.

impl From<usize> for ElementExpression

fn from(e: Element) -> ElementExpression

Converts to this type from the input type.

impl IfThenElse<ElementExpression> for Condition

fn if_then_else<U, V>(self, lhs: U, rhs: V) -> ElementExpression

where ElementExpression: From<U> + From<V>,

Returns an if-then-else expression, which returns a if this condition holds and b otherwise.

impl MaxMin<ElementExpression> for ElementResourceVariable

type Output = ElementExpression

fn max(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the maximum.

fn min(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the minimum.

impl MaxMin<ElementExpression> for ElementVariable

type Output = ElementExpression

fn max(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the maximum.

fn min(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the minimum.

impl MaxMin<ElementExpression> for Element

type Output = ElementExpression

fn max(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the maximum.

fn min(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the minimum.

impl MaxMin<ElementResourceVariable> for ElementExpression

type Output = ElementExpression

fn max(self, rhs: ElementResourceVariable) -> ElementExpression

Returns an expression representing the maximum.

fn min(self, rhs: ElementResourceVariable) -> ElementExpression

Returns an expression representing the minimum.

impl MaxMin<ElementVariable> for ElementExpression

type Output = ElementExpression

fn max(self, rhs: ElementVariable) -> ElementExpression

Returns an expression representing the maximum.

fn min(self, rhs: ElementVariable) -> ElementExpression

Returns an expression representing the minimum.

impl MaxMin<usize> for ElementExpression

type Output = ElementExpression

fn max(self, rhs: Element) -> ElementExpression

Returns an expression representing the maximum.

fn min(self, rhs: Element) -> ElementExpression

Returns an expression representing the minimum.

impl MaxMin for ElementExpression

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

Returns an expression representing the maximum.

Examples

use dypdl::prelude::*;

let model = Model::default();
let state = model.target.clone();
let a = ElementExpression::from(2);
let b = ElementExpression::from(3);
let expression = a.max(b);

assert_eq!(expression.eval(&state, &model.table_registry), 3);

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

Returns an expression representing the minimum.

Examples

use dypdl::prelude::*;

let model = Model::default();
let state = model.target.clone();
let a = ElementExpression::from(2);
let b = ElementExpression::from(3);
let expression = a.min(b);

assert_eq!(expression.eval(&state, &model.table_registry), 2);

type Output = ElementExpression

impl Mul<ElementExpression> for ElementResourceVariable

fn mul(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the multiplication.

type Output = ElementExpression

The resulting type after applying the * operator.

impl Mul<ElementExpression> for ElementVariable

fn mul(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the multiplication.

type Output = ElementExpression

The resulting type after applying the * operator.

impl Mul<ElementExpression> for Element

fn mul(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the multiplication.

type Output = ElementExpression

The resulting type after applying the * operator.

impl Mul<ElementResourceVariable> for ElementExpression

fn mul(self, rhs: ElementResourceVariable) -> ElementExpression

Returns an expression representing the multiplication.

type Output = ElementExpression

The resulting type after applying the * operator.

impl Mul<ElementVariable> for ElementExpression

fn mul(self, rhs: ElementVariable) -> ElementExpression

Returns an expression representing the multiplication.

type Output = ElementExpression

The resulting type after applying the * operator.

impl Mul<usize> for ElementExpression

fn mul(self, rhs: Element) -> ElementExpression

Returns an expression representing the multiplication.

type Output = ElementExpression

The resulting type after applying the * operator.

impl Mul for ElementExpression

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

Returns an expression representing the multiplication.

Examples

use dypdl::prelude::*;

let model = Model::default();
let state = model.target.clone();
let a = ElementExpression::from(2);
let b = ElementExpression::from(3);
let expression = a * b;

assert_eq!(expression.eval(&state, &model.table_registry), 6);

type Output = ElementExpression

The resulting type after applying the * operator.

impl PartialEq for ElementExpression

fn eq(&self, other: &ElementExpression) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Rem<ElementExpression> for ElementResourceVariable

fn rem(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the remainder.

type Output = ElementExpression

The resulting type after applying the % operator.

impl Rem<ElementExpression> for ElementVariable

fn rem(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the remainder.

type Output = ElementExpression

The resulting type after applying the % operator.

impl Rem<ElementExpression> for Element

fn rem(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the remainder.

type Output = ElementExpression

The resulting type after applying the % operator.

impl Rem<ElementResourceVariable> for ElementExpression

fn rem(self, rhs: ElementResourceVariable) -> ElementExpression

Returns an expression representing the remainder.

type Output = ElementExpression

The resulting type after applying the % operator.

impl Rem<ElementVariable> for ElementExpression

fn rem(self, rhs: ElementVariable) -> ElementExpression

Returns an expression representing the remainder.

type Output = ElementExpression

The resulting type after applying the % operator.

impl Rem<usize> for ElementExpression

fn rem(self, rhs: Element) -> ElementExpression

Returns an expression representing the remainder.

type Output = ElementExpression

The resulting type after applying the % operator.

impl Rem for ElementExpression

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

Returns an expression representing the remainder.

Examples

use dypdl::prelude::*;

let model = Model::default();
let state = model.target.clone();
let a = ElementExpression::from(2);
let b = ElementExpression::from(3);
let expression = a % b;

assert_eq!(expression.eval(&state, &model.table_registry), 2);

type Output = ElementExpression

The resulting type after applying the % operator.

impl SetElementOperation<ElementExpression> for Set

fn add(self, rhs: ElementExpression) -> SetExpression

Returns a set expression, where an element is added.

fn remove(self, rhs: ElementExpression) -> SetExpression

Returns a set expression, where an element is removed.

impl SetElementOperation<ElementExpression> for SetExpression

fn add(self, rhs: ElementExpression) -> SetExpression

Returns a set expression, where an element is added.

fn remove(self, rhs: ElementExpression) -> SetExpression

Returns a set expression, where an element is removed.

impl SetElementOperation<ElementExpression> for SetVariable

fn add(self, rhs: ElementExpression) -> SetExpression

Returns a set expression, where an element is added.

fn remove(self, rhs: ElementExpression) -> SetExpression

Returns a set expression, where an element is removed.

impl Sub<ElementExpression> for ElementResourceVariable

fn sub(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the subtraction.

type Output = ElementExpression

The resulting type after applying the - operator.

impl Sub<ElementExpression> for ElementVariable

fn sub(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the subtraction.

type Output = ElementExpression

The resulting type after applying the - operator.

impl Sub<ElementExpression> for Element

fn sub(self, rhs: ElementExpression) -> ElementExpression

Returns an expression representing the subtraction.

type Output = ElementExpression

The resulting type after applying the - operator.

impl Sub<ElementResourceVariable> for ElementExpression

fn sub(self, rhs: ElementResourceVariable) -> ElementExpression

Returns an expression representing the subtraction.

type Output = ElementExpression

The resulting type after applying the - operator.

impl Sub<ElementVariable> for ElementExpression

fn sub(self, rhs: ElementVariable) -> ElementExpression

Returns an expression representing the subtraction.

type Output = ElementExpression

The resulting type after applying the - operator.

impl Sub<usize> for ElementExpression

fn sub(self, rhs: Element) -> ElementExpression

Returns an expression representing the subtraction.

type Output = ElementExpression

The resulting type after applying the - operator.

impl Sub for ElementExpression

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

Returns an expression representing the subtraction.

Examples

use dypdl::prelude::*;

let model = Model::default();
let state = model.target.clone();
let a = ElementExpression::from(3);
let b = ElementExpression::from(2);
let expression = a - b;

assert_eq!(expression.eval(&state, &model.table_registry), 1);

type Output = ElementExpression

The resulting type after applying the - operator.

impl StructuralPartialEq for ElementExpression