Enum Condition 

pub enum Condition {
    Constant(bool),
    StateFunction(usize),
    Not(Box<Condition>),
    And(Box<Condition>, Box<Condition>),
    Or(Box<Condition>, Box<Condition>),
    ComparisonE(ComparisonOperator, Box<ElementExpression>, Box<ElementExpression>),
    ComparisonI(ComparisonOperator, Box<IntegerExpression>, Box<IntegerExpression>),
    ComparisonC(ComparisonOperator, Box<ContinuousExpression>, Box<ContinuousExpression>),
    Set(Box<SetCondition>),
    Table(Box<TableExpression<bool>>),
}

Condition.

Variants

Constant(bool)

Constant.

StateFunction(usize)

State function index.

Not(Box<Condition>)

Not x.

And(Box<Condition>, Box<Condition>)

x and b.

Or(Box<Condition>, Box<Condition>)

x or b.

ComparisonE(ComparisonOperator, Box<ElementExpression>, Box<ElementExpression>)

Comparing two element expressions.

ComparisonI(ComparisonOperator, Box<IntegerExpression>, Box<IntegerExpression>)

Comparing two integer expressions.

ComparisonC(ComparisonOperator, Box<ContinuousExpression>, Box<ContinuousExpression>)

Comparing two continuous expressions.

Set(Box<SetCondition>)

Set condition.

Table(Box<TableExpression<bool>>)

A constant in a boolean table.

Implementations

impl Condition

pub fn comparison_e<T, U>(op: ComparisonOperator, lhs: T, rhs: U) -> Self

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

Returns a condition comparing two element expressions.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object_type", 4).unwrap();
let variable = model.add_element_variable("variable", object_type, 2).unwrap();
let state = model.target.clone();
let mut function_cache = StateFunctionCache::new(&model.state_functions);

let condition = Condition::comparison_e(ComparisonOperator::Gt, variable, 0);
assert!(
    condition.eval(
        &state, &mut function_cache, &model.state_functions, &model.table_registry,
    )
);

pub fn comparison_i<T, U>(op: ComparisonOperator, lhs: T, rhs: U) -> Self

where IntegerExpression: From<T> + From<U>,

Returns a condition comparing two integer expressions.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let variable = model.add_integer_variable("variable", 2).unwrap();
let state = model.target.clone();
let mut function_cache = StateFunctionCache::new(&model.state_functions);

let condition = Condition::comparison_i(ComparisonOperator::Gt, variable, 0);
assert!(
    condition.eval(
        &state, &mut function_cache, &model.state_functions, &model.table_registry,
    )
);

pub fn comparison_c<T, U>(op: ComparisonOperator, lhs: T, rhs: U) -> Self

where ContinuousExpression: From<T> + From<U>,

Returns a condition comparing two continuous expressions.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let variable = model.add_continuous_resource_variable("variable", true, 0.5).unwrap();
let state = model.target.clone();
let mut function_cache = StateFunctionCache::new(&model.state_functions);

let condition = Condition::comparison_c(ComparisonOperator::Gt, variable, 0);
assert!(
    condition.eval(
        &state, &mut function_cache, &model.state_functions, &model.table_registry,
    )
);

impl Condition

pub fn eval<T: StateInterface>( &self, state: &T, function_cache: &mut StateFunctionCache, state_functions: &StateFunctions, registry: &TableRegistry, ) -> bool

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 variable = model.add_integer_variable("variable", 1).unwrap();
let state = model.target.clone();
let mut function_cache = StateFunctionCache::new(&model.state_functions);

let condition = Condition::comparison_i(ComparisonOperator::Ge, variable, 0);
assert!(
    condition.eval(
        &state, &mut function_cache, &model.state_functions, &model.table_registry,
    ),
);

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

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 BitAnd for Condition

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

Returns the conjunction of this condition and rhs.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let variable = model.add_integer_variable("variable", 1).unwrap();
let state = model.target.clone();
let mut function_cache = StateFunctionCache::new(&model.state_functions);

let a = Condition::comparison_i(ComparisonOperator::Ge, variable, 0);
let b = Condition::comparison_i(ComparisonOperator::Le, variable, 2);
let condition = a & b;
assert!(
    condition.eval(
        &state, &mut function_cache, &model.state_functions, &model.table_registry,
    )
);

type Output = Condition

The resulting type after applying the & operator.

impl BitOr for Condition

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

Returns the disjunction of this condition and rhs.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let variable = model.add_integer_variable("variable", 1).unwrap();
let state = model.target.clone();
let mut function_cache = StateFunctionCache::new(&model.state_functions);

let a = Condition::comparison_i(ComparisonOperator::Ge, variable, 0);
let b = Condition::comparison_i(ComparisonOperator::Lt, variable, 1);
let condition = a | b;
assert!(
    condition.eval(
        &state, &mut function_cache, &model.state_functions, &model.table_registry,
    )
);

type Output = Condition

The resulting type after applying the | operator.

impl CheckExpression<Condition> for Model

fn check_expression( &self, condition: &Condition, allow_cost: bool, ) -> Result<(), ModelErr>

Checks if an expression is valid.

impl Clone for Condition

fn clone(&self) -> Condition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Condition

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

Formats the value using the given formatter.

impl Default for Condition

fn default() -> Condition

Returns Condition::Constant(false).

impl From<Condition> for GroundedCondition

fn from(condition: Condition) -> Self

Creates a grounded condition from a condition.

impl From<GroundedCondition> for Condition

fn from(grounded_condition: GroundedCondition) -> Self

Creates a condition from a grounded condition.

impl IfThenElse<ContinuousExpression> for Condition

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

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

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

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 IfThenElse<IntegerExpression> for Condition

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

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

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

impl IfThenElse<SetExpression> for Condition

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

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

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

impl Not for Condition

fn not(self) -> Self::Output

Returns the negation of this condition.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let variable = model.add_integer_variable("variable", 1).unwrap();
let state = model.target.clone();
let mut function_cache = StateFunctionCache::new(&model.state_functions);

let condition = Condition::comparison_i(ComparisonOperator::Gt, variable, 1);
let condition = !condition;
assert!(
    condition.eval(
        &state, &mut function_cache, &model.state_functions, &model.table_registry,
    )
);

type Output = Condition

The resulting type after applying the ! operator.

impl PartialEq for Condition

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