mech_interpreter/stdlib/math/
sub.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
#[macro_use]
use crate::stdlib::*;

// Sub ------------------------------------------------------------------------

macro_rules! sub_op {
    ($lhs:expr, $rhs:expr, $out:expr) => {
      unsafe { *$out = *$lhs - *$rhs; }
    };}
  
macro_rules! sub_vec_op {
($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe { (*$lhs).sub_to(&*$rhs,&mut *$out) }
    };}

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

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

macro_rules! sub_mat_vec_op {
    ($lhs:expr, $rhs:expr, $out:expr) => {
        unsafe {
        let mut out_deref = &mut (*$out);
        let lhs_deref = &(*$lhs);
        let rhs_deref = &(*$rhs);
        for (mut col, lhs_col) in out_deref.column_iter_mut().zip(lhs_deref.column_iter()) {
            for i in 0..col.len() {
            col[i] = lhs_col[i] - rhs_deref[i];
            }
        }
        }
    };}
    
macro_rules! sub_vec_mat_op {
($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
    let mut out_deref = &mut (*$out);
    let lhs_deref = &(*$lhs);
    let rhs_deref = &(*$rhs);
    for (mut col, rhs_col) in out_deref.column_iter_mut().zip(rhs_deref.column_iter()) {
        for i in 0..col.len() {
        col[i] = lhs_deref[i] - rhs_col[i];
        }
    }
    }
};}

macro_rules! sub_mat_row_op {
($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
    let mut out_deref = &mut (*$out);
    let lhs_deref = &(*$lhs);
    let rhs_deref = &(*$rhs);
    for (mut row, lhs_row) in out_deref.row_iter_mut().zip(lhs_deref.row_iter()) {
        for i in 0..row.len() {
        row[i] = lhs_row[i] - rhs_deref[i];
        }
    }
    }
};}

macro_rules! sub_row_mat_op {
($lhs:expr, $rhs:expr, $out:expr) => {
    unsafe {
    let mut out_deref = &mut (*$out);
    let lhs_deref = &(*$lhs);
    let rhs_deref = &(*$rhs);
    for (mut row, rhs_row) in out_deref.row_iter_mut().zip(rhs_deref.row_iter()) {
        for i in 0..row.len() {
        row[i] = lhs_deref[i] - rhs_row[i];
        }
    }
    }
};}  

impl_math_fxns!(Sub);

fn impl_sub_fxn(lhs_value: Value, rhs_value: Value) -> Result<Box<dyn MechFunction>, MechError> {
impl_binop_match_arms!(
    Sub,
    (lhs_value, rhs_value),
    I8,   I8   => MatrixI8,   i8,   i8::zero(), "I8";
    I16,  I16  => MatrixI16,  i16,  i16::zero(), "I16";
    I32,  I32  => MatrixI32,  i32,  i32::zero(), "I32";
    I64,  I64  => MatrixI64,  i64,  i64::zero(), "I64";
    I128, I128 => MatrixI128, i128, i128::zero(), "I128";
    U8,   U8   => MatrixU8,   u8,   u8::zero(), "U8";
    U16,  U16  => MatrixU16,  u16,  u16::zero(), "U16";
    U32,  U32  => MatrixU32,  u32,  u32::zero(), "U32";
    U64,  U64  => MatrixU64,  u64,  u64::zero(), "U64";
    U128, U128 => MatrixU128, u128, u128::zero(), "U128";
    F32,  F32  => MatrixF32,  F32,  F32::zero(), "F32";
    F64,  F64  => MatrixF64,  F64,  F64::zero(), "F64";
)
}

impl_mech_binop_fxn!(MathSub,impl_sub_fxn);