Struct dypdl::TableHandle

source · 
pub struct TableHandle<T>(/* private fields */);
Expand description

A struct wrapping the id of a table.

Implementations§

source§

impl TableHandle<bool>

source

pub fn element<T>(&self, indices: Vec<T>) -> Condition
where ElementExpression: From<T>,

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

§Examples
use dypdl::prelude::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], true), (vec![1, 1, 1, 1], true)]);
let table = model.add_table("table", map, 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 indices = vec![
    ElementExpression::from(variable),
    ElementExpression::from(0),
    ElementExpression::from(0),
    ElementExpression::from(0),
];
let expression = table.element(indices);
assert!(expression.eval(&state, &model.table_registry));
source§

impl TableHandle<Continuous>

source

pub fn element<T>(&self, index: Vec<T>) -> ContinuousExpression
where ElementExpression: From<T>,

Returns a constant in a continuous table.

§Examples
use dypdl::prelude::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 0.1), (vec![1, 1, 1, 1], 0.2)]);
let table = model.add_table("table", map, 0.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 indices = vec![
    ElementExpression::from(variable),
    ElementExpression::from(0),
    ElementExpression::from(0),
    ElementExpression::from(0),
];
let expression = table.element(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 0.1);
source

pub fn sum<T>(&self, index: Vec<T>) -> ContinuousExpression
where ArgumentExpression: From<T>,

Returns the sum of constants over set expressions in a continuous table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 0.1), (vec![1, 1, 1, 1], 0.2)]);
let table = model.add_table("table", map, 0.0).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let set_variable = model.add_set_variable("set", object_type, set.clone()).unwrap();
let element_variable = model.add_element_variable("element", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ArgumentExpression::from(set),
    ArgumentExpression::from(set_variable),
    ArgumentExpression::from(element_variable),
    ArgumentExpression::from(0),
];
let expression = table.sum(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 0.1);
source

pub fn product<T>(&self, index: Vec<T>) -> ContinuousExpression
where ArgumentExpression: From<T>,

Returns the product of constants over set expressions in a continuous table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 0.1), (vec![1, 1, 1, 1], 0.2)]);
let table = model.add_table("table", map, 0.0).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let set_variable = model.add_set_variable("set", object_type, set.clone()).unwrap();
let element_variable = model.add_element_variable("element", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ArgumentExpression::from(set),
    ArgumentExpression::from(set_variable),
    ArgumentExpression::from(element_variable),
    ArgumentExpression::from(0),
];
let expression = table.product(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 0.0);
source

pub fn max<T>(&self, index: Vec<T>) -> ContinuousExpression
where ArgumentExpression: From<T>,

Returns the maximum of constants over set expressions in a continuous table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 0.1), (vec![1, 1, 1, 1], 0.2)]);
let table = model.add_table("table", map, 0.0).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let set_variable = model.add_set_variable("set", object_type, set.clone()).unwrap();
let element_variable = model.add_element_variable("element", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ArgumentExpression::from(set),
    ArgumentExpression::from(set_variable),
    ArgumentExpression::from(element_variable),
    ArgumentExpression::from(0),
];
let expression = table.max(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 0.1);
source

pub fn min<T>(&self, index: Vec<T>) -> ContinuousExpression
where ArgumentExpression: From<T>,

Returns the minimum of constants over set expressions in a continuous table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 0.1), (vec![1, 1, 1, 1], 0.2)]);
let table = model.add_table("table", map, 0.0).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let set_variable = model.add_set_variable("set", object_type, set.clone()).unwrap();
let element_variable = model.add_element_variable("element", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ArgumentExpression::from(set),
    ArgumentExpression::from(set_variable),
    ArgumentExpression::from(element_variable),
    ArgumentExpression::from(0),
];
let expression = table.min(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 0.0);
source§

impl TableHandle<Element>

source

pub fn element<T>(&self, indices: Vec<T>) -> ElementExpression
where ElementExpression: From<T>,

Returns a constant in an element table.

§Examples
use dypdl::prelude::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 1), (vec![1, 1, 1, 1], 1)]);
let table = model.add_table("table", map, 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 indices = vec![
    ElementExpression::from(variable),
    ElementExpression::from(0),
    ElementExpression::from(0),
    ElementExpression::from(0),
];
let expression = TableHandle::<Element>::element(&table, indices);
assert_eq!(expression.eval(&state, &model.table_registry), 1);
source§

impl TableHandle<Integer>

source

pub fn element<T>(&self, indices: Vec<T>) -> IntegerExpression
where ElementExpression: From<T>,

Returns a constant in an integer table.

§Examples
use dypdl::prelude::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 1), (vec![1, 1, 1, 1], 2)]);
let table = model.add_table("table", map, 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 indices = vec![
    ElementExpression::from(variable),
    ElementExpression::from(0),
    ElementExpression::from(0),
    ElementExpression::from(0),
];
let expression = TableHandle::<Integer>::element(&table, indices);
assert_eq!(expression.eval(&state, &model.table_registry), 1);
source

pub fn sum<T>(&self, indices: Vec<T>) -> IntegerExpression
where ArgumentExpression: From<T>,

Returns the sum of constants over set expressions in an integer table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 1), (vec![1, 1, 1, 1], 2)]);
let table = model.add_table("table", map, 0).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let set_variable = model.add_set_variable("set", object_type, set.clone()).unwrap();
let element_variable = model.add_element_variable("element", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ArgumentExpression::from(set),
    ArgumentExpression::from(set_variable),
    ArgumentExpression::from(element_variable),
    ArgumentExpression::from(0),
];
let expression = table.sum(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 1);
source

pub fn product<T>(&self, indices: Vec<T>) -> IntegerExpression
where ArgumentExpression: From<T>,

Returns the product of constants over set expressions in an integer table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 1), (vec![1, 1, 1, 1], 2)]);
let table = model.add_table("table", map, 0).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let set_variable = model.add_set_variable("set", object_type, set.clone()).unwrap();
let element_variable = model.add_element_variable("element", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ArgumentExpression::from(set),
    ArgumentExpression::from(set_variable),
    ArgumentExpression::from(element_variable),
    ArgumentExpression::from(0),
];
let expression = table.product(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 0);
source

pub fn max<T>(&self, indices: Vec<T>) -> IntegerExpression
where ArgumentExpression: From<T>,

Returns the maximum of constants over set expressions in an integer table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 1), (vec![1, 1, 1, 1], 2)]);
let table = model.add_table("table", map, 0).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let set_variable = model.add_set_variable("set", object_type, set.clone()).unwrap();
let element_variable = model.add_element_variable("element", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ArgumentExpression::from(set),
    ArgumentExpression::from(set_variable),
    ArgumentExpression::from(element_variable),
    ArgumentExpression::from(0),
];
let expression = table.max(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 1);
source

pub fn min<T>(&self, indices: Vec<T>) -> IntegerExpression
where ArgumentExpression: From<T>,

Returns the minimum of constants over set expressions in an integer table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let mut model = Model::default();
let map = FxHashMap::from_iter(vec![(vec![0, 0, 0, 0], 1), (vec![1, 1, 1, 1], 2)]);
let table = model.add_table("table", map, 0).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let set_variable = model.add_set_variable("set", object_type, set.clone()).unwrap();
let element_variable = model.add_element_variable("element", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ArgumentExpression::from(set),
    ArgumentExpression::from(set_variable),
    ArgumentExpression::from(element_variable),
    ArgumentExpression::from(0),
];
let expression = table.min(indices);
assert_eq!(expression.eval(&state, &model.table_registry), 0);
source§

impl TableHandle<Set>

source

pub fn element<T>(&self, indices: Vec<T>) -> SetExpression
where ElementExpression: From<T>,

Returns a constant in a set table.

§Examples
use dypdl::prelude::*;
use rustc_hash::FxHashMap;

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 map = FxHashMap::from_iter(
    vec![(vec![0, 0, 0, 0], a.clone()), (vec![1, 1, 1, 1], a.clone())]
);
let table = model.add_table("table", map, b).unwrap();
let variable = model.add_element_variable("variable", object_type, 0).unwrap();
let state = model.target.clone();

let indices = vec![
    ElementExpression::from(variable),
    ElementExpression::from(0),
    ElementExpression::from(0),
    ElementExpression::from(0),
];
let expression = table.element(indices);
assert_eq!(expression.eval(&state, &model.table_registry), a);
source

pub fn union<T>(&self, capacity: usize, indices: Vec<T>) -> SetExpression
where ArgumentExpression: From<T>,

Returns the union of sets in a table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let capacity = 2;
let mut model = Model::default();
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 map = FxHashMap::from_iter(
    vec![(vec![0, 0, 0, 0], a.clone()), (vec![1, 1, 1, 1], a)]
);
let table = model.add_table("table", map, 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 indices = vec![
    ArgumentExpression::from(variable),
    ArgumentExpression::from(0),
    ArgumentExpression::from(0),
    ArgumentExpression::from(0),
];
let expression = table.union(capacity, indices);
let expected = model.create_set(object_type, &[0, 1]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

let indices = vec![
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
];
let expression = table.union(capacity, indices);
let expected = model.create_set(object_type, &[0, 1]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);
source

pub fn intersection<T>(&self, capacity: usize, indices: Vec<T>) -> SetExpression
where ArgumentExpression: From<T>,

Returns the intersection of sets in a table.

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let capacity = 2;
let mut model = Model::default();
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 map = FxHashMap::from_iter(
    vec![(vec![0, 0, 0, 0], a.clone()), (vec![1, 1, 1, 1], a)]
);
let table = model.add_table("table", map, 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 indices = vec![
    ArgumentExpression::from(variable),
    ArgumentExpression::from(0),
    ArgumentExpression::from(0),
    ArgumentExpression::from(0),
];
let expression = table.intersection(capacity, indices);
let expected = model.create_set(object_type, &[]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

let indices = vec![
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
];
let expression = table.intersection(capacity, indices);
let expected = model.create_set(object_type, &[]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);
source

pub fn symmetric_difference<T>( &self, capacity: usize, indices: Vec<T>, ) -> SetExpression
where ArgumentExpression: From<T>,

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

§Examples
use dypdl::prelude::*;
use dypdl::expression::*;
use rustc_hash::FxHashMap;

let capacity = 2;
let mut model = Model::default();
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 map = FxHashMap::from_iter(
    vec![(vec![0, 0, 0, 0], a.clone()), (vec![1, 1, 1, 1], a)]
);
let table = model.add_table("table", map, 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 indices = vec![
    ArgumentExpression::from(variable),
    ArgumentExpression::from(0),
    ArgumentExpression::from(0),
    ArgumentExpression::from(0),
];
let expression = table.symmetric_difference(capacity, indices);
let expected = model.create_set(object_type, &[0, 1]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

let indices = vec![
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
    ArgumentExpression::from(variable),
];
let expression = table.symmetric_difference(capacity, indices);
let expected = model.create_set(object_type, &[]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);
source§

impl<T> TableHandle<T>

source

pub fn id(&self) -> usize

Returns the id

Trait Implementations§

source§

impl<T: Clone> Clone for TableHandle<T>

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<T: Debug> Debug for TableHandle<T>

source§

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

Formats the value using the given formatter. Read more
source§

impl<T: PartialEq> PartialEq for TableHandle<T>

source§

fn eq(&self, other: &TableHandle<T>) -> bool

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

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.
source§

impl<T: Copy> Copy for TableHandle<T>

source§

impl<T: Eq> Eq for TableHandle<T>

source§

impl<T> StructuralPartialEq for TableHandle<T>

Auto Trait Implementations§

§

impl<T> Freeze for TableHandle<T>

§

impl<T> RefUnwindSafe for TableHandle<T>
where T: RefUnwindSafe,

§

impl<T> Send for TableHandle<T>
where T: Send,

§

impl<T> Sync for TableHandle<T>
where T: Sync,

§

impl<T> Unpin for TableHandle<T>
where T: Unpin,

§

impl<T> UnwindSafe for TableHandle<T>
where T: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.