mech_compare/
eq.rs

1use crate::*;
2use mech_core::*;
3#[cfg(feature = "matrix")]
4use mech_core::matrix::Matrix;
5
6// Equal ---------------------------------------------------------------
7
8macro_rules! eq_scalar_lhs_op {
9  ($lhs:expr, $rhs:expr, $out:expr) => {
10    unsafe {
11      for i in 0..(*$lhs).len() {
12        (&mut (*$out))[i] = (&(*$lhs))[i] == (*$rhs);
13      }}};}
14
15macro_rules! eq_scalar_rhs_op {
16  ($lhs:expr, $rhs:expr, $out:expr) => {
17    unsafe {
18      for i in 0..(*$rhs).len() {
19        (&mut (*$out))[i] = (*$lhs) == (&(*$rhs))[i];
20      }}};}
21
22macro_rules! eq_vec_op {
23  ($lhs:expr, $rhs:expr, $out:expr) => {
24    unsafe {
25      for i in 0..(*$lhs).len() {
26        (&mut (*$out))[i] = (&(*$lhs))[i] == (&(*$rhs))[i];
27      }}};}
28
29macro_rules! eq_op {
30  ($lhs:expr, $rhs:expr, $out:expr) => {
31    unsafe {
32      (*$out) = (*$lhs) == (*$rhs);
33    }};}
34
35macro_rules! eq_mat_vec_op {
36  ($lhs:expr, $rhs:expr, $out:expr) => {
37    unsafe {
38      let mut out_deref = &mut (*$out);
39      let lhs_deref = &(*$lhs);
40      let rhs_deref = &(*$rhs);
41      for (mut col, lhs_col) in out_deref.column_iter_mut().zip(lhs_deref.column_iter()) {
42        for i in 0..col.len() {
43          col[i] = lhs_col[i] == rhs_deref[i];
44        }
45      }
46    }
47  };}   
48      
49macro_rules! eq_vec_mat_op {
50  ($lhs:expr, $rhs:expr, $out:expr) => {
51      unsafe {
52        let mut out_deref = &mut (*$out);
53        let lhs_deref = &(*$lhs);
54        let rhs_deref = &(*$rhs);
55        for (mut col, rhs_col) in out_deref.column_iter_mut().zip(rhs_deref.column_iter()) {
56          for i in 0..col.len() {
57            col[i] = lhs_deref[i] == rhs_col[i];
58          }
59        }
60      }
61  };}
62  
63macro_rules! eq_mat_row_op {
64  ($lhs:expr, $rhs:expr, $out:expr) => {
65      unsafe {
66      let mut out_deref = &mut (*$out);
67      let lhs_deref = &(*$lhs);
68      let rhs_deref = &(*$rhs);
69      for (mut row, lhs_row) in out_deref.row_iter_mut().zip(lhs_deref.row_iter()) {
70          for i in 0..row.len() {
71          row[i] = lhs_row[i] == rhs_deref[i];
72          }
73      }
74      }
75  };}
76
77macro_rules! eq_row_mat_op {
78  ($lhs:expr, $rhs:expr, $out:expr) => {
79      unsafe {
80      let mut out_deref = &mut (*$out);
81      let lhs_deref = &(*$lhs);
82      let rhs_deref = &(*$rhs);
83      for (mut row, rhs_row) in out_deref.row_iter_mut().zip(rhs_deref.row_iter()) {
84          for i in 0..row.len() {
85          row[i] = lhs_deref[i] == rhs_row[i];
86          }
87      }
88      }
89  };}    
90
91impl_compare_fxns!(EQ);
92
93#[cfg(feature = "table")]
94#[derive(Debug)]
95pub struct TableEq {
96  pub lhs: Ref<MechTable>,
97  pub rhs: Ref<MechTable>,
98  pub out: Ref<bool>,
99}
100impl MechFunctionFactory for TableEq {
101  fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
102    match args {
103      FunctionArgs::Binary(out, arg1, arg2) => {
104        let lhs: Ref<MechTable> = unsafe { arg1.as_unchecked() }.clone();
105        let rhs: Ref<MechTable> = unsafe { arg2.as_unchecked() }.clone();
106        let out: Ref<bool> = unsafe { out.as_unchecked() }.clone();
107        Ok(Box::new(TableEq { lhs, rhs, out }))
108      }
109      _ => Err(MechError2::new(
110          IncorrectNumberOfArguments { expected: 2, found: args.len() }, 
111          None
112        ).with_compiler_loc()
113      ),
114    }
115  }
116}
117#[cfg(feature = "table")]
118impl MechFunctionImpl for TableEq {
119  fn solve(&self) {
120    let lhs_ptr = self.lhs.as_ptr();
121    let rhs_ptr = self.rhs.as_ptr();
122    let mut out_ptr = self.out.as_mut_ptr();
123    unsafe {
124      *out_ptr = (*lhs_ptr) == (*rhs_ptr);
125    }
126  }
127  fn out(&self) -> Value { self.out.to_value() }
128  fn to_string(&self) -> String { format!("{:#?}", self) }
129}
130#[cfg(feature = "table")]
131#[cfg(feature = "compiler")]
132impl MechFunctionCompiler for TableEq {
133  fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
134    let name = format!("TableEq");
135    compile_binop!(name, self.out, self.lhs, self.rhs, ctx, FeatureFlag::Builtin(FeatureKind::Table));
136  }
137}
138
139fn impl_eq_fxn(lhs_value: Value, rhs_value: Value) -> MResult<Box<dyn MechFunction>> {
140  match (&lhs_value, &rhs_value) {
141    #[cfg(all(feature = "table"))]
142    (Value::Table(lhs), Value::Table(rhs)) => {
143      println!("Registering TableEq");
144      register_descriptor! {
145        FunctionDescriptor {
146          name: "TableEq",
147          ptr: TableEq::new,
148        }
149      }
150      return Ok(Box::new(TableEq{lhs: lhs.clone(), rhs: rhs.clone(), out: Ref::new(false) }));
151    }
152    _ => (),
153  }
154  impl_binop_match_arms!(
155    EQ,
156    register_fxn_descriptor_inner,
157    (lhs_value, rhs_value),
158    Bool, bool, "bool";
159    I8,   bool, "i8";
160    I16,  bool, "i16";
161    I32,  bool, "i32";
162    I64,  bool, "i64";
163    I128, bool, "i128";
164    U8,   bool, "u8";
165    U16,  bool, "u16";
166    U32,  bool, "u32";
167    U64,  bool, "u64";
168    U128, bool, "u128";
169    F32,  bool, "f32";
170    F64,  bool, "f64";
171    String, bool, "string";
172    R64, bool, "rational";
173    C64, bool, "complex";
174  )
175}
176
177impl_mech_binop_fxn!(CompareEqual,impl_eq_fxn,"compare/eq");
mech_compare/eq.rs

mech_compare/
eq.rs
