Fix potential error caused by floating point errors

Author: ageiss2

extrap/gui/GraphWidget.py

@@ -16,7 +16,6 @@
 from PySide6.QtCore import *  # @UnusedWildImport
 from PySide6.QtGui import *  # @UnusedWildImport
 from PySide6.QtWidgets import *  # @UnusedWildImport
-
 from extrap.gui.Utils import formatFormula
 from extrap.gui.Utils import formatNumber
 from extrap.gui.plots.AbstractPlotWidget import AbstractPlotWidget
@@ -569,9 +568,8 @@ def calculate_function(self, function, length_x_axis, x_min=None, x_max=None):
             number_of_x_points, x_list, x_values = self._calculate_evaluation_points(length_x_axis, x_min, x_max)
         else:
             number_of_x_points, x_list, x_values = self._calculate_evaluation_points(length_x_axis)
-        previous = numpy.seterr(invalid='ignore', divide='ignore')
-        y_list = function.evaluate(x_list).reshape(-1)
-        numpy.seterr(**previous)
+        with numpy.errstate(invalid='ignore', divide='ignore'):
+            y_list = function.evaluate(x_list).reshape(-1)
         cord_list = self._create_drawing_iterator(x_values, y_list)
 
         return cord_list
@@ -585,10 +583,9 @@ def calculate_aggregate_callpath_function(self, functions, length_x_axis):
 
         y_list = numpy.zeros(number_of_x_points)
 
-        previous = numpy.seterr(invalid='ignore', divide='ignore')
-        for function in functions:
-            y_list += function.evaluate(x_list).reshape(-1)
-        numpy.seterr(**previous)
+        with numpy.errstate(invalid='ignore', divide='ignore'):
+            for function in functions:
+                y_list += function.evaluate(x_list).reshape(-1)
 
         cord_list = self._create_drawing_iterator(x_values, y_list)
 
@@ -741,43 +738,41 @@ def calculateMaxY(self, modelList):
                 y = max(model.predictions)
                 y_max = max(y, y_max)
 
-        previous = numpy.seterr(invalid='ignore', divide='ignore')
-
-        if self.combine_all_callpath:
-            y_agg = 0
+        with numpy.errstate(invalid='ignore', divide='ignore'):
+            if self.combine_all_callpath:
+                y_agg = 0
+                for model in modelList:
+                    function = model.hypothesis.function
+                    y_agg = y_agg + function.evaluate(pv_list)
+                y_max = max(y_agg, y_max)
+
+                pv_list[param] = 1
+                y_agg = 0
+                for model in modelList:
+                    function = model.hypothesis.function
+                    y = function.evaluate(pv_list)
+                    if math.isinf(y):
+                        y = max(model.predictions)
+                    y_agg += y
+                y_max = max(y_agg, y_max)
+
+            # Check the value at the end of the displayed interval
             for model in modelList:
                 function = model.hypothesis.function
-                y_agg = y_agg + function.evaluate(pv_list)
-            y_max = max(y_agg, y_max)
+                y = function.evaluate(pv_list)
+                if math.isinf(y):
+                    y = max(model.predictions)
+                y_max = max(y, y_max)
 
+            # Check the value at the beginning of the displayed interval
             pv_list[param] = 1
-            y_agg = 0
             for model in modelList:
                 function = model.hypothesis.function
                 y = function.evaluate(pv_list)
                 if math.isinf(y):
                     y = max(model.predictions)
-                y_agg += y
-            y_max = max(y_agg, y_max)
-
-        # Check the value at the end of the displayed interval
-        for model in modelList:
-            function = model.hypothesis.function
-            y = function.evaluate(pv_list)
-            if math.isinf(y):
-                y = max(model.predictions)
-            y_max = max(y, y_max)
-
-        # Check the value at the beginning of the displayed interval
-        pv_list[param] = 1
-        for model in modelList:
-            function = model.hypothesis.function
-            y = function.evaluate(pv_list)
-            if math.isinf(y):
-                y = max(model.predictions)
-            y_max = max(y, y_max)
+                y_max = max(y, y_max)
 
-        numpy.seterr(**previous)
         # Ensure that the maximum value is never too small
         if y_max < 0.000001:
             y_max = 1

extrap/gui/SelectorWidget.py

@@ -11,9 +11,7 @@
 from typing import Optional, Sequence, TYPE_CHECKING, Tuple
 
 import numpy
-from PySide6.QtCore import Slot
 from PySide6.QtWidgets import *  # @UnusedWildImport
-
 from extrap.entities.calltree import Node
 from extrap.entities.metric import Metric
 from extrap.entities.model import Model
@@ -346,9 +344,9 @@ def update_min_max_value(self):
                 param_value_list = self.getParameterValues()
                 call_tree = experiment.call_tree
                 nodes = call_tree.get_nodes()
-                previous = numpy.seterr(divide='ignore', invalid='ignore')
-                value_list = self.iterate_children(model_set.models, param_value_list, nodes, selected_metric)
-                numpy.seterr(**previous)
+                with numpy.errstate(divide='ignore', invalid='ignore'):
+                    value_list = self.iterate_children(model_set.models, param_value_list, nodes, selected_metric)
+
                 if len(value_list) > 0:
                     min_max_value = max(0.0, min(value_list)), max(0.0, max(value_list))
         self.min_value, self.max_value = min_max_value

extrap/gui/TreeModel.py

@@ -8,11 +8,11 @@
 from __future__ import annotations
 
 import copy
-import numpy
-from PySide6.QtCore import *  # @UnusedWildImport
 from enum import Enum, auto
 from typing import Optional, TYPE_CHECKING, List, Callable, Any
 
+import numpy
+from PySide6.QtCore import *  # @UnusedWildImport
 from extrap.entities import calltree
 from extrap.entities.calltree import CallTree, Node
 from extrap.entities.experiment import Experiment
@@ -148,12 +148,13 @@ def data(self, index, role=None):
                 return formatFormula(formula.to_string(*parameters))
             else:
                 parameters = self.selector_widget.getParameterValues()
-                previous = numpy.seterr(divide='ignore', invalid='ignore')
-                if role == Qt.ToolTipRole and isinstance(model, SegmentedModel):
-                    res = _format_number_segmented_model(model, lambda m: m.hypothesis.function.evaluate(parameters))
-                else:
-                    res = formatNumber(str(formula.evaluate(parameters)))
-                numpy.seterr(**previous)
+                with numpy.errstate(divide='ignore', invalid='ignore'):
+                    if role == Qt.ToolTipRole and isinstance(model, SegmentedModel):
+                        res = _format_number_segmented_model(model,
+                                                             lambda m: m.hypothesis.function.evaluate(parameters))
+                    else:
+                        res = formatNumber(str(formula.evaluate(parameters)))
+
                 return res
         elif index.column() == 4:
             if role == Qt.ToolTipRole and isinstance(model, SegmentedModel):
@@ -180,9 +181,8 @@ def data(self, index, role=None):
     def get_comparison_value(self, model):
         parameters = self.selector_widget.getParameterValues()
         formula = model.hypothesis.function
-        previous = numpy.seterr(divide='ignore', invalid='ignore')
-        value = formula.evaluate(parameters)
-        numpy.seterr(**previous)
+        with numpy.errstate(divide='ignore', invalid='ignore'):
+            value = formula.evaluate(parameters)
         return value
 
     def getSelectedModel(self, callpath) -> tuple[Optional[Model], Experiment]:

extrap/gui/plots/BaseGraphWidget.py

@@ -13,13 +13,12 @@
 import matplotlib
 import numpy as np
 from PySide6.QtWidgets import QSizePolicy
+from extrap.util.formatting_helper import replace_method_parameters
 from matplotlib import patches as mpatches
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 from mpl_toolkits.mplot3d import Axes3D
 
-from extrap.util.formatting_helper import replace_method_parameters
-
 if TYPE_CHECKING:
     from extrap.gui.MainWidget import MainWidget
 
@@ -105,15 +104,14 @@ def calculate_z_models(self, maxX, maxY, model_list, max_z=0):
         # Get the z value for the x and y value
         z_List = list()
         Z_List = list()
-        previous = np.seterr(invalid='ignore', divide='ignore')
-        for model in model_list:
-            function = model.hypothesis.function
-            zs = self.calculate_z_optimized(X, Y, function)
-            Z = zs.reshape(X.shape)
-            z_List.append(zs)
-            Z_List.append(Z)
-            max_z = max(max_z, np.max(zs[np.logical_not(np.isinf(zs))]))
-        np.seterr(**previous)
+        with np.errstate(invalid='ignore', divide='ignore'):
+            for model in model_list:
+                function = model.hypothesis.function
+                zs = self.calculate_z_optimized(X, Y, function)
+                Z = zs.reshape(X.shape)
+                z_List.append(zs)
+                Z_List.append(Z)
+                max_z = max(max_z, np.max(zs[np.logical_not(np.isinf(zs))]))
         for z, Z in zip(z_List, Z_List):
             z[np.isinf(z)] = max_z
             Z[np.isinf(Z)] = max_z

extrap/modelers/multi_parameter/multi_parameter_modeler.py

@@ -11,7 +11,6 @@
 from typing import Sequence
 
 import numpy as np
-
 from extrap.entities.coordinate import Coordinate
 from extrap.entities.functions import ConstantFunction
 from extrap.entities.functions import MultiParameterFunction
@@ -142,10 +141,9 @@ def make_measurement(c, ms: Sequence[Measurement]):
             warnings.warn(f"Could not use all measurement points. At least {self.min_measurement_points ** 2} "
                           f"measurements are needed; one for each combination of parameters.")
 
-        previous = np.seterr(invalid='ignore')
-        combined_measurements = [[make_measurement(c, ms) for c, ms in grp.items() if ms]
-                                 for p, grp in enumerate(result_groups)]
-        np.seterr(**previous)
+        with np.errstate(invalid='ignore'):
+            combined_measurements = [[make_measurement(c, ms) for c, ms in grp.items() if ms]
+                                     for p, grp in enumerate(result_groups)]
 
         return combined_measurements
 

extrap/modelers/single_parameter/abstract_base.py

@@ -50,13 +50,13 @@ def compare_hypotheses(self, old: Hypothesis, new: SingleParameterHypothesis, me
         # get the compound terms of the new hypothesis
         compound_terms = new.function.compound_terms
 
-        previous = numpy.seterr(divide='ignore', invalid='ignore')
-        # for all compound terms check if they are smaller than minimum allowed contribution
-        for term in compound_terms:
-            # ignore this hypothesis, since one of the terms contributes less than epsilon to the function
-            if term.coefficient == 0 or new.calc_term_contribution(term, measurements) < self.epsilon:
-                return False
-        numpy.seterr(**previous)
+        with numpy.errstate(divide='ignore', invalid='ignore'):
+            # for all compound terms check if they are smaller than minimum allowed contribution
+            for term in compound_terms:
+                # ignore this hypothesis, since one of the terms contributes less than epsilon to the function
+                if (term.coefficient == 0
+                        or new.calc_term_contribution(term, measurements) < self.minimum_term_contribution):
+                    return False
 
         # print smapes in debug mode
         logging.debug("next hypothesis SMAPE: %g RSS: %g", new.SMAPE, new.RSS)