mech_interpreter/stdlib/
logic.rs

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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
#[macro_use]
use crate::stdlib::*;

// ----------------------------------------------------------------------------
// Logic Library
// ----------------------------------------------------------------------------



#[macro_export]
macro_rules! impl_logic_binop {
  ($struct_name:ident, $arg1_type:ty, $arg2_type:ty, $out_type:ty, $op:ident) => {
    #[derive(Debug)]
    struct $struct_name {
      lhs: Ref<$arg1_type>,
      rhs: Ref<$arg2_type>,
      out: Ref<$out_type>,
    }
    impl MechFunction for $struct_name {
      fn solve(&self) {
        let lhs_ptr = self.lhs.as_ptr();
        let rhs_ptr = self.rhs.as_ptr();
        let out_ptr = self.out.as_ptr();
        $op!(lhs_ptr,rhs_ptr,out_ptr);
      }
      fn out(&self) -> Value { self.out.to_value() }
      fn to_string(&self) -> String { format!("{:?}", self) }
    }};}

#[macro_export]
macro_rules! impl_logic_urnop {
  ($struct_name:ident, $arg_type:ty, $out_type:ty, $op:ident) => {
    #[derive(Debug)]
    struct $struct_name {
      arg: Ref<$arg_type>,
      out: Ref<$out_type>,
    }
    impl MechFunction for $struct_name {
      fn solve(&self) {
        let arg_ptr = self.arg.as_ptr();
        let out_ptr = self.out.as_ptr();
        $op!(arg_ptr,out_ptr);
      }
      fn out(&self) -> Value { self.out.to_value() }
      fn to_string(&self) -> String { format!("{:?}", self) }
    }};}

#[macro_export]
macro_rules! impl_logic_fxns {
  ($lib:ident) => {
    impl_fxns!($lib,bool,bool,impl_logic_binop);
  }
}

// And ------------------------------------------------------------------------

macro_rules! and_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {*$out = *$lhs && *$rhs;}
    };}

macro_rules! and_vec_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$lhs).len() {
        (*$out)[i] = (*$lhs)[i] && (*$rhs)[i];
      }}};}
    
macro_rules! and_scalar_rhs_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$rhs).len() {
        (*$out)[i] = (*$lhs) && (*$rhs)[i];
      }}};}
      

macro_rules! and_scalar_lhs_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$lhs).len() {
        (*$out)[i] = (*$lhs)[i] && (*$rhs);
      }}};}

impl_logic_fxns!(And);

fn impl_and_fxn(lhs_value: Value, rhs_value: Value) -> Result<Box<dyn MechFunction>, MechError> {
  impl_binop_match_arms!(
    And,
    (lhs_value, rhs_value),
    Bool, Bool => MatrixBool, bool, false, "Bool";
  )
}

impl_mech_binop_fxn!(LogicAnd,impl_and_fxn);

// Or ------------------------------------------------------------------------

macro_rules! or_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {*$out = *$lhs || *$rhs;}
    };}

macro_rules! or_vec_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$lhs).len() {
        (*$out)[i] = (*$lhs)[i] || (*$rhs)[i];
      }}};}
    
macro_rules! or_scalar_rhs_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$rhs).len() {
        (*$out)[i] = (*$lhs) || (*$rhs)[i];
      }}};}
      

macro_rules! or_scalar_lhs_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$lhs).len() {
        (*$out)[i] = (*$lhs)[i] || (*$rhs);
      }}};}

impl_logic_fxns!(Or);

fn impl_or_fxn(lhs_value: Value, rhs_value: Value) -> Result<Box<dyn MechFunction>, MechError> {
  impl_binop_match_arms!(
    Or,
    (lhs_value, rhs_value),
    Bool, Bool => MatrixBool, bool, false, "Bool";
  )
}

impl_mech_binop_fxn!(LogicOr,impl_or_fxn);

// Xor ------------------------------------------------------------------------
macro_rules! xor_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {*$out = *$lhs ^ *$rhs;}
    };}

macro_rules! xor_vec_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$lhs).len() {
        (*$out)[i] = (*$lhs)[i] ^ (*$rhs)[i];
      }}};}
    
macro_rules! xor_scalar_rhs_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$rhs).len() {
        (*$out)[i] = (*$lhs) ^ (*$rhs)[i];
      }}};}
      

macro_rules! xor_scalar_lhs_op {
  ($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$lhs).len() {
        (*$out)[i] = (*$lhs)[i] ^ (*$rhs);
      }}};} 

impl_logic_fxns!(Xor);

fn impl_xor_fxn(lhs_value: Value, rhs_value: Value) -> Result<Box<dyn MechFunction>, MechError> {
  impl_binop_match_arms!(
    Xor,
    (lhs_value, rhs_value),
    Bool, Bool => MatrixBool, bool, false, "Bool";
  )
}

impl_mech_binop_fxn!(LogicXor,impl_xor_fxn);

// Not ------------------------------------------------------------------------

macro_rules! not_op {
  ($arg:expr, $out:expr) => {
    unsafe {*$out = !*$arg;}
    };}

macro_rules! not_vec_op {
  ($arg:expr, $out:expr) => {
    unsafe {
      for i in 0..(*$arg).len() {
        (*$out)[i] = !(*$arg)[i];
      }}};}

impl_logic_urnop!(NotS, bool, bool, not_op);
#[cfg(feature = "Matrix1")]
impl_logic_urnop!(NotM1, Matrix1<bool>, Matrix1<bool>, not_vec_op);
#[cfg(feature = "Matrix2")]
impl_logic_urnop!(NotM2, Matrix2<bool>, Matrix2<bool>, not_vec_op);
#[cfg(feature = "Matrix3")]
impl_logic_urnop!(NotM3, Matrix3<bool>, Matrix3<bool>, not_vec_op);
#[cfg(feature = "Matrix4")]
impl_logic_urnop!(NotM4, Matrix4<bool>, Matrix4<bool>, not_vec_op);
#[cfg(feature = "Matrix2x3")]
impl_logic_urnop!(NotM2x3, Matrix2x3<bool>, Matrix2x3<bool>, not_vec_op);
#[cfg(feature = "Matrix3x2")]
impl_logic_urnop!(NotM3x2, Matrix3x2<bool>, Matrix3x2<bool>, not_vec_op);
#[cfg(feature = "MatrixD")]
impl_logic_urnop!(NotMD, DMatrix<bool>, DMatrix<bool>, not_vec_op);
#[cfg(feature = "RowVector2")]
impl_logic_urnop!(NotR2, RowVector2<bool>, RowVector2<bool>, not_vec_op);
#[cfg(feature = "RowVector3")]
impl_logic_urnop!(NotR3, RowVector3<bool>, RowVector3<bool>, not_vec_op);
#[cfg(feature = "RowVector4")]
impl_logic_urnop!(NotR4, RowVector4<bool>, RowVector4<bool>, not_vec_op);
#[cfg(feature = "RowVectorD")]
impl_logic_urnop!(NotRD, RowDVector<bool>, RowDVector<bool>, not_vec_op);
#[cfg(feature = "Vector2")]
impl_logic_urnop!(NotV2, Vector2<bool>, Vector2<bool>, not_vec_op);
#[cfg(feature = "Vector3")]
impl_logic_urnop!(NotV3, Vector3<bool>, Vector3<bool>, not_vec_op);
#[cfg(feature = "Vector4")]
impl_logic_urnop!(NotV4, Vector4<bool>, Vector4<bool>, not_vec_op);
#[cfg(feature = "VectorD")]
impl_logic_urnop!(NotVD, DVector<bool>, DVector<bool>, not_vec_op);

fn impl_not_fxn(arg_value: Value) -> Result<Box<dyn MechFunction>, MechError> {
  impl_urnop_match_arms!(
    Not,
    (arg_value),
    Bool => MatrixBool, bool, false, "Bool";
  )
}

impl_mech_urnop_fxn!(LogicNot,impl_not_fxn);