utils: add support for double-precision to ieee functions

Author: sourceperl

CHANGES

@@ -2,6 +2,7 @@ Revision history for pyModbusTCP
 
 0.x.x Next release
 
+    - encode_ieee and decode_ieee, now support double-precision format with opt double.
     - add shortcut alias for functions with long names in utils.
     - rewrite of some functions in utils.
     - improve test_utils readability.

pyModbusTCP/utils.py

@@ -36,30 +36,42 @@ def get_bits_from_int(val_int, val_size=16):
 #########################
 # floating-point function
 #########################
-def decode_ieee(val_int):
-    """Decode Python int (32 bits integer) as an IEEE single precision format
+def decode_ieee(val_int, double=False):
+    """Decode Python int (32 bits integer) as an IEEE single or double precision format
 
         Support NaN.
 
-        :param val_int: a 32 bit integer as an int Python value
+        :param val_int: a 32 or 64 bits integer as an int Python value
         :type val_int: int
+        :param double: set to decode as a 64 bits double precision,
+                       default is 32 bits single (optional)
+        :type double: bool
         :returns: float result
         :rtype: float
     """
-    return struct.unpack("f", struct.pack("I", val_int))[0]
+    if double:
+        return struct.unpack("d", struct.pack("Q", val_int))[0]
+    else:
+        return struct.unpack("f", struct.pack("I", val_int))[0]
 
 
-def encode_ieee(val_float):
-    """Encode Python float to int (32 bits integer) as an IEEE single precision
+def encode_ieee(val_float, double=False):
+    """Encode Python float to int (32 bits integer) as an IEEE single or double precision format
 
         Support NaN.
 
         :param val_float: float value to convert
         :type val_float: float
+        :param double: set to encode as a 64 bits double precision,
+                       default is 32 bits single (optional)
+        :type double: bool
         :returns: IEEE 32 bits (single precision) as Python int
         :rtype: int
     """
-    return struct.unpack("I", struct.pack("f", val_float))[0]
+    if double:
+        return struct.unpack("Q", struct.pack("d", val_float))[0]
+    else:
+        return struct.unpack("I", struct.pack("f", val_float))[0]
 
 
 ################################

tests/test_utils.py

@@ -23,22 +23,30 @@ def test_get_bits_from_int(self):
         self.assertEqual(int2bits(0xf007), [True]*3 + [False]*9 + [True]*4)
         self.assertEqual(int2bits(6, 4), [False, True, True, False])
 
-    def test_decode_ieee(self):
+    def test_ieee(self):
         # test IEEE NaN
-        self.assertTrue(math.isnan(decode_ieee(0x7fffffff)))
+        self.assertTrue(math.isnan(decode_ieee(0x7fc00000)))
+        self.assertEqual(encode_ieee(float('nan')), 0x7fc00000)
         # test +/- infinity
         self.assertTrue(math.isinf(decode_ieee(0xff800000)))
         self.assertTrue(math.isinf(decode_ieee(0x7f800000)))
-        # test some values
-        self.assertAlmostEqual(decode_ieee(0x3e99999a), 0.3)
-        self.assertAlmostEqual(decode_ieee(0xbe99999a), -0.3)
-
-    def test_encode_ieee(self):
-        # test IEEE NaN
-        self.assertEqual(encode_ieee(float('nan')), 2143289344)
-        # test some values
-        self.assertAlmostEqual(encode_ieee(0.3), 0x3e99999a)
-        self.assertAlmostEqual(encode_ieee(-0.3), 0xbe99999a)
+        # test big and small values
+        avogad = 6.022140857e+23
+        avo_32 = 0x66ff0c2f
+        avo_64 = 0x44dfe185d2f54b67
+        planck = 6.62606957e-34
+        pla_32 = 0x085c305e
+        pla_64 = 0x390b860bb596a559
+        # IEEE single or double precision format -> float
+        self.assertAlmostEqual(decode_ieee(avo_32), avogad, delta=avogad*1e-7)
+        self.assertAlmostEqual(decode_ieee(avo_64, double=True), avogad)
+        self.assertAlmostEqual(decode_ieee(pla_32), planck)
+        self.assertAlmostEqual(decode_ieee(pla_64, double=True), planck)
+        # float -> IEEE single or double precision format
+        self.assertAlmostEqual(encode_ieee(avogad), avo_32)
+        self.assertAlmostEqual(encode_ieee(avogad, double=True), avo_64)
+        self.assertAlmostEqual(encode_ieee(planck), pla_32)
+        self.assertAlmostEqual(encode_ieee(planck, double=True), pla_64)
 
     def test_word_list_to_long(self):
         # test word_list_to_long() and short alias words2longs()