Struct BinaryRelation 

pub struct BinaryRelation<A: Ord, B: Ord> { /* private fields */ }

Finite binary relation type. A finite binary relation.

The starter implementation stores pairs in a BTreeSet so iteration order is deterministic.

Composition direction is:

r.compose(&s) = { (a, c) | exists b. (a, b) in r and (b, c) in s }

Examples

use relmath::{BinaryRelation, UnaryRelation};

let user_role = BinaryRelation::from_pairs([
    ("ann", "admin"),
    ("bob", "reviewer"),
]);

let extra_role = BinaryRelation::from_pairs([
    ("bob", "reviewer"),
    ("cara", "guest"),
]);

let role_permission = BinaryRelation::from_pairs([
    ("admin", "read"),
    ("reviewer", "approve"),
    ("guest", "view"),
]);

assert_eq!(
    user_role.union(&extra_role).to_vec(),
    vec![("ann", "admin"), ("bob", "reviewer"), ("cara", "guest")]
);
assert_eq!(
    user_role.intersection(&extra_role).to_vec(),
    vec![("bob", "reviewer")]
);
assert_eq!(user_role.difference(&extra_role).to_vec(), vec![("ann", "admin")]);
assert_eq!(
    user_role.converse().to_vec(),
    vec![("admin", "ann"), ("reviewer", "bob")]
);

let effective_permission = user_role.union(&extra_role).compose(&role_permission);
assert!(effective_permission.contains(&"ann", &"read"));
assert_eq!(
    effective_permission.iter().copied().collect::<Vec<_>>(),
    vec![("ann", "read"), ("bob", "approve"), ("cara", "view")]
);
assert_eq!(
    effective_permission.domain().to_vec(),
    vec!["ann", "bob", "cara"]
);
assert_eq!(
    effective_permission.range().to_vec(),
    vec!["approve", "read", "view"]
);
assert_eq!(
    effective_permission
        .restrict_domain(&UnaryRelation::from_values(["ann", "cara"]))
        .to_vec(),
    vec![("ann", "read"), ("cara", "view")]
);
assert_eq!(
    effective_permission
        .restrict_range(&UnaryRelation::from_values(["read", "view"]))
        .to_vec(),
    vec![("ann", "read"), ("cara", "view")]
);
assert_eq!(
    effective_permission.image(&UnaryRelation::singleton("bob")).to_vec(),
    vec!["approve"]
);
assert_eq!(
    effective_permission
        .preimage(&UnaryRelation::from_values(["read", "view"]))
        .to_vec(),
    vec!["ann", "cara"]
);

Implementations

impl<A: Ord, B: Ord> BinaryRelation<A, B>

pub fn new() -> Self

Creates an empty binary relation.

pub fn from_pairs<I>(pairs: I) -> Self

where I: IntoIterator<Item = (A, B)>,

Creates a binary relation from the provided pairs.

Examples found in repository

examples/workflow.rs (lines 6-10)

fn main() {
    let step = BinaryRelation::from_pairs([
        ("Draft", "Review"),
        ("Review", "Approved"),
        ("Review", "Rejected"),
    ]);

    let states =
        UnaryRelation::from_values(["Draft", "Review", "Approved", "Rejected", "Archived"]);
    let reachable = step.reflexive_transitive_closure(&states);
    let draft = UnaryRelation::singleton("Draft");

    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Approved"));

    println!(
        "reachable from Draft: {:?}",
        reachable.image(&draft).to_vec()
    );
}

examples/family.rs (lines 6-12)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/access_control.rs (lines 6-11)

fn main() {
    let user_role = BinaryRelation::from_pairs([
        ("ann", "admin"),
        ("bob", "analyst"),
        ("bob", "reviewer"),
        ("cara", "guest"),
    ]);

    let role_permission = BinaryRelation::from_pairs([
        ("admin", "read"),
        ("admin", "write"),
        ("admin", "deploy"),
        ("analyst", "read"),
        ("reviewer", "approve"),
        ("guest", "read"),
    ]);

    let effective_permission = user_role.compose(&role_permission);
    let bob = UnaryRelation::singleton("bob");
    let bob_permissions = effective_permission.image(&bob);

    assert!(effective_permission.contains(&"ann", &"deploy"));
    assert!(bob_permissions.contains(&"approve"));
    assert!(bob_permissions.contains(&"read"));

    println!(
        "effective permissions for bob: {:?}",
        bob_permissions.to_vec()
    );
}

examples/provenance.rs (lines 12-15)

fn main() {
    let gene_disease = ProvenanceRelation::from_facts([
        (("BRCA1", "BreastCancer"), "curated_panel"),
        (("BRCA1", "BreastCancer"), "paper_12"),
        (("TP53", "BreastCancer"), "paper_77"),
    ]);

    let disease_drug = relmath::BinaryRelation::from_pairs([
        ("BreastCancer", "Olaparib"),
        ("BreastCancer", "Tamoxifen"),
    ]);

    let supported_gene_disease = gene_disease.to_binary_relation();
    let gene_drug = supported_gene_disease.compose(&disease_drug);
    let brca1 = UnaryRelation::singleton("BRCA1");
    let brca1_witness = gene_disease
        .why(&("BRCA1", "BreastCancer"))
        .expect("expected explanation");

    assert_eq!(
        gene_drug.image(&brca1).to_vec(),
        vec!["Olaparib", "Tamoxifen"]
    );
    assert_eq!(brca1_witness.to_vec(), vec!["curated_panel", "paper_12"]);
    assert!(brca1_witness.contains_token(&"paper_12"));
    assert_eq!(
        gene_disease
            .provenance_of(&("BRCA1", "BreastCancer"))
            .expect("expected explanation")
            .to_vec(),
        brca1_witness.to_vec()
    );
    assert_eq!(
        gene_disease.support().to_vec(),
        vec![("BRCA1", "BreastCancer"), ("TP53", "BreastCancer")]
    );
    assert!(gene_disease.why(&("BRCA1", "Olaparib")).is_none());

    println!(
        "why BRCA1 links to BreastCancer in the base evidence: {:?}",
        brca1_witness.to_vec()
    );
}

pub fn insert(&mut self, left: A, right: B) -> bool

Inserts a pair into the relation.

Returns true when the pair was not already present.

pub fn contains(&self, left: &A, right: &B) -> bool

Returns true when the relation contains the given pair.

Examples found in repository

examples/workflow.rs (line 17)

fn main() {
    let step = BinaryRelation::from_pairs([
        ("Draft", "Review"),
        ("Review", "Approved"),
        ("Review", "Rejected"),
    ]);

    let states =
        UnaryRelation::from_values(["Draft", "Review", "Approved", "Rejected", "Archived"]);
    let reachable = step.reflexive_transitive_closure(&states);
    let draft = UnaryRelation::singleton("Draft");

    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Approved"));

    println!(
        "reachable from Draft: {:?}",
        reachable.image(&draft).to_vec()
    );
}

examples/family.rs (line 21)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/access_control.rs (line 26)

fn main() {
    let user_role = BinaryRelation::from_pairs([
        ("ann", "admin"),
        ("bob", "analyst"),
        ("bob", "reviewer"),
        ("cara", "guest"),
    ]);

    let role_permission = BinaryRelation::from_pairs([
        ("admin", "read"),
        ("admin", "write"),
        ("admin", "deploy"),
        ("analyst", "read"),
        ("reviewer", "approve"),
        ("guest", "read"),
    ]);

    let effective_permission = user_role.compose(&role_permission);
    let bob = UnaryRelation::singleton("bob");
    let bob_permissions = effective_permission.image(&bob);

    assert!(effective_permission.contains(&"ann", &"deploy"));
    assert!(bob_permissions.contains(&"approve"));
    assert!(bob_permissions.contains(&"read"));

    println!(
        "effective permissions for bob: {:?}",
        bob_permissions.to_vec()
    );
}

pub fn iter(&self) -> impl Iterator<Item = &(A, B)>

Returns an iterator over the stored pairs in deterministic order.

pub fn domain(&self) -> UnaryRelation<A>

where A: Clone,

Returns the domain of the relation.

pub fn range(&self) -> UnaryRelation<B>

where B: Clone,

Returns the range of the relation.

pub fn converse(&self) -> BinaryRelation<B, A>

where A: Clone, B: Clone,

Returns the converse relation.

pub fn union(&self, other: &Self) -> Self

where A: Clone, B: Clone,

Returns the union of self and other.

pub fn intersection(&self, other: &Self) -> Self

where A: Clone, B: Clone,

Returns the intersection of self and other.

pub fn difference(&self, other: &Self) -> Self

where A: Clone, B: Clone,

Returns the set difference self \ other.

pub fn restrict_domain(&self, allowed: &UnaryRelation<A>) -> Self

where A: Clone, B: Clone,

Restricts the domain of the relation to allowed.

pub fn restrict_range(&self, allowed: &UnaryRelation<B>) -> Self

where A: Clone, B: Clone,

Restricts the range of the relation to allowed.

pub fn image(&self, sources: &UnaryRelation<A>) -> UnaryRelation<B>

where B: Clone,

Computes the image of sources through the relation.

Returns { b | exists a in sources. (a, b) in self }.

Examples found in repository

examples/workflow.rs (line 22)

fn main() {
    let step = BinaryRelation::from_pairs([
        ("Draft", "Review"),
        ("Review", "Approved"),
        ("Review", "Rejected"),
    ]);

    let states =
        UnaryRelation::from_values(["Draft", "Review", "Approved", "Rejected", "Archived"]);
    let reachable = step.reflexive_transitive_closure(&states);
    let draft = UnaryRelation::singleton("Draft");

    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Approved"));

    println!(
        "reachable from Draft: {:?}",
        reachable.image(&draft).to_vec()
    );
}

examples/family.rs (line 19)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/access_control.rs (line 24)

fn main() {
    let user_role = BinaryRelation::from_pairs([
        ("ann", "admin"),
        ("bob", "analyst"),
        ("bob", "reviewer"),
        ("cara", "guest"),
    ]);

    let role_permission = BinaryRelation::from_pairs([
        ("admin", "read"),
        ("admin", "write"),
        ("admin", "deploy"),
        ("analyst", "read"),
        ("reviewer", "approve"),
        ("guest", "read"),
    ]);

    let effective_permission = user_role.compose(&role_permission);
    let bob = UnaryRelation::singleton("bob");
    let bob_permissions = effective_permission.image(&bob);

    assert!(effective_permission.contains(&"ann", &"deploy"));
    assert!(bob_permissions.contains(&"approve"));
    assert!(bob_permissions.contains(&"read"));

    println!(
        "effective permissions for bob: {:?}",
        bob_permissions.to_vec()
    );
}

examples/annotated.rs (line 44)

fn main() {
    let confirmations = AnnotatedRelation::from_facts([
        (("Alice", "Math"), SupportCount(1)),
        (("Alice", "Math"), SupportCount(1)),
        (("Bob", "Physics"), SupportCount(1)),
        (("Cara", "Logic"), SupportCount::zero()),
    ]);

    let exact_completed = confirmations.to_binary_relation();
    let alice = UnaryRelation::singleton("Alice");

    assert_eq!(
        confirmations.annotation_of(&("Alice", "Math")),
        Some(&SupportCount(2))
    );
    assert_eq!(exact_completed.image(&alice).to_vec(), vec!["Math"]);
    assert!(!confirmations.contains_fact(&("Cara", "Logic")));
    assert_eq!(
        confirmations
            .iter()
            .map(|(fact, count)| (*fact, count.0))
            .collect::<Vec<_>>(),
        vec![(("Alice", "Math"), 2), (("Bob", "Physics"), 1)]
    );

    println!(
        "stored support counts: {:?}",
        confirmations
            .iter()
            .map(|(fact, count)| (*fact, count.0))
            .collect::<Vec<_>>()
    );
}

examples/provenance.rs (line 25)

fn main() {
    let gene_disease = ProvenanceRelation::from_facts([
        (("BRCA1", "BreastCancer"), "curated_panel"),
        (("BRCA1", "BreastCancer"), "paper_12"),
        (("TP53", "BreastCancer"), "paper_77"),
    ]);

    let disease_drug = relmath::BinaryRelation::from_pairs([
        ("BreastCancer", "Olaparib"),
        ("BreastCancer", "Tamoxifen"),
    ]);

    let supported_gene_disease = gene_disease.to_binary_relation();
    let gene_drug = supported_gene_disease.compose(&disease_drug);
    let brca1 = UnaryRelation::singleton("BRCA1");
    let brca1_witness = gene_disease
        .why(&("BRCA1", "BreastCancer"))
        .expect("expected explanation");

    assert_eq!(
        gene_drug.image(&brca1).to_vec(),
        vec!["Olaparib", "Tamoxifen"]
    );
    assert_eq!(brca1_witness.to_vec(), vec!["curated_panel", "paper_12"]);
    assert!(brca1_witness.contains_token(&"paper_12"));
    assert_eq!(
        gene_disease
            .provenance_of(&("BRCA1", "BreastCancer"))
            .expect("expected explanation")
            .to_vec(),
        brca1_witness.to_vec()
    );
    assert_eq!(
        gene_disease.support().to_vec(),
        vec![("BRCA1", "BreastCancer"), ("TP53", "BreastCancer")]
    );
    assert!(gene_disease.why(&("BRCA1", "Olaparib")).is_none());

    println!(
        "why BRCA1 links to BreastCancer in the base evidence: {:?}",
        brca1_witness.to_vec()
    );
}

pub fn preimage(&self, targets: &UnaryRelation<B>) -> UnaryRelation<A>

where A: Clone,

Computes the preimage of targets through the relation.

Returns { a | exists b in targets. (a, b) in self }.

pub fn compose<C>(&self, rhs: &BinaryRelation<B, C>) -> BinaryRelation<A, C>

where A: Clone, B: Clone, C: Clone + Ord,

Composes self with rhs.

The result contains (a, c) whenever there exists b such that (a, b) is in self and (b, c) is in rhs.

Examples

use relmath::BinaryRelation;

let user_role = BinaryRelation::from_pairs([
    ("ann", "admin"),
    ("bob", "reviewer"),
]);
let role_permission = BinaryRelation::from_pairs([
    ("admin", "read"),
    ("reviewer", "approve"),
]);

let effective_permission = user_role.compose(&role_permission);

assert_eq!(
    effective_permission.to_vec(),
    vec![("ann", "read"), ("bob", "approve")]
);

Examples found in repository

examples/family.rs (line 15)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

examples/access_control.rs (line 22)

fn main() {
    let user_role = BinaryRelation::from_pairs([
        ("ann", "admin"),
        ("bob", "analyst"),
        ("bob", "reviewer"),
        ("cara", "guest"),
    ]);

    let role_permission = BinaryRelation::from_pairs([
        ("admin", "read"),
        ("admin", "write"),
        ("admin", "deploy"),
        ("analyst", "read"),
        ("reviewer", "approve"),
        ("guest", "read"),
    ]);

    let effective_permission = user_role.compose(&role_permission);
    let bob = UnaryRelation::singleton("bob");
    let bob_permissions = effective_permission.image(&bob);

    assert!(effective_permission.contains(&"ann", &"deploy"));
    assert!(bob_permissions.contains(&"approve"));
    assert!(bob_permissions.contains(&"read"));

    println!(
        "effective permissions for bob: {:?}",
        bob_permissions.to_vec()
    );
}

examples/provenance.rs (line 18)

fn main() {
    let gene_disease = ProvenanceRelation::from_facts([
        (("BRCA1", "BreastCancer"), "curated_panel"),
        (("BRCA1", "BreastCancer"), "paper_12"),
        (("TP53", "BreastCancer"), "paper_77"),
    ]);

    let disease_drug = relmath::BinaryRelation::from_pairs([
        ("BreastCancer", "Olaparib"),
        ("BreastCancer", "Tamoxifen"),
    ]);

    let supported_gene_disease = gene_disease.to_binary_relation();
    let gene_drug = supported_gene_disease.compose(&disease_drug);
    let brca1 = UnaryRelation::singleton("BRCA1");
    let brca1_witness = gene_disease
        .why(&("BRCA1", "BreastCancer"))
        .expect("expected explanation");

    assert_eq!(
        gene_drug.image(&brca1).to_vec(),
        vec!["Olaparib", "Tamoxifen"]
    );
    assert_eq!(brca1_witness.to_vec(), vec!["curated_panel", "paper_12"]);
    assert!(brca1_witness.contains_token(&"paper_12"));
    assert_eq!(
        gene_disease
            .provenance_of(&("BRCA1", "BreastCancer"))
            .expect("expected explanation")
            .to_vec(),
        brca1_witness.to_vec()
    );
    assert_eq!(
        gene_disease.support().to_vec(),
        vec![("BRCA1", "BreastCancer"), ("TP53", "BreastCancer")]
    );
    assert!(gene_disease.why(&("BRCA1", "Olaparib")).is_none());

    println!(
        "why BRCA1 links to BreastCancer in the base evidence: {:?}",
        brca1_witness.to_vec()
    );
}

pub fn to_vec(&self) -> Vec<(A, B)>

where A: Clone, B: Clone,

Converts the relation into a sorted vector of pairs.

Examples found in repository

examples/family.rs (line 25)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

impl<T: Ord> BinaryRelation<T, T>

pub fn carrier(&self) -> UnaryRelation<T>

where T: Clone,

Returns the carrier induced by the relation: domain union range.

pub fn identity(carrier: &UnaryRelation<T>) -> Self

where T: Clone,

Returns the identity relation on carrier.

Examples

use relmath::{BinaryRelation, UnaryRelation};

let carrier = UnaryRelation::from_values(["Draft", "Review"]);

assert_eq!(
    BinaryRelation::identity(&carrier).to_vec(),
    vec![("Draft", "Draft"), ("Review", "Review")]
);

pub fn transitive_closure(&self) -> Self

where T: Clone,

Computes the transitive closure of the relation.

Examples

use relmath::BinaryRelation;

let step = BinaryRelation::from_pairs([
    ("Draft", "Review"),
    ("Review", "Approved"),
]);

assert_eq!(
    step.transitive_closure().to_vec(),
    vec![
        ("Draft", "Approved"),
        ("Draft", "Review"),
        ("Review", "Approved"),
    ]
);

pub fn reflexive_transitive_closure(&self, carrier: &UnaryRelation<T>) -> Self

where T: Clone,

Computes the reflexive-transitive closure on the given carrier.

Values that appear in carrier but not in any pair still gain their identity edge in the result.

Examples

use relmath::{BinaryRelation, UnaryRelation};

let step = BinaryRelation::from_pairs([("Draft", "Review")]);
let states = UnaryRelation::from_values(["Draft", "Review", "Archived"]);
let reachable = step.reflexive_transitive_closure(&states);

assert!(reachable.contains(&"Archived", &"Archived"));
assert!(reachable.contains(&"Draft", &"Review"));

Examples found in repository

examples/workflow.rs (line 14)

fn main() {
    let step = BinaryRelation::from_pairs([
        ("Draft", "Review"),
        ("Review", "Approved"),
        ("Review", "Rejected"),
    ]);

    let states =
        UnaryRelation::from_values(["Draft", "Review", "Approved", "Rejected", "Archived"]);
    let reachable = step.reflexive_transitive_closure(&states);
    let draft = UnaryRelation::singleton("Draft");

    assert!(reachable.contains(&"Archived", &"Archived"));
    assert!(reachable.contains(&"Draft", &"Approved"));

    println!(
        "reachable from Draft: {:?}",
        reachable.image(&draft).to_vec()
    );
}

examples/family.rs (line 16)

fn main() {
    let parent = BinaryRelation::from_pairs([
        ("Ada", "Bob"),
        ("Ada", "Cara"),
        ("Bob", "Dana"),
        ("Cara", "Eli"),
        ("Dana", "Finn"),
    ]);

    let people = UnaryRelation::from_values(["Ada", "Bob", "Cara", "Dana", "Eli", "Finn"]);
    let grandparent = parent.compose(&parent);
    let ancestor = parent.reflexive_transitive_closure(&people);

    let ada = UnaryRelation::singleton("Ada");
    let reachable_from_ada = ancestor.image(&ada);

    assert!(grandparent.contains(&"Ada", &"Dana"));
    assert!(grandparent.contains(&"Ada", &"Eli"));
    assert!(reachable_from_ada.contains(&"Finn"));

    println!("grandparent pairs: {:?}", grandparent.to_vec());
    println!(
        "people reachable from Ada: {:?}",
        reachable_from_ada.to_vec()
    );
}

pub fn is_reflexive(&self, carrier: &UnaryRelation<T>) -> bool

Returns true when the relation is reflexive on carrier.

pub fn is_irreflexive(&self, carrier: &UnaryRelation<T>) -> bool

Returns true when the relation is irreflexive on carrier.

pub fn is_symmetric(&self) -> bool

Returns true when the relation is symmetric.

pub fn is_antisymmetric(&self) -> bool

Returns true when the relation is antisymmetric.

pub fn is_transitive(&self) -> bool

where T: Clone,

Returns true when the relation is transitive.

pub fn is_equivalence(&self, carrier: &UnaryRelation<T>) -> bool

where T: Clone,

Returns true when the relation is an equivalence relation on carrier.

Examples

use relmath::{BinaryRelation, UnaryRelation};

let aliases = BinaryRelation::from_pairs([
    ("A. Smith", "A. Smith"),
    ("A. Smith", "Alice Smith"),
    ("Alice Smith", "A. Smith"),
    ("Alice Smith", "Alice Smith"),
]);
let carrier = UnaryRelation::from_values(["A. Smith", "Alice Smith"]);

assert!(aliases.is_equivalence(&carrier));

pub fn is_partial_order(&self, carrier: &UnaryRelation<T>) -> bool

where T: Clone,

Returns true when the relation is a partial order on carrier.

Examples

use relmath::{BinaryRelation, UnaryRelation};

let divides = BinaryRelation::from_pairs([
    (1_u8, 1_u8),
    (1, 2),
    (1, 4),
    (2, 2),
    (2, 4),
    (4, 4),
]);
let carrier = UnaryRelation::from_values([1_u8, 2_u8, 4_u8]);

assert!(divides.is_partial_order(&carrier));

Trait Implementations

impl<A: Clone + Ord, B: Clone + Ord> Clone for BinaryRelation<A, B>

fn clone(&self) -> BinaryRelation<A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Ord, B: Debug + Ord> Debug for BinaryRelation<A, B>

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

Formats the value using the given formatter.

impl<A: Ord, B: Ord> Default for BinaryRelation<A, B>

fn default() -> Self

Returns the “default value” for a type.

impl<A: Ord, B: Ord> Extend<(A, B)> for BinaryRelation<A, B>

fn extend<I: IntoIterator<Item = (A, B)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<A: Ord, B: Ord> FiniteRelation for BinaryRelation<A, B>

fn len(&self) -> usize

Returns the number of stored tuples in the relation.

fn is_empty(&self) -> bool

Returns true when the relation contains no tuples.

impl<A: Ord, B: Ord> FromIterator<(A, B)> for BinaryRelation<A, B>

fn from_iter<I: IntoIterator<Item = (A, B)>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a, A: Ord, B: Ord> IntoIterator for &'a BinaryRelation<A, B>

type Item = &'a (A, B)

The type of the elements being iterated over.

type IntoIter = Iter<'a, (A, B)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Ord, B: Ord> IntoIterator for BinaryRelation<A, B>

type Item = (A, B)

The type of the elements being iterated over.

type IntoIter = IntoIter<(A, B)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: PartialEq + Ord, B: PartialEq + Ord> PartialEq for BinaryRelation<A, B>

fn eq(&self, other: &BinaryRelation<A, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: Eq + Ord, B: Eq + Ord> Eq for BinaryRelation<A, B>

impl<A: Ord, B: Ord> StructuralPartialEq for BinaryRelation<A, B>