asciimath 0.8.8

Mathematical expression parser and evaluator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::{
    ast::{resolve_fn, resolve_var, Args, Node, Root, Scope},
    error::Error,
    tokens::{Operator, Token},
    util::Result,
};
use std::f64::EPSILON;

pub type NumericLiteral = f64;

pub type EvaluationResult = Result<NumericLiteral>;

pub trait Evaluate {
    /// Evaluates the node/expression with a given variable scope.
    fn eval_with(&self, scope: &Scope) -> EvaluationResult;

    /// Evaluates the node/expression without any variables.
    ///
    /// This is just a shortcut to evaluate expressions without variables.
    fn eval(&self) -> EvaluationResult;
}

fn negate(n: f64) -> f64 {
    if n == 0.0 {
        1.0
    }
    else {
        0.0
    }
}

fn int(b: bool) -> f64 {
    if b {
        1.0
    }
    else {
        0.0
    }
}

pub fn eval_operator(
    operator: &Operator,
    args: &[NumericLiteral],
) -> EvaluationResult {
    let evaled_args = &mut args.iter();
    let op_str = format!("{:?}", operator);

    match operator {
        Operator::Add => Ok(evaled_args.sum()),
        Operator::Substract => {
            Ok(evaled_args.nth(0).ok_or(Error::MissingOperands(op_str))?
                - evaled_args.sum::<NumericLiteral>())
        },
        Operator::Multiply => Ok(evaled_args.product()),
        Operator::Divide => {
            Ok(evaled_args.nth(0).ok_or(Error::MissingOperands(op_str))?
                / evaled_args.product::<NumericLiteral>())
        },
        Operator::Exponentiate => {
            let base =
                evaled_args.nth(0).ok_or(Error::MissingOperands(op_str))?;
            Ok(evaled_args.fold(*base, |acc, v| acc.powf(*v)))
        },
        Operator::IsGreaterThan => Ok(int(args[0] > args[1])),
        Operator::IsLessThan => Ok(int(args[0] < args[1])),
        Operator::IsGreaterThanOrEqualTo => Ok(int(args[0] >= args[1])),
        Operator::IsLessThanOrEqualTo => {
            Ok(((args[0] <= args[1]) as i8).into())
        },
        Operator::IsEqualTo => Ok(int((args[0] - args[1]).abs() < EPSILON)),
        Operator::IsNotEqualTo => Ok(int((args[0] - args[1]).abs() > EPSILON)),
        Operator::Not => Ok(negate(args[0])),
    }
}

fn eval_args(
    args: &Option<Args>,
    scope: &Scope,
    fn_name: String,
) -> Result<Vec<NumericLiteral>> {
    if let Some(args) = args {
        return args.iter().map(|n| n.eval_with(scope)).collect();
    }
    Err(Error::NotEnoughFunctionParams(fn_name))
}

impl Evaluate for Node {
    fn eval_with(&self, scope: &Scope) -> EvaluationResult {
        match self.token {
            Token::Operator(ref operator) => {
                dbg!(&self.args);
                let args = self
                    .args
                    .as_ref()
                    .ok_or(Error::MissingOperands(format!("{:?}", operator)))?
                    .iter()
                    .map(|node| node.eval_with(scope))
                    .collect::<Result<Vec<NumericLiteral>>>()?;

                dbg!(&args);
                let res = eval_operator(&operator, &args);
                dbg!(res)
            },
            Token::Function(ref f) => {
                let args = eval_args(&self.args, scope, f.clone())?;
                resolve_fn(f, scope)?(&args)
            },

            Token::Number(num) => Ok(num),
            Token::Variable(ref var) => resolve_var(&var, scope),
            _ => Err(Error::CannotEvaluateToken(format!("{:?}", self.token))),
        }
    }

    fn eval(&self) -> EvaluationResult {
        self.eval_with(&Scope::new())
    }
}

impl<'a> Evaluate for Root<'a> {
    fn eval(&self) -> EvaluationResult {
        self.node.eval_with(self.scope)
    }

    fn eval_with(&self, scope: &Scope) -> EvaluationResult {
        self.node.eval_with(scope)
    }
}