speed up ==, hash, <, >, <=, and >= for plain_data

[nmutil.git] / src / nmutil / divmod.py

diff --git a/src/nmutil/divmod.py b/src/nmutil/divmod.py
index 0f1a5491aeaabb83eacb49e251c5ecedd6c4e94b..7c503e6199992462824c8646f1ef62d697d6a536 100644 (file)
--- a/src/nmutil/divmod.py
+++ b/src/nmutil/divmod.py
@@ -1,20 +1,46 @@
-# this is a POWER ISA 3.0B compatible div function
+# SPDX-License-Identifier: LGPL-3-or-later
+"""
+    This work is funded through NLnet under Grant 2019-02-012
+
+    License: LGPLv3+
+
+
+"""
+
+from copy import copy
+# this is a POWER ISA 3.0B compatible *signed* div function
 # however it is also the c, c++, rust, java *and* x86 way of doing things
-def trunc_div(n, d):
-    abs_n = abs(n)
-    abs_d = abs(d)
+
+
+def trunc_divs(n, d):
+    abs_n = abs(n.to_signed_int())
+    abs_d = abs(d.to_signed_int())
+    print("trunc_div n", abs_n, n.to_signed_int())
+    print("trunc_div d", abs_d, d.to_signed_int())
     abs_q = abs_n // abs_d
-    #print ("trunc_div", n.value, d.value,
-    #                    abs_n.value, abs_d.value, abs_q.value,
-    #                    n == abs_n, d == abs_d)
-    if (n == abs_n) == (d == abs_d):
-        return abs_q
-    return -abs_q
+    sign_n = n.value & (1 << (n.bits - 1)) != 0
+    sign_d = d.value & (1 << (d.bits - 1)) != 0
+    print("trunc_div", hex(n.value), hex(d.value),
+          hex(abs_n), hex(abs_d), hex(abs_q),
+          sign_n, sign_d)
+    res = copy(n)
+    if (sign_n == sign_d):
+        res.value = abs_q
+        if res.value & (1 << (res.bits - 1)) != 0:
+            # result should be positive but is negative
+            raise OverflowError()
+        return res
+    mask = (1 << res.bits) - 1
+    res.value = (-abs_q) & mask
 
+    return res
 
-# this is a POWER ISA 3.0B compatible mod / remainder function
-# however it is also the c, c++, rust, java *and* x86 way of doing things
-def trunc_rem(n, d):
-    return n - d * trunc_div(n, d)
 
+# this is a POWER ISA 3.0B compatible *signed* mod / remainder function
+# however it is also the c, c++, rust, java *and* x86 way of doing things
+def trunc_rems(n, d):
+    m = d * trunc_divs(n, d)
 
+    # cheat - really shouldn't do this. mul returns full length
+    m.bits = n.bits
+    return n - m