odxtools 6.6.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/compumethods/compurationalcoeffs.py

@@ -1,25 +1,36 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List
+from typing import List, Union, cast
 from xml.etree import ElementTree
 
-from ..exceptions import odxrequire
+from ..exceptions import odxassert, odxrequire
 from ..odxlink import OdxDocFragment
+from ..odxtypes import DataType
 
 
 @dataclass
 class CompuRationalCoeffs:
-    numerators: List[float]
-    denominators: List[float]
+    value_type: DataType
+
+    numerators: List[Union[int, float]]
+    denominators: List[Union[int, float]]
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "CompuRationalCoeffs":
+    def coeffs_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                       value_type: DataType) -> "CompuRationalCoeffs":
+        odxassert(
+            value_type
+            in (DataType.A_UINT32, DataType.A_INT32, DataType.A_FLOAT32, DataType.A_FLOAT64),
+            "Rational coefficients must be of numeric type.")
+
         numerators = [
-            float(odxrequire(elem.text)) for elem in et_element.iterfind("COMPU-NUMERATOR/V")
+            cast(float, value_type.from_string(odxrequire(elem.text)))
+            for elem in et_element.iterfind("COMPU-NUMERATOR/V")
         ]
         denominators = [
-            float(odxrequire(elem.text)) for elem in et_element.iterfind("COMPU-DENOMINATOR/V")
+            cast(float, value_type.from_string(odxrequire(elem.text)))
+            for elem in et_element.iterfind("COMPU-DENOMINATOR/V")
         ]
 
-        return CompuRationalCoeffs(numerators=numerators, denominators=denominators)
+        return CompuRationalCoeffs(
+            value_type=value_type, numerators=numerators, denominators=denominators)

odxtools/compumethods/compuscale.py

@@ -3,9 +3,11 @@ from dataclasses import dataclass
 from typing import List, Optional
 from xml.etree import ElementTree
 
+from ..description import Description
 from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
-from ..utils import create_description_from_et
+from .compuconst import CompuConst
+from .compuinversevalue import CompuInverseValue
 from .compurationalcoeffs import CompuRationalCoeffs
 from .limit import Limit
 
@@ -13,49 +15,51 @@ from .limit import Limit
 @dataclass
 class CompuScale:
     """A COMPU-SCALE represents one value range of a COMPU-METHOD.
-
-    Example:
-
-    For a TEXTTABLE compu method a compu scale within COMPU-INTERNAL-TO-PHYS
-    can be defined with
-    ```
-    scale = CompuScale(
-        short_label="example_label", # optional: provide a label
-        description="<p>fancy description</p>", # optional: provide a description
-        lower_limit=Limit(0), # required: lower limit
-        upper_limit=Limit(3), # required: upper limit
-        compu_inverse_value=2, # required if lower_limit != upper_limit
-        compu_const="true", # required: physical value to be shown to the user
-    )
-    ```
-
-    Almost all attributes are optional but there are compu-method-specific restrictions.
-    E.g., lower_limit must always be defined unless the COMPU-METHOD is of CATEGORY LINEAR or RAT-FUNC.
-    Either `compu_const` or `compu_rational_coeffs` must be defined but never both.
     """
 
     short_label: Optional[str]
-    description: Optional[str]
+    description: Optional[Description]
     lower_limit: Optional[Limit]
     upper_limit: Optional[Limit]
-    compu_inverse_value: Optional[AtomicOdxType]
-    compu_const: Optional[AtomicOdxType]
+    compu_inverse_value: Optional[CompuInverseValue]
+    compu_const: Optional[CompuConst]
     compu_rational_coeffs: Optional[CompuRationalCoeffs]
 
+    # the following two attributes are not specified for COMPU-SCALE
+    # tags in the XML, but they are required to do anything useful
+    # with compu scales: The domain type is the input set of the
+    # function associated with the compu scale object, whilst the
+    # range type represents the output set. IOW, for scales contained
+    # by the internal-to-physical mapping function, the domain type is
+    # the internal and the range type is the physical type of the
+    # compu method. (Vice versa for scales specified by the
+    # physical-to-internal mapping function.)
+    domain_type: DataType
+    range_type: DataType
+
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
-                internal_type: DataType, physical_type: DataType) -> "CompuScale":
+    def compuscale_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                           domain_type: DataType, range_type: DataType) -> "CompuScale":
         short_label = et_element.findtext("SHORT-LABEL")
-        description = create_description_from_et(et_element.find("DESC"))
-        lower_limit = Limit.from_et(et_element.find("LOWER-LIMIT"), internal_type=internal_type)
-        upper_limit = Limit.from_et(et_element.find("UPPER-LIMIT"), internal_type=internal_type)
+        description = Description.from_et(et_element.find("DESC"), doc_frags)
+
+        lower_limit = Limit.limit_from_et(
+            et_element.find("LOWER-LIMIT"), doc_frags, value_type=domain_type)
+        upper_limit = Limit.limit_from_et(
+            et_element.find("UPPER-LIMIT"), doc_frags, value_type=domain_type)
 
-        compu_inverse_value = internal_type.create_from_et(et_element.find("COMPU-INVERSE-VALUE"))
-        compu_const = physical_type.create_from_et(et_element.find("COMPU-CONST"))
+        compu_inverse_value = None
+        if (cive := et_element.find("COMPU-INVERSE-VALUE")) is not None:
+            compu_inverse_value = CompuInverseValue.compuvalue_from_et(cive, data_type=domain_type)
+
+        compu_const = None
+        if (cce := et_element.find("COMPU-CONST")) is not None:
+            compu_const = CompuConst.compuvalue_from_et(cce, data_type=range_type)
 
         compu_rational_coeffs: Optional[CompuRationalCoeffs] = None
         if (crc_elem := et_element.find("COMPU-RATIONAL-COEFFS")) is not None:
-            compu_rational_coeffs = CompuRationalCoeffs.from_et(crc_elem, doc_frags)
+            compu_rational_coeffs = CompuRationalCoeffs.coeffs_from_et(
+                crc_elem, doc_frags, value_type=range_type)
 
         return CompuScale(
             short_label=short_label,
@@ -64,4 +68,35 @@ class CompuScale:
             upper_limit=upper_limit,
             compu_inverse_value=compu_inverse_value,
             compu_const=compu_const,
-            compu_rational_coeffs=compu_rational_coeffs)
+            compu_rational_coeffs=compu_rational_coeffs,
+            domain_type=domain_type,
+            range_type=range_type)
+
+    def applies(self, internal_value: AtomicOdxType) -> bool:
+
+        if self.lower_limit is None and self.upper_limit is None:
+            # Everything is allowed: No limits have been specified
+            return True
+        elif self.upper_limit is None:
+            # no upper limit has been specified. the spec says that
+            # the value specified by the lower limit is the only one
+            # which is allowed (cf section 7.3.6.6.1)
+            assert self.lower_limit is not None
+
+            return internal_value == self.lower_limit.value
+        elif self.lower_limit is None:
+            # only the upper limit has been specified. the spec is
+            # ambiguous: it only says that if no upper limit is
+            # defined, the lower limit shall also be used as the upper
+            # limit and a closed interval type ought to be assumed,
+            # but it does not say what happens if the lower limit is
+            # not defined (which is allowed by the XSD). We thus
+            # assume that if only the upper limit is defined, is
+            # treated the same way as if only the lower limit is
+            # specified.
+            assert self.upper_limit is not None
+
+            return internal_value == self.upper_limit.value
+
+        return self.lower_limit.complies_to_lower(internal_value) and \
+            self.upper_limit.complies_to_upper(internal_value)

odxtools/compumethods/createanycompumethod.py

@@ -1,194 +1,53 @@
 # SPDX-License-Identifier: MIT
-import warnings
-from typing import Any, Dict, List, Optional
+from typing import List
 from xml.etree import ElementTree
 
-from ..exceptions import OdxWarning, odxassert, odxraise, odxrequire
-from ..globals import logger
+from ..exceptions import odxraise, odxrequire
 from ..odxlink import OdxDocFragment
 from ..odxtypes import DataType
+from .compucodecompumethod import CompuCodeCompuMethod
 from .compumethod import CompuMethod
-from .compuscale import CompuScale
 from .identicalcompumethod import IdenticalCompuMethod
-from .limit import IntervalType, Limit
 from .linearcompumethod import LinearCompuMethod
+from .ratfunccompumethod import RatFuncCompuMethod
 from .scalelinearcompumethod import ScaleLinearCompuMethod
+from .scaleratfunccompumethod import ScaleRatFuncCompuMethod
 from .tabintpcompumethod import TabIntpCompuMethod
 from .texttablecompumethod import TexttableCompuMethod
 
 
-def _parse_compu_scale_to_linear_compu_method(
-    *,
-    scale_element: ElementTree.Element,
-    internal_type: DataType,
-    physical_type: DataType,
-    is_scale_linear: bool = False,
-    **kwargs: Any,
-) -> LinearCompuMethod:
-    odxassert(physical_type in [
-        DataType.A_FLOAT32,
-        DataType.A_FLOAT64,
-        DataType.A_INT32,
-        DataType.A_UINT32,
-    ])
-    odxassert(internal_type in [
-        DataType.A_FLOAT32,
-        DataType.A_FLOAT64,
-        DataType.A_INT32,
-        DataType.A_UINT32,
-    ])
-
-    if physical_type.as_python_type() == float:
-        computation_python_type = physical_type.from_string
-    else:
-        computation_python_type = internal_type.from_string
-
-    kwargs = kwargs.copy()
-    kwargs["internal_type"] = internal_type
-    kwargs["physical_type"] = physical_type
-
-    coeffs = odxrequire(scale_element.find("COMPU-RATIONAL-COEFFS"))
-    nums = coeffs.iterfind("COMPU-NUMERATOR/V")
-
-    offset = computation_python_type(odxrequire(next(nums).text))
-    factor_el = next(nums, None)
-    factor = computation_python_type(odxrequire(factor_el.text) if factor_el is not None else "0")
-    denominator = 1.0
-    if (string := coeffs.findtext("COMPU-DENOMINATOR/V")) is not None:
-        denominator = float(string)
-        if denominator == 0:
-            warnings.warn(
-                "CompuMethod: A denominator of zero will lead to divisions by zero.",
-                OdxWarning,
-                stacklevel=1)
-    # Read lower limit
-    internal_lower_limit = Limit.from_et(
-        scale_element.find("LOWER-LIMIT"),
-        internal_type=internal_type,
-    )
-    if internal_lower_limit is None:
-        internal_lower_limit = Limit(0, IntervalType.INFINITE)
-    kwargs["internal_lower_limit"] = internal_lower_limit
-
-    # Read upper limit
-    internal_upper_limit = Limit.from_et(
-        scale_element.find("UPPER-LIMIT"),
-        internal_type=internal_type,
-    )
-    if internal_upper_limit is None:
-        if not is_scale_linear:
-            internal_upper_limit = Limit(0, IntervalType.INFINITE)
-        else:
-            odxassert(internal_lower_limit is not None and
-                      internal_lower_limit.interval_type == IntervalType.CLOSED)
-            logger.info("Scale linear without UPPER-LIMIT")
-            internal_upper_limit = internal_lower_limit
-    kwargs["internal_upper_limit"] = internal_upper_limit
-    kwargs["denominator"] = denominator
-    kwargs["factor"] = factor
-    kwargs["offset"] = offset
-
-    return LinearCompuMethod(**kwargs)
-
-
-def create_compu_default_value(et_element: Optional[ElementTree.Element],
-                               doc_frags: List[OdxDocFragment], internal_type: DataType,
-                               physical_type: DataType) -> Optional[CompuScale]:
-    if et_element is None:
-        return None
-    compu_const = physical_type.create_from_et(et_element)
-    scale = CompuScale.from_et(
-        et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
-    scale.compu_const = compu_const
-    return scale
-
-
 def create_any_compu_method_from_et(et_element: ElementTree.Element,
-                                    doc_frags: List[OdxDocFragment], internal_type: DataType,
+                                    doc_frags: List[OdxDocFragment], *, internal_type: DataType,
                                     physical_type: DataType) -> CompuMethod:
-    compu_category = et_element.findtext("CATEGORY")
-    odxassert(compu_category in [
-        "IDENTICAL",
-        "LINEAR",
-        "SCALE-LINEAR",
-        "TEXTTABLE",
-        "COMPUCODE",
-        "TAB-INTP",
-        "RAT-FUNC",
-        "SCALE-RAT-FUNC",
-    ])
-
-    if et_element.find("COMPU-PHYS-TO-INTERNAL") is not None:  # TODO: Is this never used?
-        raise NotImplementedError(f"Found COMPU-PHYS-TO-INTERNAL for category {compu_category}")
-
-    kwargs: Dict[str, Any] = {
-        "physical_type": physical_type,
-        "internal_type": internal_type,
-    }
+    compu_category = odxrequire(et_element.findtext("CATEGORY"))
 
     if compu_category == "IDENTICAL":
-        odxassert(
-            internal_type == physical_type or
-            (internal_type in [DataType.A_ASCIISTRING, DataType.A_UTF8STRING] and
-             physical_type == DataType.A_UNICODE2STRING),
-            f"Internal type '{internal_type}' and physical type '{physical_type}'"
-            f" must be the same for compu methods of category '{compu_category}'")
-        return IdenticalCompuMethod(internal_type=internal_type, physical_type=physical_type)
-
-    if compu_category == "TEXTTABLE":
-        odxassert(physical_type == DataType.A_UNICODE2STRING)
-        compu_internal_to_phys = odxrequire(et_element.find("COMPU-INTERNAL-TO-PHYS"))
-
-        internal_to_phys: List[CompuScale] = []
-        for scale_elem in compu_internal_to_phys.iterfind("COMPU-SCALES/COMPU-SCALE"):
-            internal_to_phys.append(
-                CompuScale.from_et(
-                    scale_elem, doc_frags, internal_type=internal_type,
-                    physical_type=physical_type))
-        compu_default_value = create_compu_default_value(
-            et_element.find("COMPU-DEFAULT-VALUE"), doc_frags, **kwargs)
-
-        return TexttableCompuMethod(
-            internal_to_phys=internal_to_phys,
-            compu_default_value=compu_default_value,
-            **kwargs,
-        )
-
+        return IdenticalCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
     elif compu_category == "LINEAR":
-        # Compu method can be described by the function f(x) = (offset + factor * x) / denominator
-
-        scale_elem = odxrequire(et_element.find("COMPU-INTERNAL-TO-PHYS/COMPU-SCALES/COMPU-SCALE"))
-        return _parse_compu_scale_to_linear_compu_method(scale_element=scale_elem, **kwargs)
-
+        return LinearCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
     elif compu_category == "SCALE-LINEAR":
-
-        scale_elems = et_element.iterfind("COMPU-INTERNAL-TO-PHYS/COMPU-SCALES/COMPU-SCALE")
-        linear_methods = [
-            _parse_compu_scale_to_linear_compu_method(scale_element=scale_elem, **kwargs)
-            for scale_elem in scale_elems
-        ]
-        return ScaleLinearCompuMethod(linear_methods=linear_methods, **kwargs)
-
+        return ScaleLinearCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+    elif compu_category == "RAT-FUNC":
+        return RatFuncCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+    elif compu_category == "SCALE-RAT-FUNC":
+        return ScaleRatFuncCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+    elif compu_category == "TEXTTABLE":
+        return TexttableCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+    elif compu_category == "COMPUCODE":
+        return CompuCodeCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
     elif compu_category == "TAB-INTP":
-        internal_points = []
-        physical_points = []
-        for scale_elem in et_element.iterfind("COMPU-INTERNAL-TO-PHYS/COMPU-SCALES/COMPU-SCALE"):
-            internal_point = internal_type.from_string(
-                odxrequire(scale_elem.findtext("LOWER-LIMIT")))
-            physical_point = physical_type.create_from_et(
-                odxrequire(scale_elem.find("COMPU-CONST")))
+        return TabIntpCompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
 
-            if not isinstance(internal_point, (float, int)):
-                odxraise()
-            if not isinstance(physical_point, (float, int)):
-                odxraise()
+    # TODO: Implement all categories (never instantiate the CompuMethod base class!)
+    odxraise(f"Warning: Computation category {compu_category} is not implemented!")
 
-            internal_points.append(internal_point)
-            physical_points.append(physical_point)
-
-        return TabIntpCompuMethod(
-            internal_points=internal_points, physical_points=physical_points, **kwargs)
-
-    # TODO: Implement other categories (never instantiate CompuMethod)
-    logger.warning(f"Warning: Computation category {compu_category} is not implemented!")
-    return IdenticalCompuMethod(internal_type=DataType.A_UINT32, physical_type=DataType.A_UINT32)
+    return IdenticalCompuMethod.compu_method_from_et(
+        et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)

odxtools/compumethods/identicalcompumethod.py

@@ -1,16 +1,41 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
+from typing import List
+from xml.etree import ElementTree
 
-from ..odxtypes import AtomicOdxType
-from .compumethod import CompuMethod, CompuMethodCategory
+from ..exceptions import odxassert
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuMethod
 
 
 @dataclass
 class IdenticalCompuMethod(CompuMethod):
-
-    @property
-    def category(self) -> CompuMethodCategory:
-        return "IDENTICAL"
+    """Identical compu methods just pass through the internal value.
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.2.
+    """
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "IdenticalCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        odxassert(
+            internal_type == physical_type or
+            (internal_type
+             in [DataType.A_ASCIISTRING, DataType.A_UTF8STRING, DataType.A_UNICODE2STRING] and
+             physical_type
+             in [DataType.A_ASCIISTRING, DataType.A_UTF8STRING, DataType.A_UNICODE2STRING]),
+            f"Internal type and physical type must be the same for compu methods of category "
+            f"'{cm.category}' (internal type: '{internal_type.value}', physical type: "
+            f"'{physical_type.value}')")
+
+        return IdenticalCompuMethod(**kwargs)
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         return physical_value

odxtools/compumethods/limit.py

@@ -1,11 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import List, Optional, overload
 from xml.etree import ElementTree
 
-from ..exceptions import odxassert, odxraise, odxrequire
-from ..odxtypes import AtomicOdxType, DataType
+from ..exceptions import odxraise
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType, compare_odx_values
 
 
 class IntervalType(Enum):
@@ -16,42 +17,54 @@ class IntervalType(Enum):
 
 @dataclass
 class Limit:
-    value: AtomicOdxType
-    interval_type: IntervalType = IntervalType.CLOSED
+    value_raw: Optional[str]
+    value_type: Optional[DataType]
+    interval_type: Optional[IntervalType]
 
     def __post_init__(self) -> None:
-        if self.interval_type == IntervalType.INFINITE:
-            self.value = 0
+        self._value: Optional[AtomicOdxType] = None
+
+        if self.value_type is not None:
+            self.set_value_type(self.value_type)
+
+    @staticmethod
+    @overload
+    def limit_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment],
+                      value_type: Optional[DataType]) -> "Limit":
+        ...
+
+    @staticmethod
+    @overload
+    def limit_from_et(et_element: None, doc_frags: List[OdxDocFragment],
+                      value_type: Optional[DataType]) -> None:
+        ...
 
     @staticmethod
-    def from_et(et_element: Optional[ElementTree.Element], *,
-                internal_type: DataType) -> Optional["Limit"]:
+    def limit_from_et(et_element: Optional[ElementTree.Element], doc_frags: List[OdxDocFragment],
+                      value_type: Optional[DataType]) -> Optional["Limit"]:
 
         if et_element is None:
             return None
 
+        interval_type = None
         if (interval_type_str := et_element.get("INTERVAL-TYPE")) is not None:
             try:
                 interval_type = IntervalType(interval_type_str)
             except ValueError:
-                interval_type = IntervalType.CLOSED
                 odxraise(f"Encountered unknown interval type '{interval_type_str}'")
-        else:
-            interval_type = IntervalType.CLOSED
-
-        if interval_type == IntervalType.INFINITE:
-            if et_element.tag == "LOWER-LIMIT":
-                return Limit(float("-inf"), interval_type)
-            else:
-                odxassert(et_element.tag == "UPPER-LIMIT")
-                return Limit(float("inf"), interval_type)
-        elif internal_type == DataType.A_BYTEFIELD:
-            hex_text = odxrequire(et_element.text)
-            if len(hex_text) % 2 == 1:
-                hex_text = "0" + hex_text
-            return Limit(bytes.fromhex(hex_text), interval_type)
-        else:
-            return Limit(internal_type.from_string(odxrequire(et_element.text)), interval_type)
+
+        value_raw = et_element.text
+
+        return Limit(value_raw=value_raw, interval_type=interval_type, value_type=value_type)
+
+    def set_value_type(self, value_type: DataType) -> None:
+        self.value_type = value_type
+        if self.value_raw is not None:
+            self._value = value_type.from_string(self.value_raw)
+
+    @property
+    def value(self) -> Optional[AtomicOdxType]:
+        return self._value
 
     def complies_to_upper(self, value: AtomicOdxType) -> bool:
         """Checks if the value is in the range w.r.t. the upper limit.
@@ -60,13 +73,23 @@ class Limit:
         * If the interval type is open, return `value < limit.value`.
         * If the interval type is infinite, return `True`.
         """
-        if self.interval_type == IntervalType.CLOSED:
-            return value <= self.value  # type: ignore[operator]
-        elif self.interval_type == IntervalType.OPEN:
-            return value < self.value  # type: ignore[operator]
-        elif self.interval_type == IntervalType.INFINITE:
+        if self._value is None:
+            # if no value is specified, assume interval type INFINITE
+            # (what are we supposed to compare against?)
             return True
 
+        if self.interval_type is None or self.interval_type == IntervalType.CLOSED:
+            # assume interval type CLOSED if a value was specified,
+            # but no interval type
+            return compare_odx_values(value, self._value) <= 0
+        elif self.interval_type == IntervalType.OPEN:
+            return compare_odx_values(value, self._value) < 0
+
+        if self.interval_type != IntervalType.INFINITE:
+            odxraise("Unhandled interval type {self.interval_type}")
+
+        return True
+
     def complies_to_lower(self, value: AtomicOdxType) -> bool:
         """Checks if the value is in the range w.r.t. the lower limit.
 
@@ -74,9 +97,20 @@ class Limit:
         * If the interval type is open, return `limit.value < value`.
         * If the interval type is infinite, return `True`.
         """
-        if self.interval_type == IntervalType.CLOSED:
-            return self.value <= value  # type: ignore[operator]
-        elif self.interval_type == IntervalType.OPEN:
-            return self.value < value  # type: ignore[operator]
-        elif self.interval_type == IntervalType.INFINITE:
+
+        if self._value is None:
+            # if no value is specified, assume interval type INFINITE
+            # (what are we supposed to compare against?)
             return True
+
+        if self.interval_type is None or self.interval_type == IntervalType.CLOSED:
+            # assume interval type CLOSED if a value was specified,
+            # but no interval type
+            return compare_odx_values(value, self._value) >= 0
+        elif self.interval_type == IntervalType.OPEN:
+            return compare_odx_values(value, self._value) > 0
+
+        if self.interval_type != IntervalType.INFINITE:
+            odxraise("Unhandled interval type {self.interval_type}")
+
+        return True