Struct dypdl::Transition

pub struct Transition {
    pub name: String,
    pub parameter_names: Vec<String>,
    pub parameter_values: Vec<Element>,
    pub elements_in_set_variable: Vec<(usize, Element)>,
    pub elements_in_vector_variable: Vec<(usize, Element, usize)>,
    pub preconditions: Vec<GroundedCondition>,
    pub effect: Effect,
    pub cost: CostExpression,
}

Transition.

Fields

name: String

Name of the transition.

parameter_names: Vec<String>

parameter_values: Vec<Element>

The values of parameters.

elements_in_set_variable: Vec<(usize, Element)>

Pairs of an index of a set variable and a parameter. A parameter must be included in the corresponding variable to be applicable.

elements_in_vector_variable: Vec<(usize, Element, usize)>

Triplets of an index of a vector variable, a parameter, and the capacity. A parameter must be included in the corresponding variable to be applicable.

preconditions: Vec<GroundedCondition>

Preconditions.

effect: Effect

Effect.

cost: CostExpression

Cost expression.

Implementations

impl Transition

pub fn get_full_name(&self) -> String

Returns the name of transition considering parameters.

Examples

use dypdl::prelude::*;

let transition = Transition::new("transition");
assert_eq!(transition.get_full_name(), String::from("transition"));

pub fn new<T>(name: T) -> Transition

where String: From<T>,

Returns a new transition with the name.

pub fn set_cost<T>(&mut self, cost: T)

where CostExpression: From<T>,

Sets the cost expression;

Examples

use dypdl::prelude::*;

let mut transition = Transition::new("transition");
transition.set_cost(IntegerExpression::Cost + 1);

pub fn get_preconditions(&self) -> Vec<Condition>

Gets preconditions.

Note that the preconditions and their order might be changed due to internal optimizations.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let variable = model.add_integer_variable("x", 2).unwrap();
let state = model.target.clone();

let mut transition = Transition::new("transition");
let condition = Condition::comparison_i(ComparisonOperator::Ge, variable, 0);;
transition.add_precondition(condition.clone());

let preconditions = transition.get_preconditions();
assert_eq!(preconditions.len(), 1);
assert!(preconditions[0].eval(&state, &model.table_registry));

pub fn add_precondition(&mut self, condition: Condition)

Adds a precondition;

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let variable = model.add_integer_variable("x", 2).unwrap();
let state = model.target.clone();

let mut transition = Transition::new("transition");
let condition = Condition::comparison_i(ComparisonOperator::Ge, variable, 0);;
transition.add_precondition(condition);

Trait Implementations

impl AddEffect<ContinuousResourceVariable, ContinuousExpression> for Transition

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

where ContinuousExpression: From<V>,

Adds an effect.

impl AddEffect<ContinuousVariable, ContinuousExpression> for Transition

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

where ContinuousExpression: From<V>,

Adds an effect.

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 AddEffect<IntegerResourceVariable, IntegerExpression> for Transition

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

where IntegerExpression: From<V>,

Adds an effect.

impl AddEffect<IntegerVariable, IntegerExpression> for Transition

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

where IntegerExpression: From<V>,

Adds an effect.

impl AddEffect<SetVariable, SetExpression> for Transition

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

where SetExpression: From<V>,

Adds an effect.

impl AddEffect<VectorVariable, VectorExpression> for Transition

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

where VectorExpression: From<V>,

Adds an effect.

impl Clone for Transition

fn clone(&self) -> Transition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Transition

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

Formats the value using the given formatter.

impl Default for Transition

fn default() -> Transition

Returns the “default value” for a type.

impl PartialEq for Transition

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

fn is_applicable<S: StateInterface>( &self, state: &S, registry: &TableRegistry ) -> bool

Returns true if the transition is applicable and false otherwise.

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("x", 2).unwrap();
let state = model.target.clone();

let mut transition = Transition::new("transition");
assert!(transition.is_applicable(&state, &model.table_registry));

let condition = Condition::comparison_i(ComparisonOperator::Ge, variable, 0);;
transition.add_precondition(condition);
assert!(transition.is_applicable(&state, &model.table_registry));

let condition = Condition::comparison_i(ComparisonOperator::Le, variable, 1);;
transition.add_precondition(condition);
assert!(!transition.is_applicable(&state, &model.table_registry));

fn apply<S: StateInterface, T: From<State>>( &self, state: &S, registry: &TableRegistry ) -> T

Returns the transitioned state.

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("x", 2).unwrap();
let state = model.target.clone();

let mut transition = Transition::new("transition");
transition.add_effect(variable, variable + 1);
let state: State = transition.apply(&state, &model.table_registry);
assert_eq!(state.get_integer_variable(variable.id()), 3);

fn eval_cost<T: Numeric, S: StateInterface>( &self, cost: T, state: &S, registry: &TableRegistry ) -> T

Returns the evaluation result of the cost expression.

Panics

Panics if 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("x", 2).unwrap();
let state = model.target.clone();

let mut transition = Transition::new("transition");
transition.set_cost(IntegerExpression::Cost + variable);
assert_eq!(transition.eval_cost(1, &state, &model.table_registry), 3);

impl StructuralPartialEq for Transition