Struct Xprs 

#[non_exhaustive]
pub struct Xprs<'a> {
    pub root: Element<'a>,
    pub vars: HashSet<&'a str>,
}

Represents a mathematical expression and its variables.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

root: Element<'a>

The root element of the expression.

vars: HashSet<&'a str>

The set of variables present in the expression.

Implementations

impl Xprs<'_>

pub fn eval(&self, variables: &HashMap<&str, f64>) -> Result<f64, EvalError>

Evaluates the expression using the provided variable values. Returns an f64 if the evaluation is successful, or an EvalError if an error occurs.

Errors

An EvalError is returned if a variable is not provided.

Example

use xprs::Xprs;
use std::collections::HashMap;

let expression = "2 * x + y";
let xprs = Xprs::try_from(expression)?;

let mut variable_values = HashMap::new();
variable_values.insert("x", 3.0);
variable_values.insert("y", 2.0);

let result = xprs.eval(&variable_values);
assert_eq!(result, Ok(8.0));

// we didn't provide the variables, so this should fail
let failed_eval = xprs.eval(&HashMap::new());
assert!(failed_eval.is_err());

pub fn eval_unchecked(&self, variables: &HashMap<&str, f64>) -> f64

Evaluates the expression using the provided variable values without error handling. Returns an f64 if the evaluation is successful, or panics if an error occurs.

Panic

Use with caution, as it may panic if variable(s) are missing.

Example

use xprs::Xprs;
use std::collections::HashMap;

let expression = "2 * x + y";
let xprs = Xprs::try_from(expression)?;

let mut variable_values = HashMap::new();
variable_values.insert("x", 3.0);
variable_values.insert("y", 2.0);

let result = xprs.eval_unchecked(&variable_values);
assert_eq!(result, 8.0);

// we didn't provide the variables, so this should panic
assert_panic!(xprs.eval_unchecked(&HashMap::new()));

pub fn simplify_for_in_place(&mut self, var: (&str, f64))

Simplifies the expression in-place for a single variable.

Example

use xprs::Xprs;

let expression = "2 * x + y";
let mut xprs = Xprs::try_from(expression)?;

assert_eq!(format!("{xprs}"), "((2 * x) + y)");
assert_eq!(xprs.vars, ["x", "y"].into());

xprs.simplify_for_in_place(("x", 3.0));

assert_eq!(format!("{xprs}"), "(6 + y)");
assert_eq!(xprs.vars, ["y"].into());

pub fn eval_no_vars(&self) -> Result<f64, EvalError>

Simple wrapper around Xprs::eval that doesn’t require any variables. This will obviously fail if the expression contains variables.

Errors

An EvalError is returned if the expression contains variables.

pub fn eval_no_vars_unchecked(&self) -> f64

Simple wrapper around Xprs::eval_unchecked that doesn’t require any variables. This will obviously fail if the expression contains variables.

Panic

Use with caution, as it may panic if the expression contains variables.

pub fn simplify_for(self, var: (&str, f64)) -> Self

Simplifies the expression in-place for a single variable and returns the expression.

Example

use xprs::Xprs;

let expression = "2 * x + y";
let xprs = Xprs::try_from(expression)?;

assert_eq!(format!("{xprs}"), "((2 * x) + y)");
assert_eq!(xprs.vars, ["x", "y"].into());

let simplified_xprs = xprs.simplify_for(("x", 3.0));

assert_eq!(format!("{simplified_xprs}"), "(6 + y)");
assert_eq!(simplified_xprs.vars, ["y"].into());

pub fn simplify_for_multiple_in_place(&mut self, vars: &[(&str, f64)])

Simplifies the expression in-place for multiple variables.

Example

use xprs::Xprs;

let expression = "2 * x + y + 4z";
let mut xprs = Xprs::try_from(expression)?;

assert_eq!(format!("{xprs}"), "(((2 * x) + y) + (4 * z))");
assert_eq!(xprs.vars, ["x", "y", "z"].into());

xprs.simplify_for_multiple_in_place(&[("x", 3.0), ("z", 2.0)]);

assert_eq!(format!("{xprs}"), "((6 + y) + 8)");
assert_eq!(xprs.vars, ["y"].into());

pub fn simplify_for_multiple(self, vars: &[(&str, f64)]) -> Self

Simplifies the expression in-place for multiple variables and returns the expression.

Example

use xprs::Xprs;

let expression = "2 * x + y + 4z";
let xprs = Xprs::try_from(expression)?;

assert_eq!(format!("{xprs}"), "(((2 * x) + y) + (4 * z))");
assert_eq!(xprs.vars, ["x", "y", "z"].into());

let simplified_xprs = xprs.simplify_for_multiple(&[("x", 3.0), ("z", 2.0)]);

assert_eq!(format!("{simplified_xprs}"), "((6 + y) + 8)");
assert_eq!(simplified_xprs.vars, ["y"].into());

impl<'a> Xprs<'a>

pub fn bind(self, var: &'a str) -> Result<impl Fn(f64) -> f64 + 'a, BindError>

Creates a function of one variable based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("x + 2")?;
let func = expression.bind("x");

assert!(func.is_ok());
let func = func?;

let result = func(3.0);
assert_eq!(result, 5.0);

pub fn bind2( self, var1: &'a str, var2: &'a str, ) -> Result<impl Fn(f64, f64) -> f64 + 'a, BindError>

Creates a function of two f64 based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("x + y")?;
let func = expression.bind2("x", "y");

assert!(func.is_ok());
let func = func?;

let result = func(3.0, 2.0);
assert_eq!(result, 5.0);

pub fn bind3( self, var1: &'a str, var2: &'a str, var3: &'a str, ) -> Result<impl Fn(f64, f64, f64) -> f64 + 'a, BindError>

Creates a function of three f64 based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("x + y + z")?;
let func = expression.bind3("x", "y", "z");

assert!(func.is_ok());
let func = func?;

let result = func(3.0, 2.0, 1.0);
assert_eq!(result, 6.0);

pub fn bind4( self, var1: &'a str, var2: &'a str, var3: &'a str, var4: &'a str, ) -> Result<impl Fn(f64, f64, f64, f64) -> f64 + 'a, BindError>

Creates a function of four f64 based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("w + x + y + z")?;
let func = expression.bind4("w", "x", "y", "z");

assert!(func.is_ok());
let func = func?;

let result = func(1.0, 2.0, 3.0, 4.0);
assert_eq!(result, 10.0);

pub fn bind5( self, var1: &'a str, var2: &'a str, var3: &'a str, var4: &'a str, var5: &'a str, ) -> Result<impl Fn(f64, f64, f64, f64, f64) -> f64 + 'a, BindError>

Creates a function of five f64 based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("v + w + x + y + z")?;
let func = expression.bind5("v", "w", "x", "y", "z");

assert!(func.is_ok());
let func = func?;

let result = func(1.0, 2.0, 3.0, 4.0, 5.0);
assert_eq!(result, 15.0);

pub fn bind6( self, var1: &'a str, var2: &'a str, var3: &'a str, var4: &'a str, var5: &'a str, var6: &'a str, ) -> Result<impl Fn(f64, f64, f64, f64, f64, f64) -> f64 + 'a, BindError>

Creates a function of six f64 based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("u + v + w + x + y + z")?;
let func = expression.bind6("u", "v", "w", "x", "y", "z");

assert!(func.is_ok());
let func = func?;

let result = func(1.0, 2.0, 3.0, 4.0, 5.0, 6.0);
assert_eq!(result, 21.0);

pub fn bind7( self, var1: &'a str, var2: &'a str, var3: &'a str, var4: &'a str, var5: &'a str, var6: &'a str, var7: &'a str, ) -> Result<impl Fn(f64, f64, f64, f64, f64, f64, f64) -> f64 + 'a, BindError>

Creates a function of seven f64 based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("t + u + v + w + x + y + z")?;
let func = expression.bind7("t", "u", "v", "w", "x", "y", "z");

assert!(func.is_ok());
let func = func?;

let result = func(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
assert_eq!(result, 28.0);

pub fn bind8( self, var1: &'a str, var2: &'a str, var3: &'a str, var4: &'a str, var5: &'a str, var6: &'a str, var7: &'a str, var8: &'a str, ) -> Result<impl Fn(f64, f64, f64, f64, f64, f64, f64, f64) -> f64 + 'a, BindError>

Creates a function of eight f64 based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("s + t + u + v + w + x + y + z")?;
let func = expression.bind8("s", "t", "u", "v", "w", "x", "y", "z");

assert!(func.is_ok());
let func = func?;

let result = func(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0);
assert_eq!(result, 36.0);

pub fn bind9( self, var1: &'a str, var2: &'a str, var3: &'a str, var4: &'a str, var5: &'a str, var6: &'a str, var7: &'a str, var8: &'a str, var9: &'a str, ) -> Result<impl Fn(f64, f64, f64, f64, f64, f64, f64, f64, f64) -> f64 + 'a, BindError>

Creates a function of nine f64 based on this Xprs instance.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("r + s + t + u + v + w + x + y + z")?;
let func = expression.bind9("r", "s", "t", "u", "v", "w", "x", "y", "z");

assert!(func.is_ok());
let func = func?;

let result = func(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0);
assert_eq!(result, 45.0);

pub fn bind_n<const T: usize>( self, vars: [&'a str; T], ) -> Result<impl Fn([f64; T]) -> f64 + 'a, BindError>

Creates a function of any number* of f64 based on this Xprs instance. *The number of variables must be known at compile time.

The returned closure takes an array of f64 as input and returns an f64.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("a + b + c + d")?;
let func = expression.bind_n(["a", "b", "c", "d"]);

assert!(func.is_ok());
let func = func?;

let result = func([1.0, 2.0, 3.0, 4.0]);
assert_eq!(result, 10.0);

pub fn bind_n_runtime( self, vars: &'a [&'a str], ) -> Result<impl Fn(&[f64]) -> Result<f64, EvalError> + 'a, BindError>

Creates a function of any number of f64 based on this Xprs instance.

The returned closure takes a slice of f64 as input and returns a Result containing an f64 if the evaluation is successful, or an EvalError if an error occurs.

Errors

A BindError is returned if one or more required variables were not provided.

Example

use xprs::Parser;

let expression = Parser::default().parse("a + b + c + d")?;
let func = expression.bind_n_runtime(&["a", "b", "c", "d"]);

assert!(func.is_ok());
let func = func?;

let result = func(&[1.0, 2.0, 3.0, 4.0])?;
assert_eq!(result, 10.0);

Trait Implementations

impl<'a> Clone for Xprs<'a>

fn clone(&self) -> Xprs<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Xprs<'a>

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

Formats the value using the given formatter.

impl Display for Xprs<'_>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Xprs<'a>

fn eq(&self, other: &Xprs<'a>) -> 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<'input> TryFrom<&'input str> for Xprs<'input>

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(value: &'input str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> StructuralPartialEq for Xprs<'a>