math-ast 0.2.0

mast ast for basic arithmetic operations
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

use crate::{
    traits::{Add, Connect, Div, Factorial, Mul, Pow, Sub, Surd},
    AST,
};

impl<T> Add<AST<T>> for AST<T> {
    type Output = AST<T>;

    fn add(self, rhs: AST<T>) -> Self::Output {
        AST::Plus(box self, box rhs)
    }
}

impl<T> Sub<AST<T>> for AST<T> {
    type Output = AST<T>;

    fn sub(self, rhs: AST<T>) -> Self::Output {
        AST::Minus(box self, box rhs)
    }
}

impl<T> Mul<AST<T>> for AST<T> {
    type Output = AST<T>;

    fn mul(self, rhs: AST<T>) -> Self::Output {
        AST::Times(box self, box rhs)
    }
}

impl<T> Div<AST<T>> for AST<T> {
    type Output = AST<T>;

    fn div(self, rhs: AST<T>) -> Self::Output {
        AST::Divide(box self, box rhs)
    }
}

impl<T> Pow<AST<T>> for AST<T> {
    type Output = AST<T>;

    fn pow(self, rhs: AST<T>) -> Self::Output {
        AST::Power(box self, box rhs)
    }
}

impl<T> AST<T>
where
    T: Clone
        + Factorial
        + Add<Output = T>
        + Sub<Output = T>
        + Mul<Output = T>
        + Div<Output = T>
        + Pow<T, Output = T>
        + Surd<Output = T>
        + Connect<Output = T>,
{
    pub fn eval(self) -> T {
        match self {
            AST::Number(n) => n,
            AST::Factorial(n) => n.eval().factorial(),
            //
            AST::Plus(a, b) => a.eval() + b.eval(),
            AST::Minus(a, b) => a.eval() - b.eval(),
            AST::Times(a, b) => a.eval() * b.eval(),
            AST::Divide(a, b) => a.eval() / b.eval(),
            AST::Power(a, b) => a.eval().pow(b.eval()),
            AST::Surd(a, b) => a.eval().surd(b.eval()),
            //
            AST::Connect(a, b) => a.eval().connect(b.eval()),
        }
    }
    pub fn unwrap(self) -> T {
        match self {
            AST::Number(n) => n,
            _ => unreachable!(),
        }
    }
}