Curve Fit: Minor fixes

Author: VesnaT

Orange/data/tests/test_util.py

@@ -3,7 +3,7 @@
 
 from Orange.data import Domain, ContinuousVariable
 from Orange.data.util import get_unique_names, get_unique_names_duplicates, \
-    get_unique_names_domain, one_hot
+    get_unique_names_domain, one_hot, sanitized_name
 
 
 class TestGetUniqueNames(unittest.TestCase):
@@ -260,5 +260,13 @@ def test_dim_too_low(self):
             one_hot(self.values, dim=2)
 
 
+class TestSanitizedName(unittest.TestCase):
+    def test_sanitized_name(self):
+        self.assertEqual(sanitized_name("Foo"), "Foo")
+        self.assertEqual(sanitized_name("Foo Bar"), "Foo_Bar")
+        self.assertEqual(sanitized_name("0Foo"), "_0Foo")
+        self.assertEqual(sanitized_name("1 Foo Bar"), "_1_Foo_Bar")
+
+
 if __name__ == "__main__":
     unittest.main()

Orange/regression/curvefit.py

@@ -45,9 +45,9 @@ def coefficients(self) -> Table:
 
     def predict(self, X: np.ndarray) -> np.ndarray:
         predicted = self.__function(X, *self.__parameters)
-        if isinstance(predicted, float):
+        if not isinstance(predicted, np.ndarray):
             # handle constant function; i.e. len(self.domain.attributes) == 0
-            return np.full(len(X), predicted)
+            return np.full(len(X), predicted, dtype=float)
         return predicted.flatten()
 
     def __getstate__(self) -> Dict:
@@ -261,6 +261,8 @@ def _create_lambda(
 
     Examples
     --------
+    >>> from Orange.data import Table
+    >>> data = Table("housing")
     >>> sfun = "a * exp(-b * CRIM * LSTAT) + c"
     >>> names = [a.name for a in data.domain.attributes]
     >>> func, par, var = _create_lambda(sfun, available_feature_names=names,

Orange/regression/tests/test_curvefit.py

@@ -104,6 +104,9 @@ def test_init_str(self):
 
         self.assertRaises(TypeError, CurveFitLearner, "a + b")
 
+        kw = dict(available_feature_names=[])
+        self.assertRaises(TypeError, CurveFitLearner, "a + b", **kw)
+
     def test_init_ast(self):
         kw = dict(available_feature_names=[], functions=[])
         exp = ast.parse("a + b", mode="eval")
@@ -119,6 +122,9 @@ def test_init_callable(self):
 
         self.assertRaises(TypeError, CurveFitLearner, lambda x, a: a)
 
+        kw = dict(parameters_names=[])
+        self.assertRaises(TypeError, CurveFitLearner, lambda x, a: a, **kw)
+
     def test_fit(self):
         learner = CurveFitLearner(func, [], ["CRIM"])
         model = learner(self.data)

Orange/widgets/model/owcurvefit.py

@@ -29,7 +29,7 @@
               "fmod", "gcd", "hypot", "isfinite", "isinf", "isnan", "ldexp",
               "log", "log10", "log1p", "log2", "pi", "power", "radians",
               "remainder", "sin", "sinh", "sqrt", "tan", "tanh", "trunc",
-              "round", "abs")}
+              "round", "abs", "any", "all")}
 
 
 class Parameter:
@@ -260,6 +260,7 @@ class Warning(OWBaseLearner.Warning):
         duplicate_parameter = Msg("Duplicated parameter name.")
         unused_parameter = Msg("Unused parameter '{}' in "
                                "'Parameters' declaration.")
+        data_missing = Msg("Provide data on the input.")
 
     class Error(OWBaseLearner.Error):
         invalid_exp = Msg("Invalid expression.")
@@ -305,6 +306,8 @@ def __init__(self, *args, **kwargs):
 
         super().__init__(*args, **kwargs)
 
+        self.Warning.data_missing()
+
     def add_main_layout(self):
         box = gui.vBox(self.controlArea, "Parameters")
         self.__param_widget = ParametersWidget(self)
@@ -391,12 +394,9 @@ def __insert_into_expression(self, what: str, offset=0):
         self.__expression_edit.setFocus()
 
     def set_data(self, data: Optional[Table]):
+        self.Warning.data_missing(shown=not bool(data))
         super().set_data(data)
         self.__clear()
-        # self.__init_models()
-        # self.__enable_controls()
-        # self.__set_pending()
-        # self.unconditional_apply()
 
     def __clear(self):
         self.expression = ""
@@ -452,10 +452,11 @@ def create_learner(self) -> Optional[CurveFitLearner]:
         self.Error.no_parameter.clear()
         self.Error.unknown_parameter.clear()
         self.Warning.unused_parameter.clear()
-        if not self.__pp_data or not self.expression:
+        expression = self.expression.strip()
+        if not self.__pp_data or not expression:
             return None
 
-        if not self.__validate_expression(self.expression):
+        if not self.__validate_expression(expression):
             self.Error.invalid_exp()
             return None
 
@@ -467,7 +468,7 @@ def create_learner(self) -> Optional[CurveFitLearner]:
                             param.upper if param.use_upper else np.inf)
 
         learner = self.LEARNER(
-            self.expression,
+            expression,
             available_feature_names=[a.name for a in self.__feature_model[1:]],
             functions=FUNCTIONS,
             sanitizer=sanitized_name,

Orange/widgets/model/tests/test_owcurvefit.py

@@ -22,11 +22,29 @@ def test_functions(self):
             func = getattr(np, f)
             if isinstance(func, float):
                 pass
+            elif f in ["any", "all"]:
+                self.assertTrue(func(a))
             elif f in ["arctan2", "copysign", "fmod", "gcd", "hypot",
                        "isclose", "ldexp", "power", "remainder"]:
                 self.assertIsInstance(func(a, 2), np.ndarray)
+                self.assertEqual(func(a, 2).shape, (5,))
             else:
                 self.assertIsInstance(func(a), np.ndarray)
+                self.assertEqual(func(a).shape, (5,))
+
+
+class TestParameter(unittest.TestCase):
+    def test_to_tuple(self):
+        args = ("foo", 2, True, 10, False, 50)
+        par = Parameter(*args)
+        self.assertEqual(par.to_tuple(), args)
+
+    def test_repr(self):
+        args = ("foo", 2, True, 10, False, 50)
+        par = Parameter(*args)
+        str_par = "Parameter(name=foo, initial=2, use_lower=True, " \
+                  "lower=10, use_upper=False, upper=50)"
+        self.assertEqual(str(par), str_par)
 
 
 class TestParametersWidget(WidgetTest):
@@ -66,6 +84,19 @@ def test_add_row(self):
         self.assertFalse(data.use_upper)
         self.assertEqual(data.upper, 100)
 
+    def test_remove(self):
+        n = 5
+        for _ in range(n):
+            self._widget._add_row()
+        self.assertEqual(len(self._widget._ParametersWidget__data), n)
+
+        k = 2
+        for _ in range(k):
+            button = self._widget._ParametersWidget__controls[0][0]
+            button.click()
+
+        self.assertEqual(len(self._widget._ParametersWidget__data), n - k)
+
     def test_add_row_with_data(self):
         param = Parameter("a", 3, True, 2, False, 4)
         self._widget._add_row(param)
@@ -165,6 +196,13 @@ def test_input_data_learner_adequacy(self):  # overwritten
             self.wait_until_stop_blocking()
             self.assertFalse(self.widget.Error.data_error.is_shown())
 
+    def test_input_data_missing(self):
+        self.assertTrue(self.widget.Warning.data_missing.is_shown())
+        self.send_signal(self.widget.Inputs.data, self.housing)
+        self.assertFalse(self.widget.Warning.data_missing.is_shown())
+        self.send_signal(self.widget.Inputs.data, None)
+        self.assertTrue(self.widget.Warning.data_missing.is_shown())
+
     def test_input_preprocessor(self):
         self.__init_widget()
         super().test_input_preprocessor()
@@ -282,18 +320,18 @@ def test_parameters_combo(self):
     def test_function_combo(self):
         combo = self.widget.controls._function
         model = combo.model()
-        self.assertEqual(model.rowCount(), 44)
+        self.assertEqual(model.rowCount(), 46)
         self.assertEqual(combo.currentText(), "Select Function")
 
         self.send_signal(self.widget.Inputs.data, self.housing)
-        self.assertEqual(model.rowCount(), 44)
+        self.assertEqual(model.rowCount(), 46)
         self.assertEqual(combo.currentText(), "Select Function")
         simulate.combobox_activate_index(combo, 1)
         self.assertEqual(self.widget._OWCurveFit__expression_edit.text(),
                          "abs()")
 
         self.send_signal(self.widget.Inputs.data, None)
-        self.assertEqual(model.rowCount(), 44)
+        self.assertEqual(model.rowCount(), 46)
         self.assertEqual(combo.currentText(), "Select Function")
 
     def test_expression(self):