testing

Author: Thomas Schmelzer

cvx/cla/first.py

@@ -72,7 +72,7 @@ def init_algo_lp(
     upper_bounds: MATRIX,
     A_eq: MATRIX | None = None,
     b_eq: MATRIX | None = None,
-    solver=cp.ECOS,
+    solver=cp.CLARABEL,
     **kwargs
     # A_ub: MATRIX | None = None,
     # b_ub: MATRIX | None = None,
@@ -140,10 +140,3 @@ def _free(w, lower_bounds, upper_bounds):
     free = np.full_like(w, False, dtype=np.bool_)
     free[index] = True
     return free
-
-
-if __name__ == "__main__":
-    w = np.array([0.0, 0.0, 0.0])
-    lower_bounds = np.array([0.0, 0.0, 0.0])
-    upper_bounds = np.array([1.0, 1.0, 1.0])
-    print(_free(w, lower_bounds, upper_bounds))

cvx/cla/types.py

@@ -59,13 +59,6 @@ class TurningPoint(FrontierPoint):
     free: BOOLEAN_VECTOR
     lamb: float = np.inf
 
-    @property
-    def frontier_point(self):
-        """
-        Returns the frontier point
-        """
-        return FrontierPoint(weights=self.weights)
-
     @property
     def free_indices(self):
         """

tests/test_aux.py

@@ -66,13 +66,6 @@ def test_append(cla):
     assert fig is not None
 
 
-def test_first_turning_point(cla):
-    tp = cla._first_turning_point()
-    np.testing.assert_almost_equal(
-        tp.weights, np.array([0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
-    )
-
-
 def test_raise():
     cla = Cla(
         covariance=np.eye(2),

tests/test_first.py

@@ -5,15 +5,15 @@
 from cvx.cla.types import TurningPoint
 
 
-@pytest.mark.parametrize("n", [5, 20, 100, 1000, 10000, 100000])
+@pytest.mark.parametrize("n", [5, 20, 100, 1000, 10000])
 def test_init_algo(n):
     """Compute a first turning point"""
     mean = np.random.randn(n)
     lower_bounds = np.zeros(n)
     upper_bounds = np.random.rand(n)
 
     first = init_algo_lp(
-        mean=mean, lower_bounds=lower_bounds, upper_bounds=upper_bounds, solver="ECOS"
+        mean=mean, lower_bounds=lower_bounds, upper_bounds=upper_bounds
     )
 
     assert np.sum(first.free) == 1
@@ -34,9 +34,7 @@ def test_small():
     mean = np.array([1.0, 2.0, 3.0])
     lower_bound = np.array([0.0, 0.0, 0.0])
     upper_bound = np.array([0.4, 0.4, 0.4])
-    tp = init_algo_lp(
-        mean=mean, lower_bounds=lower_bound, upper_bounds=upper_bound, solver="ECOS"
-    )
+    tp = init_algo_lp(mean=mean, lower_bounds=lower_bound, upper_bounds=upper_bound)
 
     assert np.allclose(tp.weights, [0.2, 0.4, 0.4])
     assert tp.lamb == np.inf
@@ -61,12 +59,7 @@ def test_no_fully_invested_portfolio():
     with pytest.raises(
         ValueError, match="Could not construct a fully invested portfolio"
     ):
-        init_algo_lp(
-            mean=mean,
-            lower_bounds=lower_bounds,
-            upper_bounds=upper_bounds,
-            solver="ECOS",
-        )
+        init_algo_lp(mean=mean, lower_bounds=lower_bounds, upper_bounds=upper_bounds)
 
     with pytest.raises(
         ValueError, match="Could not construct a fully invested portfolio"
@@ -83,12 +76,7 @@ def test_lb_ub_mixed():
     mean = np.ones(3)
 
     with pytest.raises(ValueError):
-        init_algo_lp(
-            mean=mean,
-            lower_bounds=lower_bounds,
-            upper_bounds=upper_bounds,
-            solver="ECOS",
-        )
+        init_algo_lp(mean=mean, lower_bounds=lower_bounds, upper_bounds=upper_bounds)
 
     with pytest.raises(ValueError):
         init_algo(mean=mean, lower_bounds=lower_bounds, upper_bounds=upper_bounds)

tests/test_frontier.py

@@ -11,6 +11,9 @@
 
 @pytest.mark.parametrize("solver", [BAILEY, MARKOWITZ])
 def test_frontier(input_data, solver):
+    """
+    Test the frontier both for Bailey and Markowitz
+    """
     f = solver(
         covariance=input_data.covariance,
         mean=input_data.mean,
@@ -34,6 +37,9 @@ def test_frontier(input_data, solver):
     "n", [2, 2, 2, 3, 3, 3, 5, 5, 5, 5, 10, 20, 20, 20, 20, 20, 20]
 )
 def test_frontiers(n, resource_dir):
+    """
+    Compare the frontiers of BAILEY and MARKOWITZ for a variety of dimensions.
+    """
     mean = np.random.randn(n)
     lower_bounds = np.zeros(n)
     upper_bounds = np.ones(n)

tests/test_solver.py

@@ -5,23 +5,6 @@
 from tests.bailey.cla import CLA as BAILEY
 
 
-@pytest.mark.parametrize("solver", [BAILEY, MARKOWITZ])
-def test_solver(input_data, solver):
-    x = solver(
-        mean=input_data.mean,
-        lower_bounds=input_data.lower_bounds,
-        upper_bounds=input_data.upper_bounds,
-        covariance=input_data.covariance,
-        tol=1e-5,
-        A=np.ones((1, len(input_data.mean))),
-        b=np.ones(1),
-    )
-
-    assert x
-    for a in x.turning_points:
-        assert a
-
-
 @pytest.mark.parametrize("solver", [BAILEY, MARKOWITZ])
 def test_example(example, example_solution, solver):
     # example from section 3.1 in the Markowitz 2019 paper
@@ -57,37 +40,6 @@ def test_example(example, example_solution, solver):
         )
 
 
-@pytest.mark.parametrize("n", [2, 3, 5, 10, 20, 50])
-def test_init_dimension(n):
-    mean = np.random.randn(n)
-
-    # solver = Solver.BAILEY
-    tp_bailey = BAILEY(
-        mean=mean,
-        lower_bounds=np.zeros(n),
-        upper_bounds=np.ones(n),
-        covariance=np.eye(n),
-        A=np.ones((1, n)),
-        b=np.ones(1),
-    )
-
-    # solver = Solver.MARKOWITZ
-    tp_markowitz = MARKOWITZ(
-        mean=mean,
-        lower_bounds=np.zeros(n),
-        upper_bounds=np.ones(n),
-        covariance=np.eye(n),
-        A=np.ones((1, n)),
-        b=np.ones(1),
-    )
-
-    np.testing.assert_almost_equal(
-        tp_bailey.turning_points[0].weights, tp_markowitz.turning_points[0].weights
-    )
-
-    assert len(tp_bailey) == len(tp_markowitz)
-
-
 @pytest.mark.parametrize("solver", [MARKOWITZ, BAILEY])
 @pytest.mark.parametrize("n", [2, 4, 8, 16, 32, 64, 128])  # , 256, 512])
 def test_init_solver(solver, n):