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
/*
* // Copyright (c) 2021 Feng Yang
* //
* // I am making my contributions/submissions to this project solely in my
* // personal capacity and am not conveying any rights to any intellectual
* // property of any third parties.
*/
pub trait UnaryOp {
fn new() -> Self;
fn eval(&self, x: f64) -> f64;
}
pub trait BinaryOp {
fn new() -> Self;
fn eval(&self, x: f64, y: f64) -> f64;
}
//--------------------------------------------------------------------------------------------------
pub struct Plus {}
impl BinaryOp for Plus {
fn new() -> Self {
return Plus {};
}
fn eval(&self, x: f64, y: f64) -> f64 {
return x + y;
}
}
//--------------------------------------------------------------------------------------------------
pub struct Minus {}
impl BinaryOp for Minus {
fn new() -> Self {
return Minus {};
}
fn eval(&self, x: f64, y: f64) -> f64 {
return x - y;
}
}
//--------------------------------------------------------------------------------------------------
pub struct RMinus {}
impl BinaryOp for RMinus {
fn new() -> Self {
return RMinus {};
}
fn eval(&self, x: f64, y: f64) -> f64 {
return y - x;
}
}
//--------------------------------------------------------------------------------------------------
pub struct Multiplies {}
impl BinaryOp for Multiplies {
fn new() -> Self {
return Multiplies {};
}
fn eval(&self, x: f64, y: f64) -> f64 {
return x * y;
}
}
//--------------------------------------------------------------------------------------------------
pub struct Divides {}
impl BinaryOp for Divides {
fn new() -> Self {
return Divides {};
}
fn eval(&self, x: f64, y: f64) -> f64 {
return x / y;
}
}
//--------------------------------------------------------------------------------------------------
pub struct RDivides {}
impl BinaryOp for RDivides {
fn new() -> Self {
return RDivides {};
}
fn eval(&self, x: f64, y: f64) -> f64 {
return y / x;
}
}