correcting minmax for Table implementation

Author: yasserfarouk

src/negmas/helpers/misc.py

@@ -147,14 +147,17 @@ def nonmonotonic_minmax(
     input: Iterable, f: Callable[[Any], float]
 ) -> tuple[float, float]:
     """Finds the limits of a function `f` for the input assuming that it is non-monotonic and input is iterable"""
-    mn, mx = float("inf"), float("-inf")
-    fmn, fmx = float("-inf"), float("inf")
-    for x in input:
+    _mn, _mx = None, None
+    vals = [_ for _ in input]
+    if not vals:
+        return float("nan"), float("nan")
+    fmn, fmx = float("inf"), float("-inf")
+    for x in vals:
         fx = float(f(x))
-        if fx < mn:
-            mn, fmn = x, fx
-        if fx > mx:
-            mx, fmx = x, fx
+        if fx < fmn:
+            _mn, fmn = x, fx
+        if fx > fmx:
+            _mx, fmx = x, fx
     return fmn, fmx
 
 

src/negmas/inout.py

@@ -599,7 +599,9 @@ def from_genius_folder(
         return s.load_info(path)
 
     @classmethod
-    def load(cls, folder: Path | str, safe_parsing=False) -> Scenario | None:
+    def load(
+        cls, folder: Path | str, safe_parsing=False, ignore_discount=False, **kwargs
+    ) -> Scenario | None:
         """
         Loads the scenario from a folder with supported formats: XML, YML
         """
@@ -610,7 +612,12 @@ def load(cls, folder: Path | str, safe_parsing=False) -> Scenario | None:
         ):
             domain, _ = finder(folder)
             if domain is not None:
-                s = loader(folder, safe_parsing=safe_parsing)
+                s = loader(
+                    folder,
+                    safe_parsing=safe_parsing,
+                    ignore_discount=ignore_discount,
+                    **kwargs,
+                )
                 if s is not None:
                     return s.load_info(folder)
 

src/negmas/preferences/value_fun.py

@@ -85,7 +85,6 @@ class TableFun(BaseFun):
     def minmax(self, input: Issue) -> tuple[float, float]:
         return self._minmax(input)
 
-    @lru_cache
     def _minmax(self, input: Issue) -> tuple[float, float]:
         return nonmonotonic_minmax(input, self)
 
@@ -111,13 +110,11 @@ def xml(self, indx: int, issue: Issue, bias=0.0) -> str:
             if issue.is_float()
             else "discrete"
         )
-        output = f'<issue index="{indx+1}" etype="{dtype}" type="{dtype}" vtype="{vtype}" name="{issue_name}">\n'
+        output = f'<issue index="{indx + 1}" etype="{dtype}" type="{dtype}" vtype="{vtype}" name="{issue_name}">\n'
         vals = issue.all
         for i, issue_value in enumerate(vals):
             uu = self(issue_value) + bias
-            output += (
-                f'    <item index="{i+1}" value="{issue_value}" evaluation="{uu}" />\n'
-            )
+            output += f'    <item index="{i + 1}" value="{issue_value}" evaluation="{uu}" />\n'
         output += "</issue>\n"
         return output
 
@@ -147,7 +144,7 @@ def xml(self, indx: int, issue: Issue, bias=0.0) -> str:
         issue_name = issue.name
         if issue.is_continuous():
             output = f'<issue index="{indx + 1}" etype="real" type="real" vtype="real" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="linear" parameter0="{bias+self.bias}" parameter1="{self.slope}"></evaluator>\n'
+            output += f'    <evaluator ftype="linear" parameter0="{bias + self.bias}" parameter1="{self.slope}"></evaluator>\n'
         # elif isinstance(issue, ContiguousIssue) and issue.cardinality > 50_000:
         #     output = f'<issue index="{indx + 1}" etype="real" type="integer" vtype="integer" name="{issue_name}">\n'
         #     output += f'    <evaluator ftype="linear" parameter0="{bias+self.bias}" parameter1="{self.slope}"></evaluator>\n'
@@ -329,10 +326,10 @@ def xml(self, indx: int, issue: Issue, bias) -> str:
         issue_name = issue.name
         if issue.is_continuous():
             output = f'<issue index="{indx + 1}" etype="real" type="real" vtype="real" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="quadratic" parameter0="{bias+self.bias}" parameter1="{self.a1} parameter2={self.a2}"></evaluator>\n'
+            output += f'    <evaluator ftype="quadratic" parameter0="{bias + self.bias}" parameter1="{self.a1} parameter2={self.a2}"></evaluator>\n'
         elif isinstance(issue, ContiguousIssue):
             output = f'<issue index="{indx + 1}" etype="integer" type="integer" vtype="integer" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="quadratic" parameter0="{bias+self.bias}" parameter1="{self.a1} parameter2={self.a2}"></evaluator>\n'
+            output += f'    <evaluator ftype="quadratic" parameter0="{bias + self.bias}" parameter1="{self.a1} parameter2={self.a2}"></evaluator>\n'
         else:
             vals = list(issue.all)
             return TableFun(dict(zip(vals, [self(_) for _ in vals]))).xml(
@@ -372,14 +369,18 @@ def xml(self, indx: int, issue: Issue, bias) -> str:
         issue_name = issue.name
         if issue.is_continuous():
             output = f'<issue index="{indx + 1}" etype="real" type="real" vtype="real" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="poynomial" parameter0="{bias+self.bias}"'
+            output += (
+                f'    <evaluator ftype="poynomial" parameter0="{bias + self.bias}"'
+            )
             for i, x in enumerate(self.coefficients):
                 output += f'parameter{i}="{x}"'
 
             output += "></evaluator>\n"
         elif isinstance(issue, ContiguousIssue):
             output = f'<issue index="{indx + 1}" etype="integer" type="integer" vtype="integer" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="poynomial" parameter0="{bias+self.bias}"'
+            output += (
+                f'    <evaluator ftype="poynomial" parameter0="{bias + self.bias}"'
+            )
             for i, x in enumerate(self.coefficients):
                 output += f'parameter{i}="{x}"'
 
@@ -478,10 +479,10 @@ def xml(self, indx: int, issue: Issue, bias) -> str:
         issue_name = issue.name
         if issue.is_continuous():
             output = f'<issue index="{indx + 1}" etype="real" type="real" vtype="real" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="exponential" parameter0="{bias+self.bias}" parameter1="{self.tau} parameter2={self.base}"></evaluator>\n'
+            output += f'    <evaluator ftype="exponential" parameter0="{bias + self.bias}" parameter1="{self.tau} parameter2={self.base}"></evaluator>\n'
         elif isinstance(issue, ContiguousIssue):
             output = f'<issue index="{indx + 1}" etype="integer" type="integer" vtype="integer" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="exponential" parameter0="{bias+self.bias}" parameter1="{self.tau} parameter2={self.base}"></evaluator>\n'
+            output += f'    <evaluator ftype="exponential" parameter0="{bias + self.bias}" parameter1="{self.tau} parameter2={self.base}"></evaluator>\n'
         else:
             vals = list(issue.all)
             return TableFun(dict(zip(vals, [self(_) for _ in vals]))).xml(
@@ -530,10 +531,10 @@ def xml(self, indx: int, issue: Issue, bias) -> str:
         issue_name = issue.name
         if issue.is_continuous():
             output = f'<issue index="{indx + 1}" etype="real" type="real" vtype="real" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="cos" parameter0="{bias+self.bias}" parameter1="{self.amplitude} parameter2={self.multiplier} parameter3={self.phase}"></evaluator>\n'
+            output += f'    <evaluator ftype="cos" parameter0="{bias + self.bias}" parameter1="{self.amplitude} parameter2={self.multiplier} parameter3={self.phase}"></evaluator>\n'
         elif isinstance(issue, ContiguousIssue):
             output = f'<issue index="{indx + 1}" etype="integer" type="integer" vtype="integer" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="cos" parameter0="{bias+self.bias}" parameter1="{self.amplitude} parameter2={self.multiplier} parameter3={self.phase}"></evaluator>\n'
+            output += f'    <evaluator ftype="cos" parameter0="{bias + self.bias}" parameter1="{self.amplitude} parameter2={self.multiplier} parameter3={self.phase}"></evaluator>\n'
         else:
             vals = list(issue.all)
             return TableFun(dict(zip(vals, [self(_) for _ in vals]))).xml(
@@ -582,10 +583,10 @@ def xml(self, indx: int, issue: Issue, bias) -> str:
         issue_name = issue.name
         if issue.is_continuous():
             output = f'<issue index="{indx + 1}" etype="real" type="real" vtype="real" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="sin" parameter0="{bias+self.bias}" parameter1="{self.amplitude} parameter2={self.multiplier} parameter3={self.phase}"></evaluator>\n'
+            output += f'    <evaluator ftype="sin" parameter0="{bias + self.bias}" parameter1="{self.amplitude} parameter2={self.multiplier} parameter3={self.phase}"></evaluator>\n'
         elif isinstance(issue, ContiguousIssue):
             output = f'<issue index="{indx + 1}" etype="integer" type="integer" vtype="integer" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="sin" parameter0="{bias+self.bias}" parameter1="{self.amplitude} parameter2={self.multiplier} parameter3={self.phase}"></evaluator>\n'
+            output += f'    <evaluator ftype="sin" parameter0="{bias + self.bias}" parameter1="{self.amplitude} parameter2={self.multiplier} parameter3={self.phase}"></evaluator>\n'
         else:
             vals = list(issue.all)
             return TableFun(dict(zip(vals, [self(_) for _ in vals]))).xml(
@@ -629,10 +630,10 @@ def xml(self, indx: int, issue: Issue, bias) -> str:
         issue_name = issue.name
         if issue.is_continuous():
             output = f'<issue index="{indx + 1}" etype="real" type="real" vtype="real" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="log" parameter0="{bias+self.bias}" parameter1="{self.tau} parameter2={self.base} paramter3={self.scale}"></evaluator>\n'
+            output += f'    <evaluator ftype="log" parameter0="{bias + self.bias}" parameter1="{self.tau} parameter2={self.base} paramter3={self.scale}"></evaluator>\n'
         elif isinstance(issue, ContiguousIssue):
             output = f'<issue index="{indx + 1}" etype="integer" type="integer" vtype="integer" name="{issue_name}">\n'
-            output += f'    <evaluator ftype="log" parameter0="{bias+self.bias}" parameter1="{self.tau} parameter2={self.base} parameter3={self.scale}"></evaluator>\n'
+            output += f'    <evaluator ftype="log" parameter0="{bias + self.bias}" parameter1="{self.tau} parameter2={self.base} parameter3={self.scale}"></evaluator>\n'
         else:
             vals = list(issue.all)
             return TableFun(dict(zip(vals, [self(_) for _ in vals]))).xml(
@@ -807,4 +808,4 @@ def make_fun_from_xml(item) -> tuple[BaseFun, str]:
         return TriangularFun(start=strt, end=end, middle=middle), "triangular"
     else:
         # todo: implement all other functions defined in value_fun.py
-        raise ValueError(f'Unknown ftype {item.attrib["ftype"]}')
+        raise ValueError(f"Unknown ftype {item.attrib['ftype']}")