Enum Term 

pub enum Term<N: Num> {
    Num(Answer<N>),
    Operation(Rc<dyn Operate<N>>),
    Function(String, Vec<Term<N>>),
    Var(String),
}

The main representation of parsed equations. It is an operand that can contain an operation between more of itself. This form is the only one that can be directly evaluated. Does not include it’s own context.

Variants

Num(Answer<N>)

A number

Operation(Rc<dyn Operate<N>>)

An operation

Function(String, Vec<Term<N>>)

A function with the given arguments

Var(String)

A variable

Implementations

impl<N: Num + 'static> Term<N>

pub fn parse(raw: &str) -> Result<Self, ParseError>

Parse a string into an expression

pub fn parse_ctx(raw: &str, ctx: &Context<N>) -> Result<Self, ParseError>

Parse a string into an expression with the given context

pub fn eval(&self) -> Calculation<N>

Evaluate the term with the default context

pub fn eval_ctx(&self, ctx: &Context<N>) -> Calculation<N>

Evaluate the term with the given context

Examples found in repository

examples/context.rs (line 28)

fn main() {
	// A context holds data that can be used in an expression
	let mut context: Context<f64> = Context::new();
	// Add a variable "x" to the context with the value 5.4
	context.set_var("x", 5.4);
	// Add a function "sum" to the context that returns the sum of it's arguments. A closure is passed
	// in that takes twp arguments: args: &[Term], which is a slice if the arguments passed into the
	// function, and ctx: &Context, which is a reference to the context which the expression is being
	// evaluated with. The item passed in can be anything that implements the `Func` trait. There exists
	// a blanket impl for Fn(&[Term], &Context) -> Calculation which allows you to pass in closures in
	// that format.
	context.set_func(
		"sum",
		|args: &[Term<f64>], ctx: &Context<f64>| -> Calculation<f64> {
			if args.len() < 1 {
				return Err(MathError::IncorrectArguments);
			};

			let mut sum = Answer::Single(0.0);
			for arg in args {
				let b = arg.eval_ctx(ctx)?;
				sum = sum.op(&b, |a, b| Num::add(a, b, ctx))?;
			}

			Ok(sum)
		},
	);

	let raw = "2 * sum(x, 7, 400)";
	// The expression needs to be parsed with the context in order do decide if some names are functions
	// or variables.
	let expr = Expression::parse_ctx(raw, context).unwrap();
	// The expression also needs to be evaluated with a context. This context can be different than the
	// one it was parsed with, but if it is missing something that is necessary for evaluation the
	// evaluation will fail.
	println!("{} = {}", raw, expr.eval().unwrap())
}

pub fn to_string(&self) -> String

Express this term as a string

Trait Implementations

impl<N: Clone + Num> Clone for Term<N>

fn clone(&self) -> Term<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug + Num> Debug for Term<N>

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

Formats the value using the given formatter.

impl<N: Num + 'static> Display for Term<N>

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

Formats the value using the given formatter.

impl<N: Num> From<Answer<N>> for Term<N>

fn from(t: Answer<N>) -> Term<N>

Converts to this type from the input type.

impl<N: Num> From<Expression<N>> for Term<N>

fn from(t: Expression<N>) -> Term<N>

Converts to this type from the input type.

impl<N: Num> From<N> for Term<N>

fn from(t: N) -> Term<N>

Converts to this type from the input type.