Go through test requirements and make sure they all apply to the

appropriate backends

Also adjust the tests to reflect the new requirements.

The test_miscellaneous and test_end_to_end were removed.
Test_miscellaneous was removed because it doesn't cleanly fit into the
requirements at this time, and while we need it to improve coverage,
this branch is big enough without concerning ourselves with coverage.
Getting good coverage will have to be done as a later effort.

test_end_to_end was removed because in terms of functionality it's
redundant with some of the tests in test_basic_functionality and
test_options, and while it does provide some coverage that those don't,
specifically on the _project function, coverage efforts will have to
come later for sake of appropriate scoping, as mentioned above.

Author: nbelakovski

python/prima/__init__.py

@@ -489,8 +489,19 @@ def fixed_nlc_fun(x):
     elif options['backend'].lower() == "python":
         from .backends.pyprima.cobyla.cobyla import cobyla
         from .backends.pyprima.common.infos import SMALL_TR_RADIUS
+        if x0_is_scalar:
+            x0 = np.array([x0])
+        if args and x0_is_scalar:
+            original_fun = fun
+            fun = lambda x: original_fun(x[0], args)
+        elif args:
+            original_fun = fun
+            fun = lambda x: original_fun(x, args)
+        elif x0_is_scalar:
+            original_fun = fun
+            fun = lambda x: original_fun(x[0])
         def calcfc(x):
-            f = fun(x, *args)
+            f = fun(x)
             if nonlinear_constraint_function is not None:
                 nlconstr = nonlinear_constraint_function(x)
             else:
@@ -512,6 +523,8 @@ def calcfc(x):
             callback=callback,
             **options
         )
+        if x0_is_scalar:
+            result.x = result.x[0]
         result = OptimizeResult(
             x = result.x,
             success = result.info == SMALL_TR_RADIUS,

python/tests/README.md

@@ -5,12 +5,13 @@
 
 def test_anonymous_lambda():
     '''
-    In previous iterations of these bindings, memory was not handled correctly in C++ and using anonymous lambdas
+    In previous iterations of the bindings, memory was not handled correctly in C++ and using anonymous lambdas
     would cause issues including, but not limited to, segfaults and infinite hangs. This test is to ensure that
     anonymous lambdas can be used without issue.
     '''
     myNLC = NLC(lambda x: x[0]**2 - 9, [-np.inf], [0])
-    res = minimize(lambda x: (x[0] - 5)**2 + (x[1] - 4)**2, [0.0] * 2, method='COBYLA', constraints=myNLC, callback=lambda x, *args: print(x))
+    res = minimize(lambda x: (x[0] - 5)**2 + (x[1] - 4)**2, [0.0] * 2, method='COBYLA', constraints=myNLC,
+                   callback=lambda x, *args: print(x), options={'backend': 'Fortran'})
     assert abs(res.x[0] - 3) < 1e-2 and abs(res.x[1] - 4) < 1e-2 and abs(res.fun - 4) < 1e-2
 
 
@@ -22,5 +23,6 @@ def test_anonymous_lambda_unclean_exit():
     '''
     myNLC = NLC(lambda x: x[0]**2 - 9, [-np.inf], [0])
     with pytest.raises(ValueError) as e_info:
-        minimize(lambda x: (x[0] - 5)**2 + (x[1] - 4)**2, [0.0] * 2, method='GARBAGE', constraints=myNLC, callback=lambda x, *args: print(x))
+        minimize(lambda x: (x[0] - 5)**2 + (x[1] - 4)**2, [0.0] * 2, method='GARBAGE', constraints=myNLC,
+                 callback=lambda x, *args: print(x), options={'backend': 'Fortran'})
     assert e_info.match("Method must be one of NEWUOA, UOBYQA, BOBYQA, COBYLA, or LINCOA, not 'garbage'")

python/tests/pyprima/test_end_to_end.py

@@ -4,7 +4,7 @@
 from objective import fun
 
 
-def test_provide_nonlinear_constraints_alone(backend_fixture):
+def test_provide_nonlinear_constraints_alone(pyprima_turn_on_debugging, backend_fixture):
     nlc = NLC(lambda x: np.array([x[0]**2, x[1]**2]), lb=[25]*2, ub=[100]*2)
     x0 = [0, 0]
     res = minimize(fun, x0, constraints=nlc, options={'backend': backend_fixture})
@@ -79,4 +79,11 @@ def test_unconstrained_and_select_any_algorithm(method):
 def test_invalid_backend():
     x0 = [0, 0]
     with pytest.raises(ValueError, match="Backend must be either 'Fortran' or 'Python', not 'InvalidBackend'"):
-        minimize(fun, x0, options={'backend': 'InvalidBackend'})
+        minimize(fun, x0, options={'backend': 'InvalidBackend'})
+
+
+def test_select_algorithm_not_provided_by_python_implementation():
+    x0 = [0, 0]
+    with pytest.warns(UserWarning, match="The pure Python implementation only supports COBYLA at this time. The Fortran implementation will be used instead."):
+        res = minimize(fun, x0, method='newuoa', options={'backend': 'Python'})
+        assert fun.result_point_and_value_are_optimal(res)

python/tests/test_anonymous_lambda.py

@@ -1,7 +1,6 @@
 from prima import minimize as prima_minimize, NonlinearConstraint as prima_NLC, LinearConstraint as prima_LC, Bounds as prima_Bounds
 import numpy as np
 from objective import fun
-import pytest
 
 
 def test_providing_linear_and_nonlinear_constraints(backend_fixture):
@@ -15,15 +14,11 @@ def test_providing_linear_and_nonlinear_constraints(backend_fixture):
     assert res.method == "cobyla"
 
 
-def test_providing_bounds_and_linear_constraints(backend_fixture):
+def test_providing_bounds_and_linear_constraints():
     lc = prima_LC(np.array([1,1]), lb=10, ub=15)
     bounds = prima_Bounds(1, 1)
     x0 = [0, 0]
-    if backend_fixture == 'Fortran':
-        res = prima_minimize(fun, x0, constraints=lc, bounds=bounds, options={'backend': backend_fixture})
-    elif backend_fixture == "Python":
-        with pytest.warns(UserWarning, match="The pure Python implementation only supports COBYLA at this time. The Fortran implementation will be used instead."):
-            res = prima_minimize(fun, x0, constraints=lc, bounds=bounds, options={'backend': backend_fixture})
+    res = prima_minimize(fun, x0, constraints=lc, bounds=bounds)
     assert np.isclose(res.x[0], 1, atol=1e-6, rtol=1e-6)
     assert np.isclose(res.x[1], 9, atol=1e-6, rtol=1e-6)
     assert np.isclose(res.fun, 41, atol=1e-6, rtol=1e-6)

python/tests/test_basic_functionality.py

@@ -4,94 +4,98 @@
 import pytest
 
 
-def test_x0_as_list():
+def test_x0_as_list(backend_fixture):
     x0 = [0.0] * 2
-    res = minimize(fun, x0)
+    method = 'COBYLA' if backend_fixture == 'Python' else None
+    res = minimize(fun, x0, method=method, options={'backend': backend_fixture})
     assert fun.result_point_and_value_are_optimal(res)
 
 
-def test_x0_as_array():
+def test_x0_as_array(backend_fixture):
     x0 = np.array([0.0] * 2)
-    res = minimize(fun, x0)
+    method = 'COBYLA' if backend_fixture == 'Python' else None
+    res = minimize(fun, x0, method=method, options={'backend': backend_fixture})
     assert fun.result_point_and_value_are_optimal(res)
 
 
-def test_x0_as_scalar():
+def test_x0_as_scalar(backend_fixture):
     x0 = 0.0
     # We need a custom function since the default objective function we're
     # using for tests expects something that can be unpacked into two variables.
-    res = minimize(lambda x: (x-5)**2, x0)
+    method = 'COBYLA' if backend_fixture == 'Python' else None
+    res = minimize(lambda x: (x-5)**2, x0, method=method, options={'backend': backend_fixture})
     assert np.isclose(res.x, 5.0, rtol=1e-6)
     assert np.isclose(res.fun, 0.0, rtol=1e-6)
 
 
-def test_constraint_function_returns_numpy_array():
+def test_constraint_function_returns_numpy_array(backend_fixture):
     nlc = NLC(lambda x: np.array([x[0], x[1]]), lb=[-np.inf]*2, ub=[10]*2)
     x0 = [0, 0]
-    res = minimize(fun, x0, method='COBYLA', constraints=nlc)
+    res = minimize(fun, x0, method='COBYLA', constraints=nlc, options={'backend': backend_fixture})
     assert fun.result_point_and_value_are_optimal(res)
 
 
-def test_constraint_function_returns_list():
+def test_constraint_function_returns_list(backend_fixture):
     nlc = NLC(lambda x: [x[0], x[1]], lb=[-np.inf]*2, ub=[10]*2)
     x0 = [0, 0]
-    res = minimize(fun, x0, method='COBYLA', constraints=nlc)
+    res = minimize(fun, x0, method='COBYLA', constraints=nlc, options={'backend': backend_fixture})
     assert fun.result_point_and_value_are_optimal(res)
 
 
-def test_constraint_function_returns_scalar():
+def test_constraint_function_returns_scalar(backend_fixture):
     nlc = NLC(lambda x: float(np.linalg.norm(x) - np.linalg.norm(fun.optimal_x)), lb=[-np.inf], ub=[0])
     x0 = [0, 0]
-    res = minimize(fun, x0, method='COBYLA', constraints=nlc)
+    res = minimize(fun, x0, method='COBYLA', constraints=nlc, options={'backend': backend_fixture})
     assert fun.result_point_and_value_are_optimal(res)
 
 
 
 @pytest.mark.parametrize("A", (1, [1], np.array([1])))
 @pytest.mark.parametrize("lb", (0, [0], np.array([0])))
 @pytest.mark.parametrize("ub", (4, [4], np.array([4])))
-def test_linear_constraint_data_types(A, lb, ub):
+def test_linear_constraint_data_types(A, lb, ub, backend_fixture):
     myLC = LC(A=A, lb=lb, ub=ub)
     # If A is scalar, x must have dimension 1, so we need a univariate function for that
     scalar_fun = lambda x: (x - 5)**2
     x0 = 0
-    res = minimize(scalar_fun, x0, method='LINCOA', constraints=myLC)
+    method = 'COBYLA' if backend_fixture == 'Python' else None
+    res = minimize(scalar_fun, x0, constraints=myLC, method=method, options={'backend': backend_fixture})
     assert np.isclose(res.x, 4, rtol=1e-2)
 
 
-def test_nonlinear_constraint_lb_scalar_ub_scalar():
+def test_nonlinear_constraint_lb_scalar_ub_scalar(backend_fixture):
     nlc = NLC(lambda x: [x[0]**2, x[1]**2], lb=25, ub=100)
     x0 = [0, 0]
-    res = minimize(fun, x0, constraints=nlc)
+    res = minimize(fun, x0, constraints=nlc, options={'backend': backend_fixture})
     assert np.isclose(res.x[0], 5, atol=1e-6, rtol=1e-6)
     assert np.isclose(res.x[1], 5, atol=1e-6, rtol=1e-6)
     assert np.isclose(res.fun, 1, atol=1e-6, rtol=1e-6)
 
 
-def test_nonlinear_constraint_lb_scalar_ub_not_scalar():
+def test_nonlinear_constraint_lb_scalar_ub_not_scalar(backend_fixture):
     nlc = NLC(lambda x: [x[0]**2, x[1]**2], lb=9, ub=[9, 16])
     x0 = [0, 0]
-    res = minimize(fun, x0, constraints=nlc)
+    res = minimize(fun, x0, constraints=nlc, options={'backend': backend_fixture})
     assert np.isclose(res.x[0], 3, atol=1e-6, rtol=1e-6)
     # cp38-manylinux_i686 didn't quite get to 4 with a tol of e-6,
     # so we lower the tolerance a little bit.
     assert np.isclose(res.x[1], 4, atol=1e-5, rtol=1e-5)
     assert np.isclose(res.fun, 4, atol=1e-6, rtol=1e-6)
 
 
-def test_nonlinear_constraint_lb_not_scalar_ub_scalar():
+def test_nonlinear_constraint_lb_not_scalar_ub_scalar(backend_fixture):
     nlc = NLC(lambda x: [x[0]**2, x[1]**2], lb=[25, 36], ub=100)
     x0 = [0, 0]
-    res = minimize(fun, x0, constraints=nlc)
+    res = minimize(fun, x0, constraints=nlc, options={'backend': backend_fixture})
     assert np.isclose(res.x[0], 5, atol=1e-6, rtol=1e-6)
     assert np.isclose(res.x[1], 6, atol=1e-6, rtol=1e-6)
     assert np.isclose(res.fun, 4, atol=1e-6, rtol=1e-6)
 
 
-def test_nonlinear_constraint_lb_not_scalar_ub_not_scalar():
+def test_nonlinear_constraint_lb_not_scalar_ub_not_scalar(backend_fixture):
     nlc = NLC(lambda x: [x[0]**2, x[1]**2], lb=[4, 4], ub=[4, 9])
     x0 = [0, 0]
-    res = minimize(fun, x0, constraints=nlc)
+    res = minimize(fun, x0, constraints=nlc, options={'backend': backend_fixture})
     assert np.isclose(res.x[0], 2, atol=1e-6, rtol=1e-6)
     assert np.isclose(res.x[1], 3, atol=1e-6, rtol=1e-6)
     assert np.isclose(res.fun, 10, atol=1e-6, rtol=1e-6)