Struct aces::Polynomial

pub struct Polynomial<T: Atomic> { /* fields omitted */ }

A formal polynomial.

Internally a Polynomial is represented as a vector of N Atomic identifiers, a vector of M monomial::Weights, 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, but same for rows of the boolean matrix and elements of the weight vector. 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_spec(
    ctx: ContextHandle,
    port: &Port,
    spec_poly: &[Vec<NonZeroUsize>]
) -> Self

Creates a polynomial from a sequence of vectors of node [ID]s and in a Context given by a ContextHandle.

impl<T: Atomic> Polynomial<T>

pub fn new() -> Self

Creates an empty polynomial, θ.

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, Box<dyn Error>> 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 ids 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: Atomic> Iterator for Monomials<'a, T> type Item = FilterMap<Zip<Iter<'a, T>, Iter<'a>>, fn(_: (&T, bool)) -> Option<T>>;

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

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

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

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 Contextual for Polynomial<LinkID>

fn format(
    &self,
    ctx: &Context,
    dock: Option<Face>
) -> Result<String, Box<dyn Error>>

impl<T: Atomic> PartialOrd<Polynomial<T>> for Polynomial<T>

fn partial_cmp(&self, other: &Self) -> 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.

impl<T: Atomic> PartialEq<Polynomial<T>> for Polynomial<T>

fn eq(&self, other: &Self) -> 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: Atomic> Eq for Polynomial<T>

impl<T: Clone + Atomic> Clone for Polynomial<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.