Fix overflows and edge cases

For example when difference between two longs is larger than a long it would overflow.
Also when bit-difference was exactly Long/MIN_VALUE it would error when getting the absolute value.
Use bignum to work around these.
Also makes it compatible with older Clojure versions that didn't have `abs`.

Author: emlyn

CHANGELOG.md

@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ## Versions
 
 ## [Unreleased]
+- Fix bug that would return true for `(ish? 1.0 2.0)` in recent Java versions (found/tested in Java 17)
+- Fix some overflows and edge cases when comparing doubles that are not close
 
 ## [0.1.7] - 2025-02-09
 - Remove deprecated single-segment namespace

src/same/platform.cljc

@@ -74,11 +74,18 @@
             (Math/ulp (double f)))
      :cljs (ulp* f)))
 
+(defn abs-val
+  [v]
+  (cond
+    (= v Long/MIN_VALUE) (- (bigint v))
+    (neg? v)             (- v)
+    :else                v))
+
 (defn bit-diff-double
   "Difference between two doubles in ULPs (i.e. number of representable numbers between them + 1)."
   [f1 f2]
-  #?(:clj (abs (- (Double/doubleToLongBits f1)
-                  (Double/doubleToLongBits f2)))
+  #?(:clj (abs-val (- (bigint (Double/doubleToLongBits f1))
+                      (bigint (Double/doubleToLongBits f2))))
      :cljs (let [buf (js/ArrayBuffer. 16)
                  dv  (js/DataView. buf)]
              (.setFloat64 dv 0 (double f1))
@@ -90,8 +97,8 @@
 (defn bit-diff-float
   "Difference between two floats in ULPs (i.e. number of representable numbers between them + 1)."
   [f1 f2]
-  #?(:clj (abs ^long (- (Float/floatToIntBits f1)
-                        (Float/floatToIntBits f2)))
+  #?(:clj (abs-val (- (Float/floatToIntBits f1)
+                      (Float/floatToIntBits f2)))
      :cljs (let [buf (js/ArrayBuffer. 8)
                  dv  (js/DataView. buf)]
              (.setFloat32 dv 0 (float f1))

test/same/platform_test.cljc

@@ -46,6 +46,8 @@
 
 (deftest bit-diff-double-test
   (is (zero? (p/bit-diff-double 1.0 1.0)))
+  (is (= 0x8000000000000000N (p/bit-diff-double 1.0 -1.0)))
+  (is (= 0x8000000000000000N (p/bit-diff-double -1.0 1.0)))
   (is (= 1 (p/bit-diff-double 1.0 1.0000000000000002)))
   (is (= 1 (p/bit-diff-double 1.0000000000000002 1.0)))
   (is (= 0x8000000000000 (p/bit-diff-double 1.0 1.5)))