Struct RuleSet 

pub struct RuleSet { /* private fields */ }

An ordered collection of Rules.

At each node the rules are tried in order and the first one that applies wins. RuleSet is Clone + Send + Sync.

Examples

use symplex::prelude::*;
use symplex::macros::{Rule, RuleSet};

let ctx = Context::new();
let (x, a) = (ctx.symbol("x"), ctx.symbol("a_"));
let rules = RuleSet::new()
    .with(Rule::new("cos_sq", &a.cos().powi(2), &(1 - &a.sin().powi(2))))
    .with(Rule::new("tan", &(&a.sin() / &a.cos()), &a.tan()));
assert_eq!(rules.len(), 2);
let expr = &x.cos().powi(2) + &x.sin() / &x.cos();
assert_eq!(format!("{}", expr.rewrite(&rules)), "-sin(x)^2 + tan(x) + 1");

Implementations

impl RuleSet

pub fn new() -> Self

An empty rule set.

pub fn from_rules(rules: Vec<Rule>) -> Self

Build from a vector of rules (order is preserved).

pub fn from_macro_rules(ctx: &Context, rules: Vec<Rule>) -> Self

Wrap arena-level rules produced by the rule! macro.

Examples

use symplex::prelude::*;
use symplex::macros::RuleSet;

let ctx = Context::new();
let x = ctx.symbol("x");
let raw = ctx.with_arena_mut(|arena| {
    vec![
        rule!(arena, "exp_ln", exp(ln(w_)) => w_),
        rule!(arena, "sin_asin", sin(asin(w_)) => w_),
    ]
});
let rules = RuleSet::from_macro_rules(&ctx, raw);
assert_eq!(format!("{}", (&x.ln().exp() + &x.asin().sin()).rewrite(&rules)), "2*x");

pub fn standard(ctx: &Context) -> Self

The built-in simplification rules used by simplify (Pythagorean identities, exp(ln x) → x, sin/cos → tan, inverse-function compositions, …), as a rule set for ctx.

pub fn push(&mut self, rule: Rule)

Append a rule.

pub fn with(self, rule: Rule) -> Self

Builder-style append.

pub fn extend(&mut self, other: &RuleSet)

Append all rules of other.

pub fn len(&self) -> usize

Number of rules.

pub fn is_empty(&self) -> bool

true if the set has no rules.

pub fn iter(&self) -> impl Iterator<Item = &Rule>

Iterate over the rules in order.

pub fn rules(&self) -> &[Rule]

The rules as a slice.

Trait Implementations

impl Clone for RuleSet

fn clone(&self) -> RuleSet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuleSet

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

Formats the value using the given formatter.

impl Default for RuleSet

fn default() -> RuleSet

Returns the “default value” for a type.

impl From<Vec<Rule>> for RuleSet

fn from(rules: Vec<Rule>) -> Self

Converts to this type from the input type.

impl FromIterator<Rule> for RuleSet

fn from_iter<I: IntoIterator<Item = Rule>>(iter: I) -> Self

Creates a value from an iterator.

impl Index<usize> for RuleSet

type Output = Rule

The returned type after indexing.

fn index(&self, i: usize) -> &Rule

Performs the indexing (container[index]) operation.