Struct dypdl::SetVariable

pub struct SetVariable(/* private fields */);

A struct wrapping an id.

Implementations

impl SetVariable

pub fn contains<T>(self, element: T) -> Condition

where ElementExpression: From<T>,

Returns a condition checking if an element is included in this set.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object_type", 4).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let variable = model.add_set_variable("variable", object_type, set).unwrap();
let state = model.target.clone();

let condition = variable.contains(0);
assert!(condition.eval(&state, &model.table_registry));

pub fn is_equal<T>(self, set: T) -> Condition

where SetExpression: From<T>,

Returns a condition checking if this set is equal to the other.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object_type", 4).unwrap();
let a = model.create_set(object_type, &[0, 1]).unwrap();
let a = model.add_set_variable("a", object_type, a).unwrap();
let b = model.create_set(object_type, &[0, 1]).unwrap();
let state = model.target.clone();

let condition = a.is_equal(b);
assert!(condition.eval(&state, &model.table_registry));

pub fn is_not_equal<T>(self, set: T) -> Condition

where SetExpression: From<T>,

Returns a condition checking if this set is not equal to the other.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object_type", 4).unwrap();
let a = model.create_set(object_type, &[0, 1]).unwrap();
let a = model.add_set_variable("a", object_type, a).unwrap();
let b = model.create_set(object_type, &[1, 2]).unwrap();
let state = model.target.clone();

let condition = a.is_not_equal(b);
assert!(condition.eval(&state, &model.table_registry));

pub fn is_subset<T>(self, set: T) -> Condition

where SetExpression: From<T>,

Returns a condition checking if this set is a subset of the other.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object_type", 4).unwrap();
let a = model.create_set(object_type, &[0, 1]).unwrap();
let a = model.add_set_variable("a", object_type, a).unwrap();
let b = model.create_set(object_type, &[0, 1, 2]).unwrap();
let state = model.target.clone();

let condition = a.is_not_equal(b);
assert!(condition.eval(&state, &model.table_registry));

pub fn is_empty(self) -> Condition

Returns a condition checking if this set is empty.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object_type", 4).unwrap();
let set = model.create_set(object_type, &[]).unwrap();
let variable = model.add_set_variable("variable", object_type, set).unwrap();
let state = model.target.clone();

let condition = variable.is_empty();
assert!(condition.eval(&state, &model.table_registry));

impl SetVariable

pub fn len_continuous(self) -> ContinuousExpression

Returns an expression representing the cardinality of a set.

Examples

use dypdl::prelude::*;
use approx::assert_relative_eq;

let mut model = Model::default();
let object_type = model.add_object_type("object", 4).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let variable = model.add_set_variable("variable", object_type, set).unwrap();
let state = model.target.clone();

let expression = variable.len_continuous();

assert_relative_eq!(expression.eval(&state, &model.table_registry), 2.0);

impl SetVariable

pub fn len(self) -> IntegerExpression

Returns an expression representing the cardinality of a set.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object", 4).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let variable = model.add_set_variable("variable", object_type, set).unwrap();
let state = model.target.clone();

let expression = variable.len();

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

impl SetVariable

pub fn id(&self) -> usize

Returns the id.

Trait Implementations

impl AccessTarget<SetVariable, FixedBitSet> for Model

fn get_target(&self, variable: SetVariable) -> Result<Set, ModelErr>

Returns the value in the target state.

fn set_target( &mut self, variable: SetVariable, target: Set ) -> Result<(), ModelErr>

Set the value in the target state

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 BitAnd<FixedBitSet> for SetVariable

fn bitand(self, rhs: Set) -> SetExpression

Returns an expression representing the intersection.

type Output = SetExpression

The resulting type after applying the & operator.

impl BitAnd<SetExpression> for SetVariable

fn bitand(self, rhs: SetExpression) -> SetExpression

Returns an expression representing the intersection.

type Output = SetExpression

The resulting type after applying the & operator.

impl BitAnd<SetVariable> for Set

fn bitand(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the intersection.

type Output = SetExpression

The resulting type after applying the & operator.

impl BitAnd<SetVariable> for SetExpression

fn bitand(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the intersection.

type Output = SetExpression

The resulting type after applying the & operator.

impl BitAnd for SetVariable

fn bitand(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the intersection.

type Output = SetExpression

The resulting type after applying the & operator.

impl BitOr<FixedBitSet> for SetVariable

fn bitor(self, rhs: Set) -> SetExpression

Returns an expression representing the union.

type Output = SetExpression

The resulting type after applying the | operator.

impl BitOr<SetExpression> for SetVariable

fn bitor(self, rhs: SetExpression) -> SetExpression

Returns an expression representing the union.

type Output = SetExpression

The resulting type after applying the | operator.

impl BitOr<SetVariable> for Set

fn bitor(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the union.

type Output = SetExpression

The resulting type after applying the | operator.

impl BitOr<SetVariable> for SetExpression

fn bitor(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the union.

type Output = SetExpression

The resulting type after applying the | operator.

impl BitOr for SetVariable

fn bitor(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the union.

type Output = SetExpression

The resulting type after applying the | operator.

impl CheckVariable<SetVariable> for StateMetadata

fn check_variable(&self, v: SetVariable) -> Result<(), ModelErr>

Check if the variable is defined.

impl Clone for SetVariable

fn clone(&self) -> SetVariable

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SetVariable

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

Formats the value using the given formatter.

impl From<SetVariable> for ArgumentExpression

fn from(v: SetVariable) -> ArgumentExpression

Converts to this type from the input type.

impl From<SetVariable> for SetExpression

fn from(v: SetVariable) -> Self

Converts to this type from the input type.

impl GetObjectTypeOf<SetVariable> for Model

fn get_object_type_of(&self, v: SetVariable) -> Result<ObjectType, ModelErr>

Returns the object type of the variable.

impl GetObjectTypeOf<SetVariable> for StateMetadata

fn get_object_type_of(&self, v: SetVariable) -> Result<ObjectType, ModelErr>

Returns the object type of the variable.

impl Not for SetVariable

fn not(self) -> Self::Output

Returns an expression representing the complement.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object", 4).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let variable = model.add_set_variable("variable", object_type, set).unwrap();
let state = model.target.clone();

let expression = !variable;
let expected = model.create_set(object_type, &[2, 3]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

type Output = SetExpression

The resulting type after applying the ! operator.

impl PartialEq for SetVariable

fn eq(&self, other: &SetVariable) -> 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 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 SetElementOperation<ElementResourceVariable> for SetVariable

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

Returns a set expression, where an element is added.

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

Returns a set expression, where an element is removed.

impl SetElementOperation<ElementVariable> for SetVariable

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

Returns a set expression, where an element is added.

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

Returns a set expression, where an element is removed.

impl SetElementOperation<usize> for SetVariable

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

Returns a set expression, where an element is added.

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

Returns a set expression, where an element is removed.

impl Sub<FixedBitSet> for SetVariable

fn sub(self, rhs: Set) -> SetExpression

Returns an expression representing the difference.

type Output = SetExpression

The resulting type after applying the - operator.

impl Sub<SetExpression> for SetVariable

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

Returns an expression representing the difference.

type Output = SetExpression

The resulting type after applying the - operator.

impl Sub<SetVariable> for Set

fn sub(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the difference.

type Output = SetExpression

The resulting type after applying the - operator.

impl Sub<SetVariable> for SetExpression

fn sub(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the difference.

type Output = SetExpression

The resulting type after applying the - operator.

impl Sub for SetVariable

fn sub(self, rhs: SetVariable) -> SetExpression

Returns an expression representing the difference.

type Output = SetExpression

The resulting type after applying the - operator.

impl Copy for SetVariable

impl Eq for SetVariable

impl StructuralEq for SetVariable

impl StructuralPartialEq for SetVariable