Struct Predicate 

pub struct Predicate { /* private fields */ }

System requirements expressed as the inequality ax≤ b.

See the predicate module for more information on the semantics of this data type.

Implementations

impl Predicate

pub fn new() -> Self

Create a new empty predicate equivalent to 0 ≤ 0.

Examples

use banquo::Predicate;
let mut p = Predicate::new();

pub fn get(&self, name: &str) -> Option<f64>

Return a variable coefficient from the left-hand side of the inequality if it has been set, otherwise return None.

Examples

use banquo::Predicate;

let p = Predicate::from([
    ("x", 1.0), ("y", 3.0), ("z", 2.0),
]);

p.get("x");  // Some(3.0)
p.get("a");  // None

pub fn constant(&self) -> f64

Return the constant from the right-hand side of the inequality.

Examples

use banquo::Predicate;

let p = Predicate::from([
    (None, 5.0), (Some("x"), 1.0), (Some("y"), 2.0), (None, 10.0),
]);

p.constant();  // 15

impl Predicate

pub fn coefficients(&self) -> Coefficients<'_>

Create an iterator over the coefficient terms of the Predicate.

A coefficient term is a term that has a variable. This function does not make any guarantees about the order of iteration of the terms.

Example

let p = banquo::predicate!{ x + 2.0 * y + 3.3 * z <= 4.2 };

for (name, coefficient) in p.coefficients() {
    // ...
}

impl Predicate

pub fn evaluate_state<State>( &self, state: &State, ) -> Result<f64, EvaluationError>

where State: VariableSet,

Evaluate a system state into a robustness value.

The successful output of this function is a f64 value representing the distance of the state from making the inequality represented by the Predicate false. A positive output value indicates that the inequality was not violated, while a negative value indicates the inequality was violated. The unsuccessful output of this function is a [PredicateError] which indicates the nature of the evaluation error.

Any value that implements the VariableSet trait can be evaluated with this method.

Examples

use std::collections::HashMap;

use banquo::predicate::{Predicate, Term};

let state = HashMap::from([
     ("x", 1.0), ("y", 3.0), ("z", f64::NAN),
]);

// BTreeMap also implements the VariableSet trait
// let state = BTreeMap::from([
//     ("x", 1.0), ("y", 3.0), ("z", f64::NAN),
// ]);

let p = Predicate::from([
    Term::from(("x", 1.0)), Term::from(("y", 2.0)), Term::from(10.0)
]);

p.evaluate_state(&state);  // Ok -> 3.0

let p = Predicate::from([
    Term::from(("x", 1.0)), Term::from(("a", 2.0)), Term::from(10.0)
]);

p.evaluate_state(&state);  // Error -> Missing variable "a"

let p = Predicate::from([
    Term::from(("x", 1.0)), Term::from(("z", 2.0)), Term::from(10.0)
]);

p.evaluate_state(&state);  // Error -> Variable "z" has NaN value

let p = Predicate::from([
    Term::from(("x", 1.0)), Term::from(("y", f64::NAN)), Term::from(10.0)
]);

p.evaluate_state(&state);  // Error -> Variable "y" has NaN coefficient

Trait Implementations

impl<T> AddAssign<T> for Predicate

where T: Into<Term>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl Clone for Predicate

fn clone(&self) -> Predicate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Predicate

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

Formats the value using the given formatter.

impl Default for Predicate

fn default() -> Predicate

Returns the “default value” for a type.

impl<State> Formula<State> for Predicate

where State: VariableSet,

Evaluate a Trace of state values by evaluating each state individually.

type Metric = f64

The output metric from this formula

type Error = FormulaError

The type of error that may be produced during evaluation

fn evaluate( &self, trace: &Trace<State>, ) -> Result<Trace<Self::Metric>, Self::Error>

Evaluate a given trace of system states into either a trace of metric values or an error.

impl<T, const N: usize> From<[T; N]> for Predicate

where T: Into<Term>,

fn from(terms: [T; N]) -> Self

Converts to this type from the input type.

impl<T> FromIterator<T> for Predicate

where T: Into<Term>,

fn from_iter<I>(terms: I) -> Self

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl Index<&str> for Predicate

fn index(&self, index: &str) -> &Self::Output

Returns a reference to a coefficient in the predicate

Panics

Panics if the variable does not have a coefficient set

type Output = f64

The returned type after indexing.

impl Neg for Predicate

type Output = Predicate

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Predicate

fn eq(&self, other: &Predicate) -> 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<T> SubAssign<T> for Predicate

where T: Into<Term>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl StructuralPartialEq for Predicate