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

odxtools/compumethods/linearcompumethod.py

@@ -1,203 +1,92 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import cast
+from typing import List, cast
+from xml.etree import ElementTree
 
-from ..exceptions import DecodeError, EncodeError, odxassert
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
-from .compumethod import CompuMethod, CompuMethodCategory
-from .limit import IntervalType, Limit
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
+from .linearsegment import LinearSegment
 
 
 @dataclass
 class LinearCompuMethod(CompuMethod):
-    """Represents the decoding function d(y) = (offset + factor * y) / denominator
-    where d(y) is the physical value and y is the internal value.
-
-    Examples
-    --------
-
-    Define the decoding function `d(y) = 4+2*y` (or equivalent encoding `e(x) = floor((x-4)/2)`)
-    on all integers `y` in the range -10..10 (and `x` in -16..25).
-
-    ```python
-    method = LinearCompuMethod(
-        offset=4,
-        factor=2,
-        internal_type=DataType.A_INT32,
-        physical_type=DataType.A_INT32,
-        internal_lower_limit = Limit(-10, IntervalType.CLOSED),
-        internal_upper_limit = Limit(11, IntervalType.OPEN)
-    )
-    ```
-
-    Decode an internal value:
-
-    ```python
-    >>> method.convert_internal_to_physical(6)  # == 4+2*6
-    16
-    ```
-
-    Encode a physical value:
-
-    ```python
-    >>> method.convert_physical_to_internal(6)  # == 6/2-2
-    1
-    ```
-
-    Get physical limits:
-
-    ```python
-    >>> method.physical_lower_limit
-    Limit(value=-16, interval_type=IntervalType.CLOSED)
-    >>> method.physical_upper_limit
-    Limit(value=26, interval_type=IntervalType.OPEN)
-    ```
-
-    (Note that there may be additional restrictions to valid physical values by the surrounding data object prop.
-    For example, limits given by the bit length are not considered in the compu method.)
-    """
-
-    offset: float
-    factor: float
-    denominator: float
-    internal_lower_limit: Limit
-    internal_upper_limit: Limit
+    """A compu method which does linear interpoation
 
-    def __post_init__(self) -> None:
-        odxassert(self.denominator > 0)
+    i.e. internal values are converted to physical ones using the
+    function `f(x) = (offset + factor * x)/denominator` where `f(x)`
+    is the physical value and `x` is the internal value. In contrast
+    to `ScaleLinearCompuMethod`, this compu method only exhibits a
+    single segment)
 
-        self.__compute_physical_limits()
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.3.
+    """
 
     @property
-    def category(self) -> CompuMethodCategory:
-        return "LINEAR"
+    def segment(self) -> LinearSegment:
+        return self._segment
 
-    @property
-    def physical_lower_limit(self) -> Limit:
-        return self._physical_lower_limit
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "LinearCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
 
-    @property
-    def physical_upper_limit(self) -> Limit:
-        return self._physical_upper_limit
-
-    def __compute_physical_limits(self) -> None:
-        """Computes the physical limits and stores them in the properties
-        self._physical_lower_limit and self._physical_upper_limit.
-        This method is only called during the initialization of a LinearCompuMethod.
-        """
-
-        def convert_to_limit_to_physical(limit: Limit, is_upper_limit: bool) -> Limit:
-            """Helper method
-
-            Parameters:
-
-            limit
-                the internal limit to be converted to a physical limit
-            is_upper_limit
-                True iff limit is the internal upper limit
-            """
-            odxassert(isinstance(limit.value, (int, float)))
-            if limit.interval_type == IntervalType.INFINITE:
-                return limit
-            elif (limit.interval_type == limit.interval_type.OPEN and
-                  self.internal_type.as_python_type() == int):
-                closed_limit = limit.value - 1 if is_upper_limit else limit.value + 1
-                return Limit(
-                    value=self._convert_internal_to_physical(closed_limit),
-                    interval_type=IntervalType.CLOSED,
-                )
-            else:
-                return Limit(
-                    value=self._convert_internal_to_physical(limit.value),
-                    interval_type=limit.interval_type,
-                )
-
-        if self.factor >= 0:
-            self._physical_lower_limit = convert_to_limit_to_physical(self.internal_lower_limit,
-                                                                      False)
-            self._physical_upper_limit = convert_to_limit_to_physical(self.internal_upper_limit,
-                                                                      True)
-        else:
-            # If the factor is negative, the lower and upper limit are swapped
-            self._physical_lower_limit = convert_to_limit_to_physical(self.internal_upper_limit,
-                                                                      True)
-            self._physical_upper_limit = convert_to_limit_to_physical(self.internal_lower_limit,
-                                                                      False)
-
-        if self.physical_type == DataType.A_UINT32:
-            # If the data type is unsigned, the physical lower limit should be at least 0.
-            if (self._physical_lower_limit.interval_type == IntervalType.INFINITE or
-                    cast(float, self._physical_lower_limit.value) < 0):
-                self._physical_lower_limit = Limit(value=0, interval_type=IntervalType.CLOSED)
-
-    def _convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
-        if not isinstance(internal_value, (int, float)):
-            raise DecodeError("The type of internal values of linear compumethods must "
-                              "either int or float")
-
-        if self.denominator is None:
-            result = self.offset + self.factor * internal_value
-        else:
-            result = (self.offset + self.factor * internal_value) / self.denominator
-
-        if self.internal_type == DataType.A_FLOAT64 and self.physical_type in [
-                DataType.A_INT32,
-                DataType.A_UINT32,
-        ]:
-            result = round(result)
-        return self.physical_type.make_from(result)
+        return LinearCompuMethod(**kwargs)
+
+    def __post_init__(self) -> None:
+        odxassert(self.category == CompuCategory.LINEAR,
+                  "LinearCompuMethod must exhibit LINEAR category")
+
+        odxassert(self.physical_type in [
+            DataType.A_FLOAT32,
+            DataType.A_FLOAT64,
+            DataType.A_INT32,
+            DataType.A_UINT32,
+        ])
+        odxassert(self.internal_type in [
+            DataType.A_FLOAT32,
+            DataType.A_FLOAT64,
+            DataType.A_INT32,
+            DataType.A_UINT32,
+        ])
+
+        if self.compu_internal_to_phys is None:
+            odxraise("LINEAR compu methods require COMPU-INTERNAL-TO-PHYS")
+            return
+
+        compu_scales = self.compu_internal_to_phys.compu_scales
+
+        if len(compu_scales) == 0:
+            odxraise("LINEAR compu methods expect at least one compu scale within "
+                     "COMPU-INTERNAL-TO-PHYS")
+            return cast(None, LinearCompuMethod)
+        elif len(compu_scales) > 1:
+            odxraise("LINEAR compu methods expect at most one compu scale within "
+                     "COMPU-INTERNAL-TO-PHYS")
+
+        scale = compu_scales[0]
+        self._segment = LinearSegment.from_compu_scale(
+            scale, internal_type=self.internal_type, physical_type=self.physical_type)
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
-        odxassert(self.is_valid_internal_value(internal_value))
-        return self._convert_internal_to_physical(internal_value)
+        if not self._segment.internal_applies(internal_value):
+            odxraise(f"Cannot decode internal value {internal_value!r}", DecodeError)
+
+        return self._segment.convert_internal_to_physical(internal_value)
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
-        if not isinstance(physical_value, (int, float)):
-            raise EncodeError("The type of physical values of linear compumethods must "
-                              "either int or float")
-
-        odxassert(
-            self.is_valid_physical_value(physical_value),
-            f"physical value {physical_value} of type {type(physical_value)} "
-            f"is not valid. Expected type {self.physical_type} with internal "
-            f"range {self.internal_lower_limit} to {self.internal_upper_limit}")
-        if self.denominator is None:
-            result = (physical_value - self.offset) / self.factor
-        else:
-            result = ((physical_value * self.denominator) - self.offset) / self.factor
-
-        if self.physical_type == DataType.A_FLOAT64 and self.internal_type in [
-                DataType.A_INT32,
-                DataType.A_UINT32,
-        ]:
-            result = round(result)
-        return self.internal_type.make_from(result)
+        if not self._segment.physical_applies(physical_value):
+            odxraise(f"Cannot decode physical value {physical_value!r}", EncodeError)
+
+        return self._segment.convert_physical_to_internal(physical_value)
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
-        # Do type checks
-        expected_type = self.physical_type.as_python_type()
-        if expected_type == float and not isinstance(physical_value, (int, float)):
-            return False
-        elif expected_type != float and not isinstance(physical_value, expected_type):
-            return False
-
-        # Compare to the limits
-        if not self.physical_lower_limit.complies_to_lower(physical_value):
-            return False
-        if not self.physical_upper_limit.complies_to_upper(physical_value):
-            return False
-        return True
+        return self._segment.physical_applies(physical_value)
 
     def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
-        expected_type = self.internal_type.as_python_type()
-        if expected_type == float and not isinstance(internal_value, (int, float)):
-            return False
-        elif expected_type != float and not isinstance(internal_value, expected_type):
-            return False
-
-        if not self.internal_lower_limit.complies_to_lower(internal_value):
-            return False
-        if not self.internal_upper_limit.complies_to_upper(internal_value):
-            return False
-
-        return True
+        return self._segment.internal_applies(internal_value)

odxtools/compumethods/linearsegment.py

@@ -0,0 +1,190 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from ..exceptions import odxraise, odxrequire
+from ..odxtypes import AtomicOdxType, DataType
+from .compuscale import CompuScale
+from .limit import Limit
+
+
+@dataclass
+class LinearSegment:
+    """Helper class to represent a segment of a piecewise-linear interpolation.
+
+    Multiple compu methods (LINEAR, SCALE-LINEAR, TAB-INTP) require
+    linear interpolation. This class centralizes the required
+    parameters for a single such segment. (The required parameters are
+    extracted from the respective compu method's
+    COMPU-INTERNAL-TO-PHYS objects. We do it this way because the
+    internal-to-phys objects are rather clunky to work with and
+    feature a lot of irrelevant information.)
+
+    """
+    offset: float
+    factor: float
+    denominator: float
+    internal_lower_limit: Optional[Limit]
+    internal_upper_limit: Optional[Limit]
+
+    inverse_value: Union[int, float]  # value used as inverse if factor is 0
+
+    internal_type: DataType
+    physical_type: DataType
+
+    @staticmethod
+    def from_compu_scale(scale: CompuScale, *, internal_type: DataType,
+                         physical_type: DataType) -> "LinearSegment":
+        coeffs = odxrequire(scale.compu_rational_coeffs)
+
+        offset = coeffs.numerators[0]
+        factor = 0 if len(coeffs.numerators) == 1 else coeffs.numerators[1]
+
+        denominator = 1.0
+        if len(coeffs.denominators) > 0:
+            denominator = coeffs.denominators[0]
+
+        inverse_value: Union[int, float] = 0
+        if scale.compu_inverse_value is not None:
+            x = odxrequire(scale.compu_inverse_value).value
+            if not isinstance(x, (int, float)):
+                odxraise(f"Non-numeric COMPU-INVERSE-VALUE specified ({x!r})")
+            inverse_value = x
+
+        internal_lower_limit = scale.lower_limit
+        internal_upper_limit = scale.upper_limit
+
+        return LinearSegment(
+            offset=offset,
+            factor=factor,
+            denominator=denominator,
+            internal_lower_limit=internal_lower_limit,
+            internal_upper_limit=internal_upper_limit,
+            inverse_value=inverse_value,
+            internal_type=internal_type,
+            physical_type=physical_type)
+
+    @property
+    def physical_lower_limit(self) -> Optional[Limit]:
+        return self._physical_lower_limit
+
+    @property
+    def physical_upper_limit(self) -> Optional[Limit]:
+        return self._physical_upper_limit
+
+    def __post_init__(self) -> None:
+        self.__compute_physical_limits()
+
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> Union[float, int]:
+        if not isinstance(internal_value, (int, float)):
+            odxraise(f"Internal values of linear compumethods must "
+                     f"either be int or float (is: {type(internal_value).__name__})")
+
+        result = (self.offset + self.factor * internal_value) / self.denominator
+
+        if self.physical_type in [
+                DataType.A_INT32,
+                DataType.A_UINT32,
+        ]:
+            result = round(result)
+
+        return result
+
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> Union[float, int]:
+        if not isinstance(physical_value, (int, float)):
+            odxraise(f"Physical values of linear compumethods must "
+                     f"either be int or float (is: {type(physical_value).__name__})")
+
+        if abs(self.factor) < 1e-10:
+            # "If factor = 0 then COMPU-INVERSE-VALUE shall be specified.
+            return self.inverse_value
+
+        result = (physical_value * self.denominator - self.offset) / self.factor
+
+        if self.internal_type in [
+                DataType.A_INT32,
+                DataType.A_UINT32,
+        ]:
+            result = round(result)
+
+        return result
+
+    def __compute_physical_limits(self) -> None:
+        """Computes the physical limits and stores them in the properties
+        self._physical_lower_limit and self._physical_upper_limit.
+        This method is called by `__post_init__()`.
+        """
+
+        def convert_internal_to_physical_limit(internal_limit: Optional[Limit]) -> Optional[Limit]:
+            """Helper method to convert a single internal limit
+            """
+            if internal_limit is None or internal_limit.value_raw is None:
+                return None
+
+            internal_value = self.internal_type.from_string(internal_limit.value_raw)
+            physical_value = self.convert_internal_to_physical(internal_value)
+
+            result = Limit(
+                value_raw=str(physical_value),
+                value_type=self.physical_type,
+                interval_type=internal_limit.interval_type)
+
+            return result
+
+        self._physical_lower_limit = None
+        self._physical_upper_limit = None
+
+        if self.factor >= 0:
+            self._physical_lower_limit = convert_internal_to_physical_limit(
+                self.internal_lower_limit)
+            self._physical_upper_limit = convert_internal_to_physical_limit(
+                self.internal_upper_limit)
+        else:
+            # If the scaling factor is negative, the lower and upper
+            # limit are swapped
+            self._physical_lower_limit = convert_internal_to_physical_limit(
+                self.internal_upper_limit)
+            self._physical_upper_limit = convert_internal_to_physical_limit(
+                self.internal_lower_limit)
+
+    def physical_applies(self, physical_value: AtomicOdxType) -> bool:
+        """Returns True iff the segment is applicable to a given physical value"""
+        # Do type checks
+        expected_type = self.physical_type.python_type
+        if issubclass(expected_type, float):
+            if not isinstance(physical_value, (int, float)):
+                return False
+        else:
+            if not isinstance(physical_value, expected_type):
+                return False
+
+        if self._physical_lower_limit is not None and \
+           not self._physical_lower_limit.complies_to_lower(physical_value):
+            return False
+
+        if self._physical_upper_limit is not None and \
+           not self._physical_upper_limit.complies_to_upper(physical_value):
+            return False
+
+        return True
+
+    def internal_applies(self, internal_value: AtomicOdxType) -> bool:
+        """Returns True iff the segment is applicable to a given internal value"""
+        # Do type checks
+        expected_type = self.internal_type.python_type
+        if issubclass(expected_type, float):
+            if not isinstance(internal_value, (int, float)):
+                return False
+        else:
+            if not isinstance(internal_value, expected_type):
+                return False
+
+        if self.internal_lower_limit is not None and \
+           not self.internal_lower_limit.complies_to_lower(internal_value):
+            return False
+
+        if self.internal_upper_limit is not None and \
+           not self.internal_upper_limit.complies_to_upper(internal_value):
+            return False
+
+        return True

odxtools/compumethods/ratfunccompumethod.py

@@ -0,0 +1,106 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, cast
+from xml.etree import ElementTree
+
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
+from .ratfuncsegment import RatFuncSegment
+
+
+@dataclass
+class RatFuncCompuMethod(CompuMethod):
+    """A compu method using a rational function
+
+    i.e. internal values are converted to physical ones using the
+    function `f(x) = (a0 + a1*x + a2*x^2 ...)/(b0 + b0*x^2 ...)` where `f(x)`
+    is the physical value and `x` is the internal value. In contrast
+    to `ScaleRatFuncCompuMethod`, this compu method only exhibits a
+    single segment)
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.5.
+    """
+
+    @property
+    def int_to_phys_segment(self) -> RatFuncSegment:
+        return self._int_to_phys_segment
+
+    @property
+    def phys_to_int_segment(self) -> Optional[RatFuncSegment]:
+        return self._phys_to_int_segment
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "RatFuncCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return RatFuncCompuMethod(**kwargs)
+
+    def __post_init__(self) -> None:
+        odxassert(self.category == CompuCategory.RAT_FUNC,
+                  "RatFuncCompuMethod must exhibit RAT-FUNC category")
+
+        odxassert(self.physical_type in [
+            DataType.A_FLOAT32,
+            DataType.A_FLOAT64,
+            DataType.A_INT32,
+            DataType.A_UINT32,
+        ])
+        odxassert(self.internal_type in [
+            DataType.A_FLOAT32,
+            DataType.A_FLOAT64,
+            DataType.A_INT32,
+            DataType.A_UINT32,
+        ])
+
+        if self.compu_internal_to_phys is None:
+            odxraise("RAT-FUNC compu methods require COMPU-INTERNAL-TO-PHYS")
+            return
+
+        int_to_phys_scales = self.compu_internal_to_phys.compu_scales
+        if len(int_to_phys_scales) != 1:
+            odxraise("RAT-FUNC compu methods expect exactly one compu scale within "
+                     "COMPU-INTERNAL-TO-PHYS")
+            return cast(None, RatFuncCompuMethod)
+
+        self._int_to_phys_segment = RatFuncSegment.from_compu_scale(
+            int_to_phys_scales[0], value_type=self.physical_type)
+
+        self._phys_to_int_segment = None
+        if self.compu_phys_to_internal is not None:
+            phys_to_int_scales = self.compu_phys_to_internal.compu_scales
+            if len(phys_to_int_scales) != 1:
+                odxraise("RAT-FUNC compu methods expect exactly one compu scale within "
+                         "COMPU-PHYS-TO-INTERNAL")
+                return cast(None, RatFuncCompuMethod)
+
+            self._phys_to_int_segment = RatFuncSegment.from_compu_scale(
+                phys_to_int_scales[0], value_type=self.internal_type)
+
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
+        if not self._int_to_phys_segment.applies(internal_value):
+            odxraise(f"Cannot decode internal value {internal_value!r}", DecodeError)
+            return cast(AtomicOdxType, None)
+
+        return self._int_to_phys_segment.convert(internal_value)
+
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        if self._phys_to_int_segment is None or not self._phys_to_int_segment.applies(
+                physical_value):
+            odxraise(f"Cannot encode physical value {physical_value!r}", EncodeError)
+            return cast(AtomicOdxType, None)
+
+        return self._phys_to_int_segment.convert(physical_value)
+
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
+        return self._phys_to_int_segment is not None and self._phys_to_int_segment.applies(
+            physical_value)
+
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
+        return self._int_to_phys_segment.applies(internal_value)

odxtools/compumethods/ratfuncsegment.py

@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, Union
+
+from ..exceptions import odxraise, odxrequire
+from ..odxtypes import AtomicOdxType, DataType
+from .compuscale import CompuScale
+from .limit import Limit
+
+
+@dataclass
+class RatFuncSegment:
+    """Helper class to represent a segment of a piecewise rational function.
+    """
+    value_type: DataType
+
+    numerator_coeffs: List[Union[int, float]]
+    denominator_coeffs: List[Union[int, float]]
+
+    lower_limit: Optional[Limit]
+    upper_limit: Optional[Limit]
+
+    @staticmethod
+    def from_compu_scale(scale: CompuScale, value_type: DataType) -> "RatFuncSegment":
+        coeffs = odxrequire(scale.compu_rational_coeffs,
+                            "Scales for rational functions must exhibit "
+                            "COMPU-RATIONAL-COEFFS")
+
+        numerator_coeffs = coeffs.numerators
+        denominator_coeffs = coeffs.denominators
+
+        lower_limit = scale.lower_limit
+        upper_limit = scale.upper_limit
+
+        return RatFuncSegment(
+            numerator_coeffs=numerator_coeffs,
+            denominator_coeffs=denominator_coeffs,
+            lower_limit=lower_limit,
+            upper_limit=upper_limit,
+            value_type=scale.range_type)
+
+    def convert(self, value: AtomicOdxType) -> Union[float, int]:
+        if not isinstance(value, (int, float)):
+            odxraise(f"Internal values of linear compumethods must "
+                     f"either be int or float (is: {type(value).__name__})")
+
+        numerator = 0.0
+        x = float(value)
+        for numerator_coeff in reversed(self.numerator_coeffs):
+            numerator *= x
+            numerator += float(numerator_coeff)
+
+        denominator = 0.0
+        for denominator_coeff in reversed(self.denominator_coeffs):
+            denominator *= x
+            denominator += float(denominator_coeff)
+
+        result = numerator / denominator
+
+        if self.value_type in [
+                DataType.A_INT32,
+                DataType.A_UINT32,
+        ]:
+            result = round(result)
+
+        return result
+
+    def applies(self, value: AtomicOdxType) -> bool:
+        """Returns True iff the segment is applicable to a given internal value"""
+        # Do type checks
+        expected_type = self.value_type.python_type
+        if issubclass(expected_type, float):
+            if not isinstance(value, (int, float)):
+                return False
+        else:
+            if not isinstance(value, expected_type):
+                return False
+
+        if self.lower_limit is not None and \
+           not self.lower_limit.complies_to_lower(value):
+            return False
+
+        if self.upper_limit is not None and \
+           not self.upper_limit.complies_to_upper(value):
+            return False
+
+        return True