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

odxtools/compumethods/scalelinearcompumethod.py

@@ -1,39 +1,145 @@
 # 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 odxassert
-from ..odxtypes import AtomicOdxType
-from .compumethod import CompuMethod, CompuMethodCategory
-from .linearcompumethod import LinearCompuMethod
+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 .limit import IntervalType
+from .linearsegment import LinearSegment
 
 
 @dataclass
 class ScaleLinearCompuMethod(CompuMethod):
-    linear_methods: List[LinearCompuMethod]
+    """A piecewise linear compu method which may feature discontinuities.
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.4.
+    """
 
     @property
-    def category(self) -> CompuMethodCategory:
-        return "SCALE-LINEAR"
-
-    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
-        odxassert(
-            self.is_valid_physical_value(physical_value),
-            f"cannot convert the invalid physical value {physical_value!r} "
-            f"of type {type(physical_value)}")
-        lin_method = next(
-            scale for scale in self.linear_methods if scale.is_valid_physical_value(physical_value))
-        return lin_method.convert_physical_to_internal(physical_value)
-
-    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
-        lin_method = next(
-            scale for scale in self.linear_methods if scale.is_valid_internal_value(internal_value))
-        return lin_method.convert_internal_to_physical(internal_value)
+    def segments(self) -> List[LinearSegment]:
+        return self._segments
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "ScaleLinearCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return ScaleLinearCompuMethod(**kwargs)
+
+    def __post_init__(self) -> None:
+        self._segments: List[LinearSegment] = []
+
+        odxassert(self.category == CompuCategory.SCALE_LINEAR,
+                  "ScaleLinearCompuMethod must exibit SCALE-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("SCALE-LINEAR compu methods require COMPU-INTERNAL-TO-PHYS")
+            return
+
+        compu_scales = self.compu_internal_to_phys.compu_scales
+
+        for scale in compu_scales:
+            self._segments.append(
+                LinearSegment.from_compu_scale(
+                    scale, internal_type=self.internal_type, physical_type=self.physical_type))
+
+        # find out if the transfer function is invertible (i.e. if it
+        # can be encoded by normal means). section 7.3.6.6.4 of the
+        # ODX specification states that the condition for
+        # invertibility is that adjacent COMPU-SCALES exhibit the same
+        # values on their common boundaries and that the slope in all
+        # intervals exhibit the same sign (or are 0). For segments
+        # with a slope of zero, COMPU-INVERSE-VALUE shall be used.
+        self._is_invertible = True
+        ref_factor = self._segments[0].factor
+        for i in range(0, len(self._segments) - 1):
+            s0 = self.segments[i]
+            s1 = self.segments[i + 1]
+
+            if ref_factor * s1.factor < 0:
+                self._is_invertible = False
+                break
+            if s1.factor != 0:
+                ref_factor = s1.factor
+
+            # both interval boundaries must not be infinite
+            if s0.internal_upper_limit is None or \
+               s1.internal_lower_limit is None:
+                self._is_invertible = False
+                break
+            elif s0.internal_upper_limit.value is None or \
+               s1.internal_lower_limit.value is None or \
+               s0.internal_upper_limit.interval_type == IntervalType.INFINITE or \
+               s1.internal_lower_limit.interval_type == IntervalType.INFINITE:
+                self._is_invertible = False
+                break
+
+            # the intervals must use the same reference point
+            if (x := s0.internal_upper_limit.value) != s1.internal_lower_limit.value:
+                self._is_invertible = False
+                break
+
+            if not isinstance(x, (int, float)):
+                odxraise("Linear segments must use int or float for all quantities")
+
+            # the respective function value at the interval's
+            # reference point must be identical
+            y0 = s0.convert_internal_to_physical(x)
+            y1 = s1.convert_internal_to_physical(x)
+            if abs(y0 - y1) < 1e-10:
+                self._is_invertible = False
+                break
+
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> Union[float, int]:
+        if not self._is_invertible:
+            odxraise(
+                f"Trying to encode value {physical_value!r} using a non-invertible "
+                f"SCALE-LINEAR transfer function", EncodeError)
+
+        applicable_segments = [
+            seg for seg in self._segments if seg.physical_applies(physical_value)
+        ]
+        if not applicable_segments:
+            odxraise(r"No applicable segment for value {physical_value} found", EncodeError)
+            return cast(int, None)
+
+        seg = applicable_segments[0]
+
+        return seg.convert_physical_to_internal(physical_value)
+
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> Union[float, int]:
+        applicable_segments = [
+            seg for seg in self._segments if seg.internal_applies(internal_value)
+        ]
+        if not applicable_segments:
+            odxraise(r"No applicable segment for value {internal_value} found", DecodeError)
+            return cast(int, None)
+
+        seg = applicable_segments[0]
+        return seg.convert_internal_to_physical(internal_value)
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
-        return any(
-            True for scale in self.linear_methods if scale.is_valid_physical_value(physical_value))
+        return any(True for seg in self._segments if seg.physical_applies(physical_value))
 
     def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
-        return any(
-            True for scale in self.linear_methods if scale.is_valid_internal_value(internal_value))
+        return any(True for seg in self._segments if seg.internal_applies(internal_value))

odxtools/compumethods/scaleratfunccompumethod.py

@@ -0,0 +1,113 @@
+# 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 ScaleRatFuncCompuMethod(CompuMethod):
+    """A compu method using a piecewise rational function
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.5.
+    """
+
+    @property
+    def int_to_phys_segments(self) -> List[RatFuncSegment]:
+        return self._int_to_phys_segments
+
+    @property
+    def phys_to_int_segments(self) -> Optional[List[RatFuncSegment]]:
+        return self._phys_to_int_segments
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "ScaleRatFuncCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return ScaleRatFuncCompuMethod(**kwargs)
+
+    def __post_init__(self) -> None:
+        odxassert(self.category == CompuCategory.SCALE_RAT_FUNC,
+                  "ScaleRatFuncCompuMethod must exhibit SCALE-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 at least one compu scale within "
+                     "COMPU-INTERNAL-TO-PHYS")
+            return
+
+        self._int_to_phys_segments = [
+            RatFuncSegment.from_compu_scale(scale, value_type=self.physical_type)
+            for scale in int_to_phys_scales
+        ]
+
+        self._phys_to_int_segments = 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("SCALE-RAT-FUNC compu methods expect at least one compu scale within "
+                         "COMPU-PHYS-TO-INTERNAL")
+                return
+
+            self._phys_to_int_segments = [
+                RatFuncSegment.from_compu_scale(scale, value_type=self.internal_type)
+                for scale in phys_to_int_scales
+            ]
+
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
+        for seg in self._int_to_phys_segments:
+            if seg.applies(internal_value):
+                return seg.convert(internal_value)
+
+        odxraise(f"Internal value {internal_value!r} be decoded using this compumethod",
+                 DecodeError)
+        return cast(AtomicOdxType, None)
+
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        if self._phys_to_int_segments is None:
+            odxraise(f"Physical values cannot be encoded using this compumethod", EncodeError)
+            return cast(AtomicOdxType, None)
+
+        for seg in self._phys_to_int_segments:
+            if seg.applies(physical_value):
+                return seg.convert(physical_value)
+
+        odxraise(f"Physical values {physical_value!r} be decoded using this compumethod",
+                 EncodeError)
+        return cast(AtomicOdxType, None)
+
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
+        return any(seg.applies(internal_value) for seg in self._int_to_phys_segments)
+
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
+        if self._phys_to_int_segments is None:
+            return False
+
+        return any(seg.applies(physical_value) for seg in self._phys_to_int_segments)

odxtools/compumethods/tabintpcompumethod.py

@@ -1,107 +1,114 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Tuple, Union
+from typing import List, Union
+from xml.etree import ElementTree
 
-from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from ..odxlink import OdxDocFragment
 from ..odxtypes import AtomicOdxType, DataType
-from .compumethod import CompuMethod, CompuMethodCategory
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
 from .limit import IntervalType, Limit
 
 
 @dataclass
 class TabIntpCompuMethod(CompuMethod):
-    """
-    A compu method of type Tab Interpolated is used for linear interpolation.
-
-    A `TabIntpCompuMethod` is defined by a set of points. Each point is an (internal, physical) value pair.
-    When converting from internal to physical or vice-versa, the result is linearly interpolated.
-
-    The function defined by a `TabIntpCompuMethod` is similar to the one of a `ScaleLinearCompuMethod` with the following differences:
-
-    * `TabIntpCompuMethod`s are always continuous whereas `ScaleLinearCompuMethod` might have jumps
-    * `TabIntpCompuMethod`s are always invertible: Even if the linear interpolation is not monotonic, the first matching interval is taken.
-
-    Refer to ASAM MCD-2 D (ODX) Specification, section 7.3.6.6.8 for details.
-
-    Examples
-    --------
-
-    Create a TabIntpCompuMethod defined by the points (0, -1), (10, 1), (30, 2)::
-
-        method = TabIntpCompuMethod(
-            internal_type=DataType.A_UINT32,
-            physical_type=DataType.A_UINT32,
-            internal_points=[0, 10, 30],
-            physical_points=[-1, 1, 2]
-        )
-
-    Note that the points are given as two lists. The equivalent odx definition is::
-
-        <COMPU-METHOD>
-            <CATEGORY>TAB-INTP</CATEGORY>
-            <COMPU-INTERNAL-TO-PHYS>
-                <COMPU-SCALES>
-                    <COMPU-SCALE>
-                        <LOWER-LIMIT INTERVAL-TYPE = "CLOSED">0</LOWER-LIMIT>
-                        <COMPU-CONST>
-                            <V>-1</V>
-                        </COMPU-CONST>
-                    </COMPU-SCALE>
-                    <COMPU-SCALE>
-                        <LOWER-LIMIT INTERVAL-TYPE = "CLOSED">10</LOWER-LIMIT>
-                        <COMPU-CONST>
-                            <V>1</V>
-                        </COMPU-CONST>
-                    </COMPU-SCALE>
-                    <COMPU-SCALE>
-                        <LOWER-LIMIT INTERVAL-TYPE = "CLOSED">30</LOWER-LIMIT>
-                        <COMPU-CONST>
-                            <V>2</V>
-                        </COMPU-CONST>
-                    </COMPU-SCALE>
-                </COMPU-SCALES>
-            </COMPU-INTERNAL-TO-PHYS>
-        </COMPU-METHOD>
+    """A table-based interpolated compu method provides a continuous
+    transfer function based on piecewise linear interpolation.
+
+    A `TabIntpCompuMethod` is defined by a set of points. Each point
+    is an (internal, physical) value pair.  When converting from
+    internal to physical or vice-versa, the result is linearly
+    interpolated.
+
+    The function defined by a `TabIntpCompuMethod` is similar to the
+    one of a `ScaleLinearCompuMethod` with the following differences:
+
+    * `TabIntpCompuMethod`s are always continuous whereas
+      `ScaleLinearCompuMethod` might exhibit gaps
+    * `TabIntpCompuMethod`s are always invertible: Even if the linear
+      interpolation is not monotonic, the first matching interval is
+      used.
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.8.
 
     """
 
-    internal_points: List[Union[float, int]]
-    physical_points: List[Union[float, int]]
+    @property
+    def internal_points(self) -> List[Union[float, int]]:
+        return self._internal_points
+
+    @property
+    def physical_points(self) -> List[Union[float, int]]:
+        return self._physical_points
+
+    @property
+    def internal_lower_limit(self) -> Limit:
+        return self._internal_lower_limit
+
+    @property
+    def internal_upper_limit(self) -> Limit:
+        return self._internal_upper_limit
+
+    @property
+    def physical_lower_limit(self) -> Limit:
+        return self._physical_lower_limit
+
+    @property
+    def physical_upper_limit(self) -> Limit:
+        return self._physical_upper_limit
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "TabIntpCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return TabIntpCompuMethod(**kwargs)
 
     def __post_init__(self) -> None:
+        odxassert(self.category == CompuCategory.TAB_INTP,
+                  "TabIntpCompuMethod must exibit TAB-INTP category")
+
+        self._internal_points: List[Union[int, float]] = []
+        self._physical_points: List[Union[int, float]] = []
+        for scale in odxrequire(self.compu_internal_to_phys).compu_scales:
+            internal_point = odxrequire(scale.lower_limit).value
+            physical_point = odxrequire(scale.compu_const).value
+
+            if not isinstance(internal_point, (float, int)):
+                odxraise("The type of values of tab-intp compumethods must "
+                         "either int or float")
+            if not isinstance(physical_point, (float, int)):
+                odxraise("The type of values of tab-intp compumethods must "
+                         "either int or float")
+
+            self._internal_points.append(internal_point)
+            self._physical_points.append(physical_point)
+
         self._physical_lower_limit = Limit(
-            value_raw=str(min(self.physical_points)),
+            value_raw=str(min(self._physical_points)),
             value_type=self.physical_type,
             interval_type=IntervalType.CLOSED)
         self._physical_upper_limit = Limit(
-            value_raw=str(max(self.physical_points)),
+            value_raw=str(max(self._physical_points)),
             value_type=self.physical_type,
             interval_type=IntervalType.CLOSED)
 
         self._internal_lower_limit = Limit(
-            value_raw=str(min(self.internal_points)),
+            value_raw=str(min(self._internal_points)),
             value_type=self.internal_type,
             interval_type=IntervalType.CLOSED)
         self._internal_upper_limit = Limit(
-            value_raw=str(max(self.internal_points)),
+            value_raw=str(max(self._internal_points)),
             value_type=self.internal_type,
             interval_type=IntervalType.CLOSED)
 
-        self._assert_validity()
-
-    @property
-    def category(self) -> CompuMethodCategory:
-        return "TAB-INTP"
-
-    @property
-    def physical_lower_limit(self) -> Limit:
-        return self._physical_lower_limit
+        self.__assert_validity()
 
-    @property
-    def physical_upper_limit(self) -> Limit:
-        return self._physical_upper_limit
-
-    def _assert_validity(self) -> None:
+    def __assert_validity(self) -> None:
         odxassert(len(self.internal_points) == len(self.physical_points))
 
         odxassert(
@@ -110,7 +117,7 @@ class TabIntpCompuMethod(CompuMethod):
                 DataType.A_UINT32,
                 DataType.A_FLOAT32,
                 DataType.A_FLOAT64,
-            ], "Internal data type of tab-intp compumethod must be one of"
+            ], "Internal data type of TAB-INTP compumethod must be one of"
             " [A_INT32, A_UINT32, A_FLOAT32, A_FLOAT64]")
         odxassert(
             self.physical_type in [
@@ -118,51 +125,64 @@ class TabIntpCompuMethod(CompuMethod):
                 DataType.A_UINT32,
                 DataType.A_FLOAT32,
                 DataType.A_FLOAT64,
-            ], "Physical data type of tab-intp compumethod must be one of"
+            ], "Physical data type of TAB-INTP compumethod must be one of"
             " [A_INT32, A_UINT32, A_FLOAT32, A_FLOAT64]")
 
-    def _piecewise_linear_interpolate(self, x: Union[int, float],
-                                      points: List[Tuple[Union[int, float],
-                                                         Union[int, float]]]) -> Union[float, None]:
-        for ((x0, y0), (x1, y1)) in zip(points[:-1], points[1:]):
-            if x0 <= x and x <= x1:
+    def __piecewise_linear_interpolate(self, x: Union[int, float],
+                                       range_samples: List[Union[int, float]],
+                                       domain_samples: List[Union[int,
+                                                                  float]]) -> Union[float, None]:
+        for i in range(0, len(range_samples) - 1):
+            if (x0 := range_samples[i]) <= x and x <= (x1 := range_samples[i + 1]):
+                y0 = domain_samples[i]
+                y1 = domain_samples[i + 1]
                 return y0 + (x - x0) * (y1 - y0) / (x1 - x0)
 
         return None
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         if not isinstance(physical_value, (int, float)):
-            raise EncodeError("The type of values of tab-intp compumethods must "
-                              "either int or float")
+            odxraise("The type of values of tab-intp compumethods must "
+                     "either int or float", EncodeError)
+            return None
 
-        reference_points = list(zip(self.physical_points, self.internal_points))
         odxassert(
             isinstance(physical_value, (int, float)),
-            "Only integers and floats can be piecewise linearly interpolated")
-        result = self._piecewise_linear_interpolate(physical_value, reference_points)
+            "Only integers and floats can be piecewise linearly interpolated", EncodeError)
+        result = self.__piecewise_linear_interpolate(physical_value, self._physical_points,
+                                                     self._internal_points)
 
         if result is None:
-            raise EncodeError(f"Internal value {physical_value!r} must be inside the range"
-                              f" [{min(self.physical_points)}, {max(self.physical_points)}]")
+            odxraise(
+                f"Internal value {physical_value!r} must be inside the range"
+                f" [{min(self.physical_points)}, {max(self.physical_points)}]", EncodeError)
+
         res = self.internal_type.make_from(result)
-        if not isinstance(res, (int, float)):
-            odxraise()
+
         return res
 
     def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
         if not isinstance(internal_value, (int, float)):
-            raise EncodeError("The internal type of values of tab-intp compumethods must "
-                              "either int or float")
+            odxraise(
+                "The internal type of values of tab-intp compumethods must "
+                "either int or float", EncodeError)
+            return None
+
+        odxassert(
+            isinstance(internal_value, (int, float)),
+            "Only integers and floats can be piecewise linearly interpolated", DecodeError)
 
-        reference_points = list(zip(self.internal_points, self.physical_points))
-        result = self._piecewise_linear_interpolate(internal_value, reference_points)
+        result = self.__piecewise_linear_interpolate(internal_value, self._internal_points,
+                                                     self._physical_points)
 
         if result is None:
-            raise DecodeError(f"Internal value {internal_value!r} must be inside the range"
-                              f" [{min(self.internal_points)}, {max(self.internal_points)}]")
+            odxraise(
+                f"Internal value {internal_value!r} must be inside the range"
+                f" [{min(self.internal_points)}, {max(self.internal_points)}]", DecodeError)
+            return None
+
         res = self.physical_type.make_from(result)
-        if not isinstance(res, (int, float)):
-            odxraise()
+
         return res
 
     def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool: