rename get_float macro to get_primitive_float

StevenLove · StevenLove · commit da286948bbac · 2024-05-06T16:12:32.000-07:00
rename get_int macro to get_primitive_int

rename compare_int to compare_numeric

refactor NUM_LT, NUM_LTE, NUM_GT, NUM_GTE to use compare_numeric and removed helper macro

updated equality docs

implemented clojure-style = and == and not=

implemented identical
diff --git a/compile_state/src/state.rs b/compile_state/src/state.rs
@@ -379,7 +379,6 @@ Example:
 (test::assert-equal 0 (+))
 (test::assert-equal 5 (+ 5))
 (test::assert-equal 10 (+ 5 5))
-(test::assert-equal 5 (+ 5.0))
 (test::assert-equal 6 (+ 1 5))
 (test::assert-equal 6.5 (+ 1 5.5))
 (test::assert-equal 7 (+ 1 2 4))
@@ -750,6 +749,8 @@ Example:
 (test::assert-true (not= 1.1 1.0))
 (test::assert-false (not= 1.1 1.1))
 (test::assert-true (not= 3 2 3))
+(test::assert-true (not= 1 1.0))
+(test::assert-true (not= 1e-30 1.0001e-30))
 "#),
             numlt: add_special(vm, "<", r#"Usage: (< val0 ... valN)
 
diff --git a/doc/src/equality.md b/doc/src/equality.md
@@ -1,55 +1,77 @@
 # Equality
 
-When testing for equality in Slosh, there are several functions that can be used.
-Consider invocations like
-```slosh
-(= 1 2)
-```
-```slosh
-(== 1 2)
-```
-```slosh
-(identical? 1 2)
-```
-```slosh
-(assert-equal 1 2)
-```
-these are translated to different opcodes and equality implementations as listed below
-
--   `equal?`
-
-    -   lenient
-    -   `state.rs` defines special forms object with key `equal` mapped to the name `equal?`.
+The most common way to test equality is with `=`
+For numeric equality (IEEE) use `==`
+For bytewise equality use `identical?`
+
+The behavior and names are based on Clojure's implementation. Read their docs here: https://clojure.org/guides/equality
+
+-   `=`
+    -   `(= 2 0x2)` is `true` (comparing an int to a byte)
+    -   `(= 2 2.0)` is `false` (comparing an int to a float)
+    -   `(= NaN NaN)` is `false`
+    -   `state.rs` defines special forms object with key `equal` mapped to the name `=`.
     -   `compile.rs` matches on `env.specials().equal` and generates opcode `EQUAL`
     -   `exec_loop.rs` maps opcode `EQUAL` to function `is_equal`
     -   `vm.rs` `is_equal` converts each arg to a `Value` (in case it needs to be dereferenced) and calls `is_equal_pair`
     -   `vm.rs` `is_equal_pair` does a complex test for equality
         -   check if both args are Byte or Int and if so, converts both to `i64` with `Value::get_int` and compares with rust native `==`
         -   check if both args are Byte or Int or Float and if so, converts both to `f64` with `Value::get_float`
             -   then subtracts the second from the first and takes the absolute value and tests `diff == 0.0`
+-   `==`
+
+    -   `(== 1 1.0)` is `true` (comparing an int to a float)
+    -   `(== NaN NaN)` is `false`
+    -   returns true whenever `=` does, but also returns true for numbers that are numerically equal
+
+    -   when comparing two floats, converts two both to `f64` and compares with native f64 `==`
+    -   does not use F56::PartialEq implementation
+
+    -   `state.rs` defines special forms object with key `numeq` mapped to the name `==`.
+    -   `compile.rs` calls `compile_list` which calls `compile_special` which calls `compile_math` in `compile_math.rs`
+    -   `compile_math.rs` `compile_math` matches on `env.specials().numeq` and generates opcode `NUMEQ`
+    -   `exec_loop.rs` maps opcode `NUMEQ` to function `compare_numeric` and passes a comparator `|a,b| a == b`
+    -   `macros.rs` `compare_numeric`
+        -   checks if either argument is a `Float` and if so, converts both to `f64` with `get_primitive_float` macro and uses the comparator
+        -   checks if either argument is a `Int` and if so, converts both to `i64` with `get_primitive_int` macro and uses the comparator
+
+-   `identical?`
+
+    -   uses `Value::PartialEq` implementation
+    -   `state.rs` defines special forms object with key `eq` mapped to the name `identical?`.
+    -   `compile.rs` matches on `env.specials().eq` and generates opcode `EQ`
+    -   `exec_loop.rs` maps opcode `EQ` to function `is_identical`
+    -   `vm.rs` `is_identical` converts each arg to a `Value` (in case it needs to be dereferenced) and compares `val1 == val2` which uses `Value::PartialEq` implementation
 
 -   `assert-equal`
 
     -   based on `equal?`
     -   is a macro defined in core.slosh which checks if the arguments are `equal?` and throws an error if they are not
 
--   `eq?`
+-   `not=`
+    -   `(not= 1 2)` is equivalent to `(not (= 1 2))`
+    -   `(not= 1 1.0)` is `true` (comparing an int to a float)
+    -   `state.rs` defines special forms object with key `numneq` mapped to the name `not=`.
+    -   `compile_math.rs` converts `numneq` to opcode `NUMNEQ`
+    -   `exec_loop.rs` maps opcode `NUMNEQ` to a negation of the implementation of opcode `EQUAL` AKA `=`
 
-    -   uses `Value::PartialEq` implementation
-    -   `state.rs` defines special forms object with key `eq` mapped to the name `eq?`.
-    -   `compile.rs` matches on `env.specials().eq` and generates opcode `EQ`
-    -   `exec_loop.rs` maps opcode `EQ` to function `is_eq`
-    -   `vm.rs` `is_eq` converts each arg to a `Value` and compares `val1 == val2` which uses `Value::PartialEq` implementation
+### Moving Forward
 
--   `=`
-    -   numeric equality after converting to `i64` or `f64`
-    -   `state.rs` defines special forms object with key `numeq` mapped to the name `=`.
-    -   `compile.rs` calls `compile_list` which calls `compile_special` which calls `compile_math` in `compile_math.rs`
-    -   `compile_math.rs` `compile_math` matches on `env.specials().numeq` and generates opcode `NUMEQ`
-    -   `exec_loop.rs` maps opcode `NUMEQ` to function `compare_int` and passes two comparators
-        -   an integer comparator: `|a,b| a == b`
-        -   a float comparator: `|a: f64, b: f64| (a - b).abs() < f64::EPSILON`
-    -   `macros.rs` `compare_int`
-        -   checks if either argument is a `Float` and if so, converts both to `f64` with `get_float` macro and uses the float comparator
-        -   checks if either argument is a `Int` and if so, converts both to `i64` with `get_int` macro and uses the integer comparator
-    -   ultimately, ints are compared as i64 and floats are compared as f64 with a tolerance of `f64::EPSILON`
+-   = should be converted to =?
+-   =? should just be an alias for equal? which is the slower more intuitive equality check
+-   eq? is the faster more strict equality check but it does spend a little extra time making sure to dereference captured heap values
+-   eq? on floats should do an IEEE comparison
+-   eq? should consider 1.0 equal to 1
+-   equal? on floats should do a fuzzy comparison
+-   if we want a bitwise comparison of floats we will implement it later
+
+eq? does not do type coercion
+just do what clojure does
+numeq should be a bit fuzzy
+NaN != NaN is false and NaN == NaN is false
+
+may 1 2024
+= (equal) loosy goosey (still use IEEE comparison)
+== (=?) (for numbers) (IEEE comparison)
+identical? (eq?) (bytewise equality)
+users who want rough epsilon equality can defn their own fn
diff --git a/slosh/tests/equality.slosh b/slosh/tests/equality.slosh
@@ -0,0 +1,8 @@
+#!/usr/bin/env slosh
+
+(assert-true (= 1 1))
+(assert-false (= 2 2.0))
+(assert-true (not= 2 2.0))
+(assert-true (== 2 2.0))
+(assert-true (== 2 2.000000000000000000000000000000000000000000001))
+(assert-false(== 1e-30 1.001e-30))
diff --git a/vm/src/value.rs b/vm/src/value.rs
@@ -245,6 +245,18 @@ impl Value {
         matches!(&self, Value::Byte(_) | Value::Int(_) | Value::Float(_))
     }
 
+    pub fn is_float(&self) -> bool {
+        matches!(self, Value::Float(_))
+    }
+
+    pub fn not(&self) -> Value {
+        match self {
+            Value::False => Value::True,
+            Value::Nil => Value::True,
+            _ => Value::False,
+        }
+    }
+
     pub fn get_int<ENV>(&self, _vm: &GVm<ENV>) -> VMResult<i64> {
         match &self {
             Value::Byte(b) => Ok(*b as i64),
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -189,7 +189,7 @@ impl<ENV> GVm<ENV> {
         Ok(val)
     }
 
-    fn is_eq(&self, reg1: u16, reg2: u16) -> VMResult<Value> {
+    fn is_identical(&self, reg1: u16, reg2: u16) -> VMResult<Value> {
         let mut val = Value::False;
         if reg1 == reg2 {
             val = Value::True;
@@ -230,9 +230,14 @@ impl<ENV> GVm<ENV> {
                 val = Value::True;
             }
         } else if val1.is_number() && val2.is_number() {
-            let diff = (val1.get_float(self)? - val2.get_float(self)?).abs();
-            if diff == 0.0 {
-                val = Value::True;
+            // compare two floats by converting to f64 and using native equality check (IEEE)
+            if val1.is_float() && val2.is_float() {
+                if val1.get_float(self)? == val2.get_float(self)? {
+                    val = Value::True;
+                }
+            } else {
+                // we are comparing two numbers but they aren't both ints or both floats
+                val = Value::False;
             }
         } else {
             match (val1, val2) {
@@ -391,6 +396,7 @@ impl<ENV> GVm<ENV> {
         Ok(val)
     }
 
+    /// test if the operands are = (more lenient than identical)
     fn is_equal(&self, reg1: u16, reg2: u16) -> VMResult<Value> {
         let mut val = Value::False;
         if reg1 == reg2 {
@@ -1577,4 +1583,29 @@ mod tests {
         assert!(res.unwrap_err().to_string() == "[rt]: Divide by zero error.");
         Ok(())
     }
+
+    #[test]
+    fn test_equality() {
+        let vm = Vm::new();
+
+        let byte = Value::Byte(2);
+        let another_byte = Value::Byte(2);
+        let int = Value::Int([0, 0, 0, 0, 0, 0, 2]);
+        let another_int = Value::Int([0, 0, 0, 0, 0, 0, 2]);
+        let float = Value::Float(2.0.into());
+        let another_float = Value::Float(2.0000000000000000000000000000000000000000001.into());
+
+        // testing `=`
+        assert!(vm.is_equal_pair(byte, int).unwrap().is_true());
+        assert!(vm.is_equal_pair(byte, float).unwrap().is_false());
+        assert!(vm.is_equal_pair(int, float).unwrap().is_false());
+
+        // testing `identical?`
+        assert!(byte == another_byte);
+        assert!(int == another_int);
+        assert!(float == another_float);
+        assert!(byte != int);
+        assert!(byte != float);
+        assert!(int != float);
+    }
 }
diff --git a/vm/src/vm/exec_loop.rs b/vm/src/vm/exec_loop.rs
@@ -805,7 +805,9 @@ impl<ENV> GVm<ENV> {
                 }
                 EQ => {
                     let (dest, reg1, reg2) = decode3!(self.ip_ptr, wide);
-                    let val = self.is_eq(reg1, reg2).map_err(|e| (e, chunk.clone()))?;
+                    let val = self
+                        .is_identical(reg1, reg2)
+                        .map_err(|e| (e, chunk.clone()))?;
                     set_register!(self, dest as usize, val);
                 }
                 EQUAL => {
@@ -948,30 +950,29 @@ impl<ENV> GVm<ENV> {
                 SUB => binary_math!(self, chunk, self.ip_ptr, |a, b| a - b, wide),
                 MUL => binary_math!(self, chunk, self.ip_ptr, |a, b| a * b, wide),
                 DIV => div_math!(self, chunk, self.ip_ptr, wide),
-                NUMEQ => compare_int!(
-                    self,
-                    chunk,
-                    self.ip_ptr,
-                    |a, b| a == b,
-                    |a: f64, b: f64| (a - b).abs() < f64::EPSILON,
-                    wide,
-                    true,
-                    false
-                ),
-                NUMNEQ => compare_int!(
-                    self,
-                    chunk,
-                    self.ip_ptr,
-                    |a, b| a == b,
-                    |a: f64, b: f64| (a - b).abs() < f64::EPSILON,
-                    wide,
-                    true,
-                    true
-                ),
-                NUMLT => compare!(self, chunk, self.ip_ptr, |a, b| a < b, wide, true),
-                NUMLTE => compare!(self, chunk, self.ip_ptr, |a, b| a <= b, wide, true),
-                NUMGT => compare!(self, chunk, self.ip_ptr, |a, b| a > b, wide, true),
-                NUMGTE => compare!(self, chunk, self.ip_ptr, |a, b| a >= b, wide, true),
+                NUMEQ => {
+                    compare_numeric!(self, chunk, self.ip_ptr, |a, b| a == b, wide)
+                }
+                NUMNEQ => {
+                    // TODO: #142 NUMNEQ is being hijacked temporarily to implement clojure `not=` which is a non-numeric comparison
+                    let (dest, reg1, reg2) = decode3!(self.ip_ptr, wide);
+                    let val = self.is_equal(reg1, reg2).map_err(|e| (e, chunk.clone()))?;
+                    set_register!(self, dest as usize, val.not());
+                    // This is what NUMNEQ would look like if it were a numeric comparison
+                    // compare_numeric!(self, chunk, self.ip_ptr, |a, b| a != b, wide)
+                }
+                NUMLT => {
+                    compare_numeric!(self, chunk, self.ip_ptr, |a, b| a < b, wide)
+                }
+                NUMLTE => {
+                    compare_numeric!(self, chunk, self.ip_ptr, |a, b| a <= b, wide)
+                }
+                NUMGT => {
+                    compare_numeric!(self, chunk, self.ip_ptr, |a, b| a > b, wide)
+                }
+                NUMGTE => {
+                    compare_numeric!(self, chunk, self.ip_ptr, |a, b| a >= b, wide)
+                }
                 INC => {
                     let (dest, i) = decode2!(self.ip_ptr, wide);
                     match self.register(dest as usize) {
diff --git a/vm/src/vm/macros.rs b/vm/src/vm/macros.rs
