Enum Answer

pub enum Answer<N: Num> {
    Single(N),
    Multiple(Vec<N>),
}

An answer of an evaluatation. Can be either a single answer or multiple. This struct contains some helper methods for performing operations on single or multiple answers. The op method takes another Num, and a function with two Num arguments, itself and the other (as references). It performs that function on all combinations and returns an answer with all of the results in one. The unop function is similar but it performs an operation on only itself, without another value (unary operation).

Variants

Single(N)

A single answer

Multiple(Vec<N>)

Multiple answers. Will always be at least two (probably)

Implementations

impl<N: Num> Answer<N>

pub fn op<F: Fn(&N, &N) -> Calculation<N>>( &self, other: &Self, oper: F, ) -> Calculation<N>

Perform an operation on all the values of an answer with all the values of another answer

Examples found in repository

examples/context.rs (line 29)

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 unop<F: Fn(&N) -> Calculation<N>>(&self, oper: F) -> Calculation<N>

Perform an operation on all the values of an answer

pub fn unwrap_single(self) -> N

Unwrap the single variant of an answer

pub fn to_vec(self) -> Vec<N>

Convert this answer into a vector

pub fn join(self, other: Self) -> Self

Adds all the answers of another answer to the asnwers of this answer, returning a new answer

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<N: Num> Display for Answer<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: PartialEq + Num> PartialEq for Answer<N>

fn eq(&self, other: &Answer<N>) -> 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<N: Num> StructuralPartialEq for Answer<N>