Struct dypdl::Table3DHandle

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

A struct wrapping the id of a table.

Implementations§

source§

impl Table3DHandle<bool>

source

pub fn element<T, U, V>(&self, x: T, y: U, z: V) -> Condition
where ElementExpression: From<T> + From<U> + From<V>,

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

§Examples
use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![
        vec![vec![true, false], vec![false, true]],
        vec![vec![false, true], 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, variable + 1, 1);
assert!(expression.eval(&state, &model.table_registry));
source§

impl Table3DHandle<Continuous>

source

pub fn element<T, U, V>(&self, x: T, y: U, z: V) -> ContinuousExpression
where ElementExpression: From<T> + From<U> + From<V>,

Returns a constant in a 3D continuous table.

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

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![
        vec![vec![0.2, 0.3], vec![0.4, 0.5]],
        vec![vec![0.6, 0.7], vec![0.8, 0.9]]
    ]
).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, variable + 1, 1);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.5);
source

pub fn sum<T, U, V>(&self, x: T, y: U, z: V) -> ContinuousExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

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

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

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![
        vec![vec![0.2, 0.3], vec![0.4, 0.5]],
        vec![vec![0.6, 0.7], vec![0.8, 0.9]]
    ]
).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 expression = table.sum(set_variable, element_variable, 1);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 1.0);

let expression = table.sum(set, set_variable, set_variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 4.4);
source

pub fn product<T, U, V>(&self, x: T, y: U, z: V) -> ContinuousExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

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

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

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![
        vec![vec![0.2, 0.3], vec![0.4, 0.5]],
        vec![vec![0.6, 0.7], vec![0.8, 0.9]]
    ]
).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 expression = table.product(set_variable, element_variable, 1);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.21);

let expression = table.product(set, set_variable, set_variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.0036288);
source

pub fn max<T, U, V>(&self, x: T, y: U, z: V) -> ContinuousExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

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

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

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![
        vec![vec![0.2, 0.3], vec![0.4, 0.5]],
        vec![vec![0.6, 0.7], vec![0.8, 0.9]]
    ]
).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 expression = table.max(set_variable, element_variable, 1);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.7);

let expression = table.max(set, set_variable, set_variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.9);
source

pub fn min<T, U, V>(&self, x: T, y: U, z: V) -> ContinuousExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

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

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

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![
        vec![vec![0.2, 0.3], vec![0.4, 0.5]],
        vec![vec![0.6, 0.7], vec![0.8, 0.9]]
    ]
).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 expression = table.min(set_variable, element_variable, 1);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.3);

let expression = table.min(set, set_variable, set_variable);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.2);
source§

impl Table3DHandle<Element>

source

pub fn element<T, U, V>(&self, x: T, y: U, z: V) -> ElementExpression
where ElementExpression: From<T> + From<U> + From<V>,

Returns a constant in a 3D element table.

§Examples
use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![vec![vec![1, 0], vec![0, 1]], vec![vec![0, 1], 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 = Table3DHandle::<Element>::element(&table, variable, variable + 1, 1);
assert_eq!(expression.eval(&state, &model.table_registry), 1);
source§

impl Table3DHandle<Integer>

source

pub fn element<T, U, V>(&self, x: T, y: U, z: V) -> IntegerExpression
where ElementExpression: From<T> + From<U> + From<V>,

Returns a constant in a 3D integer table.

§Examples
use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![vec![vec![2, 3], vec![4, 5]], vec![vec![6, 7], vec![8, 9]]]
).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 = Table3DHandle::<Integer>::element(&table, variable, variable + 1, 1);
assert_eq!(expression.eval(&state, &model.table_registry), 5);
source

pub fn sum<T, U, V>(&self, x: T, y: U, z: V) -> IntegerExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

Returns the sum of constants over set expressions in a 3D integer table.

§Examples
use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![vec![vec![2, 3], vec![4, 5]], vec![vec![6, 7], vec![8, 9]]]
).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 expression = table.sum(set_variable, element_variable, 1);
assert_eq!(expression.eval(&state, &model.table_registry), 10);

let expression = table.sum(set, set_variable, set_variable);
assert_eq!(expression.eval(&state, &model.table_registry), 44);
source

pub fn product<T, U, V>(&self, x: T, y: U, z: V) -> IntegerExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

Returns the product of constants over set expressions in a 3D integer table.

§Examples
use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![vec![vec![2, 3], vec![4, 5]], vec![vec![6, 7], vec![8, 9]]]
).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 expression = table.product(set_variable, element_variable, 1);
assert_eq!(expression.eval(&state, &model.table_registry), 21);

let expression = table.product(set, set_variable, set_variable);
assert_eq!(expression.eval(&state, &model.table_registry), 362880);
source

pub fn max<T, U, V>(&self, x: T, y: U, z: V) -> IntegerExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

Returns the maximum of constants over set expressions in a 3D integer table.

§Examples
use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![vec![vec![2, 3], vec![4, 5]], vec![vec![6, 7], vec![8, 9]]]
).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 expression = table.max(set_variable, element_variable, 1);
assert_eq!(expression.eval(&state, &model.table_registry), 7);

let expression = table.max(set, set_variable, set_variable);
assert_eq!(expression.eval(&state, &model.table_registry), 9);
source

pub fn min<T, U, V>(&self, x: T, y: U, z: V) -> IntegerExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

Returns the minimum of constants over set expressions in a 3D integer table.

§Examples
use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_3d(
    "table",
    vec![vec![vec![2, 3], vec![4, 5]], vec![vec![6, 7], vec![8, 9]]]
).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 expression = table.min(set_variable, element_variable, 1);
assert_eq!(expression.eval(&state, &model.table_registry), 3);

let expression = table.min(set, set_variable, set_variable);
assert_eq!(expression.eval(&state, &model.table_registry), 2);
source§

impl Table3DHandle<Set>

source

pub fn element<T, U, V>(&self, x: T, y: U, z: V) -> SetExpression
where ElementExpression: From<T> + From<U> + From<V>,

Returns a constant in a 3D 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_3d(
    "table",
    vec![
        vec![vec![a.clone(), b.clone()], vec![b.clone(), a.clone()]],
        vec![vec![a.clone(), b.clone()], vec![b, a.clone()]],
    ]
).unwrap();
let variable = model.add_element_variable("variable", object_type, 0).unwrap();
let state = model.target.clone();

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

pub fn union<T, U, V>(&self, capacity: usize, x: T, y: U, z: V) -> SetExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

Returns the union of sets in a 3D 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_3d(
    "table",
    vec![
        vec![vec![a.clone(), b.clone()], vec![b.clone(), a.clone()]],
        vec![vec![a.clone(), b.clone()], vec![b, a.clone()]],
    ]
).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, 0, 0);
let expected = model.create_set(object_type, &[1]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

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

pub fn intersection<T, U, V>( &self, capacity: usize, x: T, y: U, z: V, ) -> SetExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

Returns the intersection of sets in a 3D 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_3d(
    "table",
    vec![
        vec![vec![a.clone(), b.clone()], vec![b.clone(), a.clone()]],
        vec![vec![a.clone(), b.clone()], vec![b, a.clone()]],
    ]
).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, 0, 0);
let expected = model.create_set(object_type, &[1]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

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

pub fn symmetric_difference<T, U, V>( &self, capacity: usize, x: T, y: U, z: V, ) -> SetExpression
where ArgumentExpression: From<T> + From<U> + From<V>,

Returns the symmetric difference (disjunctive union) of sets in a 3D 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_3d(
    "table",
    vec![
        vec![vec![a.clone(), b.clone()], vec![b.clone(), a.clone()]],
        vec![vec![a.clone(), b.clone()], vec![b, a.clone()]],
    ]
).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, 0, 0);
let expected = model.create_set(object_type, &[]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

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

impl<T> Table3DHandle<T>

source

pub fn id(&self) -> usize

Returns the id

Trait Implementations§

source§

impl<T: Clone> Clone for Table3DHandle<T>

source§

fn clone(&self) -> Table3DHandle<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 Table3DHandle<T>

source§

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

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

impl<T: PartialEq> PartialEq for Table3DHandle<T>

source§

fn eq(&self, other: &Table3DHandle<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 Table3DHandle<T>

source§

impl<T: Eq> Eq for Table3DHandle<T>

source§

impl<T> StructuralPartialEq for Table3DHandle<T>

Auto Trait Implementations§

§

impl<T> Freeze for Table3DHandle<T>

§

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

§

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

§

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

§

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

§

impl<T> UnwindSafe for Table3DHandle<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.