pepflow 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

pepflow/point_test.py

@@ -24,10 +24,9 @@ import numpy as np
 import pytest
 
 from pepflow import expression_manager as exm
-from pepflow import function as fc
 from pepflow import pep as pep
 from pepflow import pep_context as pc
-from pepflow import point, scalar
+from pepflow import point
 
 
 @pytest.fixture
@@ -103,12 +102,6 @@ def test_point_hash_different(pep_context: pc.PEPContext) -> None:
     assert p1.uid != p2.uid
 
 
-def test_scalar_hash_different(pep_context: pc.PEPContext) -> None:
-    s1 = scalar.Scalar(is_basis=True, eval_expression=None)
-    s2 = scalar.Scalar(is_basis=True, eval_expression=None)
-    assert s1.uid != s2.uid
-
-
 def test_point_tag(pep_context: pc.PEPContext) -> None:
     p1 = point.Point(is_basis=True, eval_expression=None)
     p1.add_tag(tag="my_tag")
@@ -123,202 +116,61 @@ def test_point_repr(pep_context: pc.PEPContext) -> None:
     assert str(p1) == "my_tag"
 
 
-def test_scalar_tag():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None)
-        s1.add_tag(tag="my_tag")
-    assert s1.tags == ["my_tag"]
-    assert s1.tag == "my_tag"
-
-
-def test_scalar_repr():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, tags=["s1"])
-        print(s1)  # it should be fine without tag
-        s1.add_tag("my_tag")
-        assert str(s1) == "my_tag"
-
-
-def test_point_in_a_list():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        p1 = point.Point(is_basis=True, eval_expression=None)
-        p2 = point.Point(is_basis=True, eval_expression=None)
-        p3 = point.Point(is_basis=True, eval_expression=None)
+def test_point_in_a_list(pep_context: pc.PEPContext):
+    p1 = point.Point(is_basis=True, eval_expression=None)
+    p2 = point.Point(is_basis=True, eval_expression=None)
+    p3 = point.Point(is_basis=True, eval_expression=None)
     assert p1 in [p1, p2]
     assert p3 not in [p1, p2]
 
 
-def test_scalar_in_a_list():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None)
-        s2 = scalar.Scalar(is_basis=True, eval_expression=None)
-        s3 = scalar.Scalar(is_basis=True, eval_expression=None)
-    assert s1 in [s1, s2]
-    assert s3 not in [s1, s2]
-
-
-def test_expression_manager_on_basis_point():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        p1 = point.Point(is_basis=True, eval_expression=None, tags=["p1"])
-        p2 = point.Point(is_basis=True, eval_expression=None, tags=["p2"])
-        pm = exm.ExpressionManager(ctx)
+def test_expression_manager_on_basis_point(pep_context: pc.PEPContext):
+    p1 = point.Point(is_basis=True, eval_expression=None, tags=["p1"])
+    p2 = point.Point(is_basis=True, eval_expression=None, tags=["p2"])
+    pm = exm.ExpressionManager(pep_context)
 
-        np.testing.assert_allclose(pm.eval_point(p1).vector, np.array([1, 0]))
-        np.testing.assert_allclose(pm.eval_point(p2).vector, np.array([0, 1]))
+    np.testing.assert_allclose(pm.eval_point(p1).vector, np.array([1, 0]))
+    np.testing.assert_allclose(pm.eval_point(p2).vector, np.array([0, 1]))
 
-        p3 = point.Point(is_basis=True, eval_expression=None, tags=["p3"])  # noqa: F841
-        pm = exm.ExpressionManager(ctx)
+    p3 = point.Point(is_basis=True, eval_expression=None, tags=["p3"])  # noqa: F841
+    pm = exm.ExpressionManager(pep_context)
 
     np.testing.assert_allclose(pm.eval_point(p1).vector, np.array([1, 0, 0]))
     np.testing.assert_allclose(pm.eval_point(p2).vector, np.array([0, 1, 0]))
 
 
-def test_expression_manager_on_basis_scalar():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
-        s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
-        pm = exm.ExpressionManager(ctx)
+def test_expression_manager_eval_point(pep_context: pc.PEPContext):
+    p1 = point.Point(is_basis=True, tags=["p1"])
+    p2 = point.Point(is_basis=True, tags=["p2"])
+    p3 = 2 * p1 + p2 / 4
+    p4 = p3 + p1
 
-        np.testing.assert_allclose(pm.eval_scalar(s1).vector, np.array([1, 0]))
-        np.testing.assert_allclose(pm.eval_scalar(s2).vector, np.array([0, 1]))
+    pm = exm.ExpressionManager(pep_context)
+    np.testing.assert_allclose(pm.eval_point(p3).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_point(p4).vector, np.array([3, 0.25]))
 
-        s3 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s3"])  # noqa: F841
-        pm = exm.ExpressionManager(ctx)
 
-        np.testing.assert_allclose(pm.eval_scalar(s1).vector, np.array([1, 0, 0]))
-        np.testing.assert_allclose(pm.eval_scalar(s2).vector, np.array([0, 1, 0]))
+def test_expression_manager_eval_point_large_scale(pep_context):
+    all_basis = [point.Point(is_basis=True, tags=[f"p_{i}"]) for i in range(100)]
+    p = all_basis[0]
+    for i in range(len(all_basis)):
+        for j in range(i + 1, len(all_basis)):
+            p += all_basis[i] * 2 + all_basis[j]
+    pm = exm.ExpressionManager(pep_context)
+    t = time.time()
+    for pp in pep_context.points:
+        pm.eval_point(pp)
 
+    assert (time.time() - t) < 0.5
 
-def test_expression_manager_eval_point():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        p1 = point.Point(is_basis=True, tags=["p1"])
-        p2 = point.Point(is_basis=True, tags=["p2"])
-        p3 = 2 * p1 + p2 / 4
-        p4 = p3 + p1
 
-        pm = exm.ExpressionManager(ctx)
-    np.testing.assert_allclose(pm.eval_point(p3).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_point(p4).vector, np.array([3, 0.25]))
+def test_zero_point(pep_context):
+    _ = point.Point(is_basis=True, tags=["p1"])
+    p0 = point.Point.zero()
 
+    pm = exm.ExpressionManager(pep_context)
+    np.testing.assert_allclose(pm.eval_point(p0).vector, np.array([0]))
 
-def test_expression_manager_eval_point_large_scale():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        all_basis = [point.Point(is_basis=True, tags=[f"p_{i}"]) for i in range(100)]
-        p = all_basis[0]
-        for i in range(len(all_basis)):
-            for j in range(i + 1, len(all_basis)):
-                p += all_basis[i] * 2 + all_basis[j]
-        pm = exm.ExpressionManager(ctx)
-        t = time.time()
-        for pp in ctx.points:
-            pm.eval_point(pp)
-
-        assert (time.time() - t) < 0.5
-
-
-def test_function_generate_triplet():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        f = fc.Function(is_basis=True, reuse_gradient=True)
-        f.add_tag("f")
-        g = fc.Function(is_basis=True, reuse_gradient=True)
-        g.add_tag("g")
-        h = 5 * f + 5 * g
-        h.add_tag("h")
-
-        f1 = fc.Function(is_basis=True, reuse_gradient=False)
-        f1.add_tag("f1")
-        g1 = fc.Function(is_basis=True, reuse_gradient=False)
-        g1.add_tag("g1")
-        h1 = 5 * f1 + 5 * g1
-        h1.add_tag("h1")
-
-        p1 = point.Point(is_basis=True)
-        p1.add_tag("p1")
-        p1_triplet = h.generate_triplet(p1)
-        p1_triplet_1 = h.generate_triplet(p1)
-
-        p1_triplet_2 = h1.generate_triplet(p1)
-        p1_triplet_3 = h1.generate_triplet(p1)
-
-        pm = exm.ExpressionManager(ctx)
-
-    np.testing.assert_allclose(
-        pm.eval_point(p1).vector, np.array([1, 0, 0, 0, 0, 0, 0])
-    )
-
-    np.testing.assert_allclose(
-        pm.eval_point(p1_triplet.gradient).vector, np.array([0, 5, 5, 0, 0, 0, 0])
-    )
-    np.testing.assert_allclose(
-        pm.eval_scalar(p1_triplet.function_value).vector, np.array([5, 5, 0, 0])
-    )
-
-    np.testing.assert_allclose(
-        pm.eval_point(p1_triplet_1.gradient).vector, np.array([0, 5, 5, 0, 0, 0, 0])
-    )
-    np.testing.assert_allclose(
-        pm.eval_scalar(p1_triplet_1.function_value).vector, np.array([5, 5, 0, 0])
-    )
-
-    np.testing.assert_allclose(
-        pm.eval_point(p1_triplet_2.gradient).vector, np.array([0, 0, 0, 5, 5, 0, 0])
-    )
-    np.testing.assert_allclose(
-        pm.eval_scalar(p1_triplet_2.function_value).vector, np.array([0, 0, 5, 5])
-    )
-
-    np.testing.assert_allclose(
-        pm.eval_point(p1_triplet_3.gradient).vector, np.array([0, 0, 0, 0, 0, 5, 5])
-    )
-    np.testing.assert_allclose(
-        pm.eval_scalar(p1_triplet_3.function_value).vector, np.array([0, 0, 5, 5])
-    )
-
-
-def test_function_add_stationary_point():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        f = fc.Function(is_basis=True, reuse_gradient=True)
-        f.add_tag("f")
-        x_opt = f.add_stationary_point("x_opt")
-
-        pm = exm.ExpressionManager(ctx)
-
-        np.testing.assert_allclose(pm.eval_point(x_opt).vector, np.array([1]))
-
-
-def test_smooth_interpolability_constraints():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        f = fc.SmoothConvexFunction(L=1)
-        f.add_tag("f")
-        _ = f.add_stationary_point("x_opt")
-
-        x_0 = point.Point(is_basis=True)
-        x_0.add_tag("x_0")
-        _ = f.generate_triplet(x_0)
-
-        all_interpolation_constraints = f.get_interpolation_constraints()
-
-        pm = exm.ExpressionManager(ctx)
-
-    np.testing.assert_allclose(
-        pm.eval_scalar(all_interpolation_constraints[1].scalar).vector, [1, -1]
-    )
-    np.testing.assert_allclose(
-        pm.eval_scalar(all_interpolation_constraints[1].scalar).matrix,
-        [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.5]],
-    )
-
-    np.testing.assert_allclose(
-        pm.eval_scalar(all_interpolation_constraints[1].scalar).constant, 0
-    )
+    _ = point.Point(is_basis=True, tags=["p2"])
+    pm = exm.ExpressionManager(pep_context)
+    np.testing.assert_allclose(pm.eval_point(p0).vector, np.array([0, 0]))