Struct dypdl::Table1DHandle

pub struct Table1DHandle<T>(/* private fields */);

A struct wrapping the id of a table.

Implementations

impl Table1DHandle<bool>

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

where ElementExpression: From<T>,

Returns a condition referring to a value in a 1D boolean table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_1d("table", vec![true, false]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let variable = model.add_element_variable("variable", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.element(variable);
assert!(expression.eval(&state, &model.table_registry));

impl Table1DHandle<Continuous>

pub fn element<T>(&self, x: T) -> ContinuousExpression

where ElementExpression: From<T>,

Returns a constant in a 1D continuous table.

Examples

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

let mut model = Model::default();
let table = model.add_table_1d("table", vec![0.2, 0.3]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let variable = model.add_element_variable("variable", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.element(variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.2);

pub fn sum<T>(&self, x: T) -> ContinuousExpression

where SetExpression: From<T>,

Returns the sum of constants over a set expression in a 1D continuous table.

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

let mut model = Model::default();
let table = model.add_table_1d("table", vec![0.2, 0.3]).unwrap();
let object_type = model.add_object_type("object", 2).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 = table.sum(variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.5);

pub fn product<T>(&self, x: T) -> ContinuousExpression

where SetExpression: From<T>,

Returns the product of constants over a set expression in a 1D continuous table.

Examples

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

let mut model = Model::default();
let table = model.add_table_1d("table", vec![0.2, 0.3]).unwrap();
let object_type = model.add_object_type("object", 2).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 = table.product(variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.06);

pub fn max<T>(&self, x: T) -> ContinuousExpression

where SetExpression: From<T>,

Returns the maximum of constants over a set expression in a 1D continuous table.

Examples

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

let mut model = Model::default();
let table = model.add_table_1d("table", vec![0.2, 0.3]).unwrap();
let object_type = model.add_object_type("object", 2).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 = table.max(variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.3);

pub fn min<T>(&self, x: T) -> ContinuousExpression

where SetExpression: From<T>,

Returns the minimum of constants over a set expression in a 1D continuous table.

Examples

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

let mut model = Model::default();
let table = model.add_table_1d("table", vec![0.2, 0.3]).unwrap();
let object_type = model.add_object_type("object", 2).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 = table.min(variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.2);

impl Table1DHandle<Element>

pub fn element<T>(&self, x: T) -> ElementExpression

where ElementExpression: From<T>,

Returns a constant in a 1D element table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_1d("table", vec![1, 0]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let variable = model.add_element_variable("variable", object_type, 0).unwrap();
let state = model.target.clone();

let expression = Table1DHandle::<Element>::element(&table, variable);
assert_eq!(expression.eval(&state, &model.table_registry), 1);

impl Table1DHandle<Integer>

pub fn element<T>(&self, x: T) -> IntegerExpression

where ElementExpression: From<T>,

Returns a constant in a 1D integer table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_1d("table", vec![2, 3]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let variable = model.add_element_variable("variable", object_type, 0).unwrap();
let state = model.target.clone();

let expression = Table1DHandle::<Integer>::element(&table, variable);
assert_eq!(expression.eval(&state, &model.table_registry), 2);

pub fn sum<T>(&self, x: T) -> IntegerExpression

where SetExpression: From<T>,

Returns the sum of constants over a set expression in a 1D integer table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_1d("table", vec![2, 3]).unwrap();
let object_type = model.add_object_type("object", 2).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 = table.sum(variable);
assert_eq!(expression.eval(&state, &model.table_registry), 5);

pub fn product<T>(&self, x: T) -> IntegerExpression

where SetExpression: From<T>,

Returns the product of constants over a set expression in a 1D integer table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_1d("table", vec![2, 3]).unwrap();
let object_type = model.add_object_type("object", 2).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 = table.product(variable);
assert_eq!(expression.eval(&state, &model.table_registry), 6);

pub fn max<T>(&self, x: T) -> IntegerExpression

where SetExpression: From<T>,

Returns the maximum of constants over a set expression in a 1D integer table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_1d("table", vec![2, 3]).unwrap();
let object_type = model.add_object_type("object", 2).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 = table.max(variable);
assert_eq!(expression.eval(&state, &model.table_registry), 3);

pub fn min<T>(&self, x: T) -> IntegerExpression

where SetExpression: From<T>,

Returns the minimum of constants over a set expression in a 1D integer table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_1d("table", vec![2, 3]).unwrap();
let object_type = model.add_object_type("object", 2).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 = table.min(variable);
assert_eq!(expression.eval(&state, &model.table_registry), 2);

impl Table1DHandle<Set>

pub fn element<T>(&self, x: T) -> SetExpression

where ElementExpression: From<T>,

Returns a constant in a 1D set table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let object_type = model.add_object_type("object", 2).unwrap();
let a = model.create_set(object_type, &[1]).unwrap();
let b = model.create_set(object_type, &[0]).unwrap();
let table = model.add_table_1d("table", vec![a.clone(), b]).unwrap();
let variable = model.add_element_variable("variable", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.element(variable);
assert_eq!(expression.eval(&state, &model.table_registry), a);

pub fn union<T>(&self, capacity: usize, x: T) -> SetExpression

where ArgumentExpression: From<T>,

Returns the union of sets in a 1D table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let capacity = 2;
let object_type = model.add_object_type("object", capacity).unwrap();
let a = model.create_set(object_type, &[0, 1]).unwrap();
let b = model.create_set(object_type, &[0]).unwrap();
let table = model.add_table_1d("table", vec![a, b]).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 = table.union(capacity, variable);
let expected = model.create_set(object_type, &[0, 1]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

pub fn intersection<T>(&self, capacity: usize, x: T) -> SetExpression

where ArgumentExpression: From<T>,

Returns the intersection of sets in a 1D table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let capacity = 2;
let object_type = model.add_object_type("object", capacity).unwrap();
let a = model.create_set(object_type, &[0, 1]).unwrap();
let b = model.create_set(object_type, &[0]).unwrap();
let table = model.add_table_1d("table", vec![a, b]).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 = table.intersection(capacity, variable);
let expected = model.create_set(object_type, &[0]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

pub fn symmetric_difference<T>(&self, capacity: usize, x: T) -> SetExpression

where ArgumentExpression: From<T>,

Returns the symmetric difference (disjunctive union) of sets in a 1D table.

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let capacity = 2;
let object_type = model.add_object_type("object", capacity).unwrap();
let a = model.create_set(object_type, &[1]).unwrap();
let b = model.create_set(object_type, &[0]).unwrap();
let table = model.add_table_1d("table", vec![a, b]).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 = table.symmetric_difference(capacity, variable);
let expected = model.create_set(object_type, &[0, 1]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

impl<T> Table1DHandle<T>

pub fn id(&self) -> usize

Returns the id

Trait Implementations

impl<T: Clone> Clone for Table1DHandle<T>

fn clone(&self) -> Table1DHandle<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Table1DHandle<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Table1DHandle<T>

fn eq(&self, other: &Table1DHandle<T>) -> 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<T: Copy> Copy for Table1DHandle<T>

impl<T: Eq> Eq for Table1DHandle<T>

impl<T> StructuralPartialEq for Table1DHandle<T>