Struct ascesis::Polynomial

pub struct Polynomial<T> where
    T: Atomic + Debug,  { /* fields omitted */ }

A formal polynomial.

Internally a Polynomial is represented as a vector of N Atomic identifiers and a boolean matrix with N columns and M rows. Vector of Atomic identifiers is sorted in strictly increasing order. It represents the set of nodes occuring in the polynomial and N is the number of such nodes.

M is the number of monomials in the canonical representation of the polynomial. The order in which monomials are listed is arbitrary. An element in row i and column j of the matrix determines if a node in j-th position in the vector of identifiers occurs in i-th monomial.

Polynomials may be compared and added using traits from std::cmp and std::ops standard modules, with the obvious exception of std::cmp::Ord. Note however that, in general, preventing Context or Port mismatch between polynomials is the responsibility of the caller of an operation. Implementation detects some, but not all, cases of mismatch and panics if it does so.

Methods

impl Polynomial<LinkID>

pub fn from_nodes_in_context<'a, I>(
    ctx: &Arc<Mutex<Context>>,
    face: Face,
    node_id: NodeID,
    poly_ids: I
) -> Polynomial<LinkID> where
    I: IntoIterator + 'a,
    <I as IntoIterator>::Item: IntoIterator,
    <<I as IntoIterator>::Item as IntoIterator>::Item == &'a NodeID, 

Creates a polynomial from a sequence of sequences of NodeIDs and in a Context given by a ContextHandle.

impl<T> Polynomial<T> where
    T: Atomic + Debug, 

pub fn new() -> Polynomial<T>

Creates an empty polynomial, θ.

pub fn new_docked(dock: Face) -> Polynomial<T>

Creates an empty polynomial, θ, docked at a given Face.

pub fn clear(&mut self)

Resets this polynomial into θ.

pub fn atomic_multiply(&mut self, atomic: T)

Multiplies this polynomial (all its monomials) by a single-element monomial.

pub fn add_atomics_sorted<I>(&mut self, atomics: I) -> Result<bool, AcesError> where
    I: IntoIterator<Item = T>, 

Adds a sequence of Atomic identifiers to this polynomial as another monomial.

On success, returns true if this polynomial changed or false if it didn't, due to idempotency of addition.

Returns error if atomics aren't given in strictly increasing order, or in case of port mismatch, or if context mismatch was detected.

pub fn is_empty(&self) -> bool

pub fn is_atomic(&self) -> bool

pub fn is_monomial(&self) -> bool

pub fn num_monomials(&self) -> usize

Important traits for Monomials<'a, T>

impl<'a, T> Iterator for Monomials<'a, T> where
    T: Atomic + Debug,  type Item = FilterMap<Zip<Iter<'a, T>, Iter<'a, u32>>, fn((&T, bool)) -> Option<T>>;

pub fn get_monomials(&self) -> Monomials<T>

Creates a Monomials iterator.

pub fn get_atomics(&self) -> Iter<T>

pub fn as_sat_clauses(&self, port_lit: Literal) -> Vec<Clause>

Constructs the firing rule of this polynomial, the logical constraint imposed on firing components, if the polynomial is attached to the node and face represented by port_lit. The rule is transformed into a CNF formula, a conjunction of disjunctions of sat::Literals (a sequence of clauses).

Returns a sequence of clauses in the form of vector of vectors of sat::Literals.

Trait Implementations

impl<T> Clone for Polynomial<T> where
    T: Atomic + Clone + Debug, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Contextual for Polynomial<LinkID>

fn format(
    &self,
    ctx: &Arc<Mutex<Context>>
) -> Result<String, Box<dyn Error + 'static>>

fn with(&self, ctx: &Arc<Mutex<Context>>) -> InContext<Self>

fn with_mut(&mut self, ctx: &Arc<Mutex<Context>>) -> InContextMut<Self>

impl<T> Debug for Polynomial<T> where
    T: Atomic + Debug, 

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

Formats the value using the given formatter.

impl<T> Eq for Polynomial<T> where
    T: Atomic + Debug, 

impl<T> PartialEq<Polynomial<T>> for Polynomial<T> where
    T: Atomic + Debug, 

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

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> PartialOrd<Polynomial<T>> for Polynomial<T> where
    T: Atomic + Debug, 

fn partial_cmp(&self, other: &Polynomial<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.