Implement minimums by size as per CDI Standard.

Author: Poikilos

openlcb/cdivar.py

@@ -17,6 +17,50 @@
 NUM_TYPES = {'int': int, 'float': float}  # type: dict[str, Type]
 # Assumes "IEEE" in OpenLCB CDI Standard means IEEE 754-2008:
 FLOAT_MAXIMUMS = {2: 65504.0, 4: 3.40e38, 8: 1.80e308}  # type: dict[int, float]  # noqa: E501
+# Float minimums (https://en.wikipedia.org/wiki/IEEE_754):
+# 16-bit smallest normal 6.10×10−5 subnormal 5.96×10−8
+# 32-bit smallest normal 1.18×10−38 subnormal 1.40×10−45
+# 64-bit smallest normal 2.23×10−308 subnormal 4.94×10−324
+F_MIN_BITS = {
+    2: [0] * 16,
+    4: [0] * 32,
+    8: [0] * 64,
+}
+
+# Set bits for the most negative finite number
+for size, bits in F_MIN_BITS.items():
+    bits[0] = 1                                 # Sign bit = 1 (negative)
+    if size == 2:      # binary16: 1 sign + 5 exp + 10 mant
+        for i in range(1, 6):   bits[i] = 1    # exp = 11110
+        bits[5] = 0                             # ← important: clear LSB of exponent
+        for i in range(6, 16):  bits[i] = 1    # mantissa all 1s
+    elif size == 4:    # binary32: 1 sign + 8 exp + 23 mant
+        for i in range(1, 9):   bits[i] = 1    # exp = 11111110
+        bits[8] = 0                             # ← clear LSB of exponent
+        for i in range(9, 32):  bits[i] = 1
+    else:              # binary64: 1 sign + 11 exp + 52 mant
+        for i in range(1, 12):  bits[i] = 1    # exp = 111...1110
+        bits[11] = 0                            # ← clear LSB of exponent
+        for i in range(12, 64): bits[i] = 1
+
+FLOAT_MINIMUMS = {}  # F_MIN_DATA = {}
+
+for k, bits in F_MIN_BITS.items():
+    # Create traceable binary string (e.g. "0b000...001")
+    bit_str = "0b" + "".join(map(str, bits))
+    # Convert to integer then to bytes
+    value = int(bit_str, 2)
+    data_bytes = value.to_bytes(k, 'big')
+    fmt = {2: ">e", 4: ">f", 8: ">d"}[k]
+    # F_MIN_DATA[k] = data_bytes 
+    FLOAT_MINIMUMS[k] = struct.unpack(fmt, data_bytes)[0]
+    # print(f"binary{k*8:2d} bits: {bit_str}")
+    # print(f"binary{k*8:2d} value: {F_MIN_DATA[k]:.20e}\n")
+    # results:
+    # -65504.0
+    # -3.4028234663852886e+38
+    # -1.7976931348623157e+308
+
 UNSIGNED_INT_MAXIMUMS = {  # type: dict[int, int]
     1: 0xFF, 2: 0xFFFF, 4: 0xFFFF_FFFF, 8: 0xFFFF_FFFF_FFFF_FFFF}
 SIGNED_INT_MINIMUMS = {}
@@ -89,7 +133,8 @@ class CDIVar:
 
     def __init__(self, className, _min=None, _max=None,
                  _size=None, _default=None, assert_range=False,
-                 _no_min=False, _no_max=False, _default_data=None):
+                 _no_min=False, _no_max=False, _default_data=None,
+                 signed=None):
         self.data = None  # type: bytes|None
         self.min = _min  # type: CDIVar|None
         self.max = _max  # type: CDIVar|None
@@ -101,8 +146,6 @@ def __init__(self, className, _min=None, _max=None,
             f"Expected {list(CLASSNAME_TYPES.keys())} got {className}"
         if _default is not None:
             assert isinstance(_default, CDIVar)
-            if className in NUM_TYPES:
-                _default.assertNumberFormat()
             assert _default_data is None, \
                 "Can only set _default or _default_data"
         elif _default_data is not None:
@@ -113,9 +156,18 @@ def __init__(self, className, _min=None, _max=None,
                               _no_max=True, _no_min=True)  # prevent recursion
             _default.data = _default_data
 
+        if _default is not None:
+            if className in NUM_TYPES:
+                _default.assertNumberFormat()
+                if _default < 0:
+                    if signed is None:
+                        signed = True
+
         self.name = None  # type: str|None
         self.className = className  # type: str
-        self.signed = False  # type: bool
+        if signed is None:
+            signed = False
+        self.signed = signed  # type: bool
         assert isinstance(_no_min, bool)
         assert isinstance(_no_max, bool)
         self._no_min = _no_min
@@ -140,9 +192,26 @@ def __init__(self, className, _min=None, _max=None,
                         raise AssertionError(error)
                     else:
                         logger.error(error)
-        elif not _no_min:
-            self.min = CDIVar(className, _size=_size,
-                              _no_min=True, _no_max=True)  # prevent inf recurs
+        elif (className in NUM_TYPES) and not _no_min:
+            # self.min = CDIVar(className, _size=_size,
+            #                   _no_min=True, _no_max=True)  # prevent inf recurs
+            # Set minimum based on size,
+            #   as per Configuration Description Information Standard.
+            assert _size is not None
+            if className == "int":
+                if signed:
+                    # self.min.setInt(SIGNED_INT_MINIMUMS[_size])
+                    self.min = CDIVar.fromInt(SIGNED_INT_MINIMUMS[_size],
+                                              _size)
+                else:
+                    # self.min.setInt(0)
+                    self.min = CDIVar.fromInt(0, _size)
+            elif className == "float":
+                # self.min.setFloat(FLOAT_MINIMUMS[_size])
+                self.min = CDIVar.fromFloat(FLOAT_MINIMUMS[_size], _size)
+            else:
+                raise NotImplementedError(f"no default minimum {className}")
+
         if _max is not None:
             assert isinstance(_max, CDIVar)
             _max.assertNumberFormat()
@@ -342,9 +411,11 @@ def cmp_any(cls, self: 'CDIVar', other: Union['CDIVar', float, int],
     @classmethod
     def fromNumber(cls, value: Union[int, float],
                    className: str, _size: int) -> 'CDIVar':
-        var = CDIVar(className, _size=_size)
+        var = CDIVar(className, _size=_size, _no_min=True)
+        # ^ _no_min prevents infinite recursion generating min
         if value < 0:
             var.signed = True
+            var.min = None  # remove default (0)
         if className == "int":
             assert isinstance(value, int)
             var.setInt(value)
@@ -484,6 +555,7 @@ def intToData(self, value: int) -> bytes:
         try:
             return struct.pack(self.packFormat(), value)
         except Exception as ex:
+            logger.error("")
             logger.error(formatted_ex(ex))
             logger.error(
                 f"Tried to set a(n) {self.subtype()} CDIVar"

openlcb/storagepool.py

@@ -2,7 +2,7 @@
 import struct
 from typing import Union
 
-from openlcb.cdivar import SUBTYPE_FORMATS
+from openlcb.cdivar import SUBTYPE_FORMATS, CDIVar
 from openlcb.memoryspace import MemorySpace
 
 logger = getLogger(__name__)
@@ -12,17 +12,42 @@ class StoragePool:
     def __init__(self):
         self.spaces = {}  # type: dict[int, bytearray]
 
+    def set(self, var: CDIVar):
+        assert isinstance(var, CDIVar)
+        assert var.space is not None
+        assert var.address
+        data = var.getData()
+        assert data is not None
+        self.setData(var.space, var.address, data, size=var.size)
+
+    def get(self, var: CDIVar) -> CDIVar:
+        """Modify var in place.
+
+        Returns:
+            CDIVar: Same var instance (returned by reference) modified.
+        """
+        assert isinstance(var, CDIVar)
+        assert var.space is not None
+        assert var.address
+        assert var.size is not None
+        data = self.getData(var.space, var.address, var.size)
+        assert data is not None
+        var.setData(data)
+        return var
+
     def setData(self, space: Union[MemorySpace, int], address: int,
-                data: Union[bytes, bytearray]):
+                data: Union[bytes, bytearray], size=None):
         """Set address in virtual memory space to data"""
         assert isinstance(data, (bytearray, bytes))
         if isinstance(space, MemorySpace):
             space = space.value
         assert isinstance(space, int)
         assert isinstance(address, int)
         assert address >= 0
-        # if size is None:
-        size = len(data)
+        if size is None:
+            size = len(data)
+        else:
+            assert size <= len(data)
         end = address + size
 
         if space not in self.spaces:
@@ -37,7 +62,10 @@ def setData(self, space: Union[MemorySpace, int], address: int,
                 f" byte(s) to {end} byte(s).")
             self.spaces[space] += b'\0' * newRegionLen
         assert end - address == len(data)
-        self.spaces[space][address:end] = data
+        if size < len(data):
+            self.spaces[space][address:end] = data[:size]
+        else:
+            self.spaces[space][address:end] = data
 
     def getData(self, space: Union[MemorySpace, int], address: int,
                 size: int, force=False) -> bytearray:
@@ -73,7 +101,6 @@ def setInt(self, space: Union[MemorySpace, int], address: int,
         typeStr = f"int{size*8}"
         dataFormat = SUBTYPE_FORMATS[typeStr]
         data = struct.pack(dataFormat, value)
-        print(f"packing {dataFormat}")
         assert len(data) == size, \
             f"Expected {size} byte(s) for {typeStr}, got {len(data)}"
         return self.setData(space, address, data)

tests/test_storagepool.py

@@ -3,6 +3,8 @@
 import sys
 import unittest
 
+from openlcb import emit_cast
+from openlcb.cdivar import SIGNED_INT_MINIMUMS, CDIVar
 from openlcb.storagepool import StoragePool
 
 
@@ -130,6 +132,65 @@ def testFloat(self):
         out_value = pool.getFloat(1, 10, size)
         self.assertEqual(in_value, out_value)
 
+    def testCDIVarUInt(self):
+        size = 4
+        var = CDIVar("int", _size=size)
+        var.space = 1
+        var.address = 10
+        in_value = 999
+        # signed = False
+        var.setInt(in_value)
+        self.assertEqual(var.getInt(), in_value)
+        pool = StoragePool()
+        pool.set(var)
+        var = pool.get(var)
+        self.assertEqual(var.getInt(), in_value)
+        assert var.space is not None
+        assert var.address is not None
+        assert var.size is not None
+        assert var.signed is not None
+        out_value = pool.getInt(var.space, var.address, var.size, var.signed)
+        self.assertEqual(out_value, in_value)
+
+    def testCDIVarSInt(self):
+        size = 4
+        in_value = -999
+        signed = True if in_value < 0 else False
+        # defaultVar = CDIVar("int", _size=size, _no_min=True, _no_max=True,
+        #                     signed=signed)
+        # defaultVar.setInt(in_value)
+        # simplified construction:
+        defaultVar = CDIVar.fromInt(in_value, size)
+        self.assertTrue(defaultVar.signed)
+        self.assertIsNone(defaultVar.min)
+        var = CDIVar(
+            "int",
+            _size=size,
+            _default=defaultVar,  # forces signed since negative
+        )
+        self.assertTrue(var.signed)
+        self.assertIsInstance(var.min, CDIVar)
+        self.assertIsNotNone(
+            var.min,
+            msg=f"{emit_cast(var.min)} should be min for {size*8}-bit")
+        self.assertEqual(var.min, SIGNED_INT_MINIMUMS[size])
+        # ^ == allowed since __eq__ is defined for CDIVar (var.min)
+        var.space = 1
+        var.address = 10
+        # signed = False
+        var.setInt(in_value)
+        self.assertEqual(var.getInt(), in_value)
+        pool = StoragePool()
+        pool.set(var)
+        var = pool.get(var)
+        self.assertEqual(var.getInt(), in_value)
+        assert var.space is not None
+        assert var.address is not None
+        assert var.size is not None
+        assert var.signed is True
+        out_value = pool.getInt(var.space, var.address, var.size, var.signed)
+        self.assertEqual(out_value, in_value)
+
 
 if __name__ == "__main__":
     unittest.main()