Struct dypdl::Table2DHandle

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

A struct wrapping the id of a table.

Implementations

impl Table2DHandle<bool>

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

where ElementExpression: From<T> + From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d(
    "table",
    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, 1);
assert!(expression.eval(&state, &model.table_registry));

impl Table2DHandle<Continuous>

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

where ElementExpression: From<T> + From<U>,

Returns a constant in a 2D continuous table.

Examples

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

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

pub fn sum_x<T, U>(&self, x: T, y: U) -> ContinuousExpression

where SetExpression: From<T>, ElementExpression: From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let x = model.add_set_variable("x", object_type, set).unwrap();
let y = model.add_element_variable("y", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.sum_x(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.6);

pub fn sum_y<T, U>(&self, x: T, y: U) -> ContinuousExpression

where ElementExpression: From<T>, SetExpression: From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.add_element_variable("x", object_type, 0).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, set).unwrap();
let state = model.target.clone();

let expression = table.sum_y(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.5);

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

where SetExpression: From<T> + From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, x.clone()).unwrap();
let state = model.target.clone();

let expression = table.sum(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 1.4);

pub fn product_x<T, U>(&self, x: T, y: U) -> ContinuousExpression

where SetExpression: From<T>, ElementExpression: From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let x = model.add_set_variable("x", object_type, set).unwrap();
let y = model.add_element_variable("y", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.product_x(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.08);

pub fn product_y<T, U>(&self, x: T, y: U) -> ContinuousExpression

where ElementExpression: From<T>, SetExpression: From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.add_element_variable("x", object_type, 0).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, set).unwrap();
let state = model.target.clone();

let expression = table.product_y(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.06);

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

where SetExpression: From<T> + From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, x.clone()).unwrap();
let state = model.target.clone();

let expression = table.product(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.012);

pub fn max_x<T, U>(&self, x: T, y: U) -> ContinuousExpression

where SetExpression: From<T>, ElementExpression: From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let x = model.add_set_variable("x", object_type, set).unwrap();
let y = model.add_element_variable("y", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.max_x(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.4);

pub fn max_y<T, U>(&self, x: T, y: U) -> ContinuousExpression

where ElementExpression: From<T>, SetExpression: From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.add_element_variable("x", object_type, 0).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, set).unwrap();
let state = model.target.clone();

let expression = table.max_y(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.3);

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

where SetExpression: From<T> + From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, x.clone()).unwrap();
let state = model.target.clone();

let expression = table.max(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.5);

pub fn min_x<T, U>(&self, x: T, y: U) -> ContinuousExpression

where SetExpression: From<T>, ElementExpression: From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let x = model.add_set_variable("x", object_type, set).unwrap();
let y = model.add_element_variable("y", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.min_x(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.2);

pub fn min_y<T, U>(&self, x: T, y: U) -> ContinuousExpression

where ElementExpression: From<T>, SetExpression: From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.add_element_variable("x", object_type, 0).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, set).unwrap();
let state = model.target.clone();

let expression = table.min_y(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.2);

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

where SetExpression: From<T> + From<U>,

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

Examples

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

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![0.2, 0.3], vec![0.4, 0.5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, x.clone()).unwrap();
let state = model.target.clone();

let expression = table.min(x, y);
assert_relative_eq!(expression.eval(&state, &model.table_registry), 0.2);

impl Table2DHandle<Element>

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

where ElementExpression: From<T> + From<U>,

Returns a constant in a 2D element table.

Examples

use dypdl::prelude::*;

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

impl Table2DHandle<Integer>

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

where ElementExpression: From<T> + From<U>,

Returns a constant in a 2D integer table.

Examples

use dypdl::prelude::*;

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

pub fn sum_x<T, U>(&self, x: T, y: U) -> IntegerExpression

where SetExpression: From<T>, ElementExpression: From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let x = model.add_set_variable("x", object_type, set).unwrap();
let y = model.add_element_variable("y", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.sum_x(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 6);

pub fn sum_y<T, U>(&self, x: T, y: U) -> IntegerExpression

where ElementExpression: From<T>, SetExpression: From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.add_element_variable("x", object_type, 0).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, set).unwrap();
let state = model.target.clone();

let expression = table.sum_y(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 5);

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

where SetExpression: From<T> + From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, x.clone()).unwrap();
let state = model.target.clone();

let expression = table.sum(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 14);

pub fn product_x<T, U>(&self, x: T, y: U) -> IntegerExpression

where SetExpression: From<T>, ElementExpression: From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let x = model.add_set_variable("x", object_type, set).unwrap();
let y = model.add_element_variable("y", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.product_x(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 8);

pub fn product_y<T, U>(&self, x: T, y: U) -> IntegerExpression

where ElementExpression: From<T>, SetExpression: From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.add_element_variable("x", object_type, 0).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, set).unwrap();
let state = model.target.clone();

let expression = table.product_y(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 6);

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

where SetExpression: From<T> + From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, x.clone()).unwrap();
let state = model.target.clone();

let expression = table.product(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 120);

pub fn max_x<T, U>(&self, x: T, y: U) -> IntegerExpression

where SetExpression: From<T>, ElementExpression: From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let x = model.add_set_variable("x", object_type, set).unwrap();
let y = model.add_element_variable("y", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.max_x(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 4);

pub fn max_y<T, U>(&self, x: T, y: U) -> IntegerExpression

where ElementExpression: From<T>, SetExpression: From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.add_element_variable("x", object_type, 0).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, set).unwrap();
let state = model.target.clone();

let expression = table.max_y(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 3);

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

where SetExpression: From<T> + From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, x.clone()).unwrap();
let state = model.target.clone();

let expression = table.max(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 5);

pub fn min_x<T, U>(&self, x: T, y: U) -> IntegerExpression

where SetExpression: From<T>, ElementExpression: From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let x = model.add_set_variable("x", object_type, set).unwrap();
let y = model.add_element_variable("y", object_type, 0).unwrap();
let state = model.target.clone();

let expression = table.min_x(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 2);

pub fn min_y<T, U>(&self, x: T, y: U) -> IntegerExpression

where ElementExpression: From<T>, SetExpression: From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.add_element_variable("x", object_type, 0).unwrap();
let set = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, set).unwrap();
let state = model.target.clone();

let expression = table.min_y(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 2);

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

where SetExpression: From<T> + From<U>,

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

Examples

use dypdl::prelude::*;

let mut model = Model::default();
let table = model.add_table_2d("table", vec![vec![2, 3], vec![4, 5]]).unwrap();
let object_type = model.add_object_type("object", 2).unwrap();
let x = model.create_set(object_type, &[0, 1]).unwrap();
let y = model.add_set_variable("y", object_type, x.clone()).unwrap();
let state = model.target.clone();

let expression = table.min(x, y);
assert_eq!(expression.eval(&state, &model.table_registry), 2);

impl Table2DHandle<Set>

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

where ElementExpression: From<T> + From<U>,

Returns a constant in a 2D 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_2d("table", 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, 0);
assert_eq!(expression.eval(&state, &model.table_registry), a);

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

where ArgumentExpression: From<T> + From<U>,

Returns the union of sets in a 2D table.

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_2d("table", vec![vec![a.clone(), b.clone()], 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, 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);
let expected = model.create_set(object_type, &[0, 1]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

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

where ArgumentExpression: From<T> + From<U>,

Returns the intersection of sets in a 2D table.

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_2d("table", vec![vec![a.clone(), b.clone()], 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, 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);
let expected = model.create_set(object_type, &[]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

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

where ArgumentExpression: From<T> + From<U>,

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

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_2d("table", vec![vec![a.clone(), b.clone()], 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, 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);
let expected = model.create_set(object_type, &[]).unwrap();
assert_eq!(expression.eval(&state, &model.table_registry), expected);

impl<T> Table2DHandle<T>

pub fn id(&self) -> usize

Returns the id

Trait Implementations

impl<T: Clone> Clone for Table2DHandle<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Table2DHandle<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Table2DHandle<T>

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

impl<T: Eq> Eq for Table2DHandle<T>

impl<T> StructuralEq for Table2DHandle<T>

impl<T> StructuralPartialEq for Table2DHandle<T>