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
|
use crate::eval::Num;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum BinOp {
Pow,
Mul,
Div,
IntDiv,
Mod,
Add,
Sub,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum UnOp {
Neg,
Sin,
Cos,
Tan,
Asin,
Acos,
Atan,
Sqrt,
Log,
Log10,
Log2,
Floor,
Ceil,
Round,
Abs,
}
#[derive(Debug, PartialEq)]
pub enum Expr {
Num(Num),
UnOp {
op: UnOp,
x: Box<Expr>,
},
BinOp {
op: BinOp,
x: Box<Expr>,
y: Box<Expr>,
},
}
impl BinOp {
pub fn expr(self, x: Expr, y: Expr) -> Expr {
Expr::BinOp {
op: self,
x: Box::new(x),
y: Box::new(y),
}
}
fn eval(self, x: Num, y: Num) -> Num {
match self {
BinOp::Pow => x.pow(y),
BinOp::Mul => x.mul(y),
BinOp::Div => x.div(y),
BinOp::IntDiv => x.int_div(y),
BinOp::Mod => x.modulo(y),
BinOp::Add => x.add(y),
BinOp::Sub => x.sub(y),
}
}
}
impl UnOp {
pub fn expr(self, x: Expr) -> Expr {
Expr::UnOp {
op: self,
x: Box::new(x),
}
}
fn eval(self, x: Num) -> Num {
match self {
UnOp::Neg => Num::Int(0).sub(x),
UnOp::Sin => x.sin(),
UnOp::Cos => x.cos(),
UnOp::Tan => x.tan(),
UnOp::Asin => x.asin(),
UnOp::Acos => x.acos(),
UnOp::Atan => x.atan(),
UnOp::Sqrt => x.sqrt(),
UnOp::Log => x.log(),
UnOp::Log10 => x.log10(),
UnOp::Log2 => x.log2(),
UnOp::Floor => x.floor(),
UnOp::Ceil => x.ceil(),
UnOp::Round => x.round(),
UnOp::Abs => x.abs(),
}
}
}
impl Expr {
pub fn eval(&self) -> Num {
match self {
Expr::Num(n) => *n,
Expr::UnOp { op, x } => op.eval(x.eval()),
Expr::BinOp { op, x, y } => op.eval(x.eval(), y.eval()),
}
}
}
|
