pepflow 0.1.2__tar.gz → 0.1.4__tar.gz

{pepflow-0.1.2 → pepflow-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pepflow
-Version: 0.1.2
+Version: 0.1.4
 Summary: PEPFlow: A framework for Performance Estimation Problem (PEP) Workflow
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

pepflow-0.1.4/pepflow/e2e_test.py

@@ -0,0 +1,34 @@
+import math
+
+from pepflow import function, pep
+from pepflow import pep_context as pc
+
+
+def test_gd_e2e():
+    ctx = pc.PEPContext("gd").set_as_current()
+    pep_builder = pep.PEPBuilder()
+    eta = 1
+    N = 9
+
+    f = pep_builder.declare_func(function.SmoothConvexFunction, L=1)
+    f.add_tag("f")
+    x = pep_builder.set_init_point("x_0")
+    x_star = f.add_stationary_point("x_star")
+    pep_builder.set_initial_constraint(
+        ((x - x_star) ** 2).le(1, name="initial_condition")
+    )
+
+    # We first build the algorithm with the largest number of iterations.
+    for i in range(N):
+        x = x - eta * f.gradient(x)
+        x.add_tag(f"x_{i + 1}")
+
+    # To achieve the sweep, we can just update the performance_metric.
+    for i in range(1, N + 1):
+        p = ctx.get_by_tag(f"x_{i}")
+        pep_builder.set_performance_metric(
+            f.function_value(p) - f.function_value(x_star)
+        )
+        result = pep_builder.solve()
+        expected_opt_value = 1 / (4 * i + 2)
+        assert math.isclose(result.primal_opt_value, expected_opt_value, rel_tol=1e-3)

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/function.py

@@ -87,6 +87,10 @@ class Function:
             return self.tag
         return super().__repr__()
 
+    def _repr_latex_(self):
+        s = repr(self)
+        return rf"$\\displaystyle {s}$"
+
     def get_interpolation_constraints(self):
         raise NotImplementedError(
             "This method should be implemented in the children class."
@@ -247,6 +251,9 @@ class Function:
         triplet = self.generate_triplet(point)
         return triplet.function_value
 
+    def __call__(self, point: pt.Point) -> sc.Scalar:
+        return self.function_value(point)
+
     def __add__(self, other):
         assert isinstance(other, Function)
         return Function(
@@ -258,46 +265,61 @@ class Function:
 
     def __sub__(self, other):
         assert isinstance(other, Function)
+        tag_other = other.tag
+        if isinstance(other.composition, AddedFunc):
+            tag_other = f"({other.tag})"
         return Function(
             is_basis=False,
             reuse_gradient=self.reuse_gradient and other.reuse_gradient,
             composition=AddedFunc(self, -other),
-            tags=[f"{self.tag}-{other.tag}"],
+            tags=[f"{self.tag}-{tag_other}"],
         )
 
     def __mul__(self, other):
         assert utils.is_numerical(other)
+        tag_self = self.tag
+        if isinstance(self.composition, AddedFunc):
+            tag_self = f"({self.tag})"
         return Function(
             is_basis=False,
             reuse_gradient=self.reuse_gradient,
             composition=ScaledFunc(scale=other, base_func=self),
-            tags=[f"{other:.4g}*{self.tag}"],
+            tags=[f"{other:.4g}*{tag_self}"],
         )
 
     def __rmul__(self, other):
         assert utils.is_numerical(other)
+        tag_self = self.tag
+        if isinstance(self.composition, AddedFunc):
+            tag_self = f"({self.tag})"
         return Function(
             is_basis=False,
             reuse_gradient=self.reuse_gradient,
             composition=ScaledFunc(scale=other, base_func=self),
-            tags=[f"{other:.4g}*{self.tag}"],
+            tags=[f"{other:.4g}*{tag_self}"],
         )
 
     def __neg__(self):
+        tag_self = self.tag
+        if isinstance(self.composition, AddedFunc):
+            tag_self = f"({self.tag})"
         return Function(
             is_basis=False,
             reuse_gradient=self.reuse_gradient,
             composition=ScaledFunc(scale=-1, base_func=self),
-            tags=[f"-{self.tag}"],
+            tags=[f"-{tag_self}"],
         )
 
     def __truediv__(self, other):
         assert utils.is_numerical(other)
+        tag_self = self.tag
+        if isinstance(self.composition, AddedFunc):
+            tag_self = f"({self.tag})"
         return Function(
             is_basis=False,
             reuse_gradient=self.reuse_gradient,
             composition=ScaledFunc(scale=1 / other, base_func=self),
-            tags=[f"1/{other:.4g}*{self.tag}"],
+            tags=[f"1/{other:.4g}*{tag_self}"],
         )
 
     def __hash__(self):
@@ -347,3 +369,20 @@ class SmoothConvexFunction(Function):
                     self.smooth_convex_interpolability_constraints(i, j)
                 )
         return interpolation_constraints
+
+    def interpolate_ineq(
+        self, p1_tag: str, p2_tag: str, pep_context: pc.PEPContext | None = None
+    ) -> pt.Scalar:
+        """Generate the interpolation inequality scalar by tags."""
+        if pep_context is None:
+            pep_context = pc.get_current_context()
+        if pep_context is None:
+            raise RuntimeError("Did you forget to specify a context?")
+        # TODO: we definitely need a more robust tag system
+        x1 = pep_context.get_by_tag(p1_tag)
+        x2 = pep_context.get_by_tag(p2_tag)
+        f1 = pep_context.get_by_tag(f"{self.tag}({p1_tag})")
+        f2 = pep_context.get_by_tag(f"{self.tag}({p2_tag})")
+        g1 = pep_context.get_by_tag(f"gradient_{self.tag}({p1_tag})")
+        g2 = pep_context.get_by_tag(f"gradient_{self.tag}({p2_tag})")
+        return f2 - f1 + g2 * (x1 - x2) + 1 / 2 * (g1 - g2) ** 2

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/function_test.py

@@ -17,11 +17,86 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from typing import Iterator
+
 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
+
+
+@pytest.fixture
+def pep_context() -> Iterator[pc.PEPContext]:
+    """Prepare the pep context and reset the context to None at the end."""
+    ctx = pc.PEPContext("test").set_as_current()
+    yield ctx
+    pc.set_current_context(None)
+
+
+def test_function_add_tag(pep_context: pc.PEPContext) -> None:
+    f1 = fc.Function(is_basis=True, reuse_gradient=False, tags=["f1"])
+    f2 = fc.Function(is_basis=True, reuse_gradient=False, tags=["f2"])
+
+    f_add = f1 + f2
+    assert f_add.tag == "f1+f2"
+
+    f_sub = f1 - f2
+    assert f_sub.tag == "f1-f2"
+
+    f_sub = f1 - (f2 + f1)
+    assert f_sub.tag == "f1-(f2+f1)"
+
+    f_sub = f1 - (f2 - f1)
+    assert f_sub.tag == "f1-(f2-f1)"
+
+
+def test_function_mul_tag(pep_context: pc.PEPContext) -> None:
+    f = fc.Function(is_basis=True, reuse_gradient=False, tags=["f"])
+
+    f_mul = f * 0.1
+    assert f_mul.tag == "0.1*f"
+
+    f_rmul = 0.1 * f
+    assert f_rmul.tag == "0.1*f"
+
+    f_neg = -f
+    assert f_neg.tag == "-f"
+
+    f_truediv = f / 0.1
+    assert f_truediv.tag == "1/0.1*f"
+
+
+def test_function_add_and_mul_tag(pep_context: pc.PEPContext) -> None:
+    f1 = fc.Function(is_basis=True, reuse_gradient=False, tags=["f1"])
+    f2 = fc.Function(is_basis=True, reuse_gradient=False, tags=["f2"])
+
+    f_add_mul = (f1 + f2) * 0.1
+    assert f_add_mul.tag == "0.1*(f1+f2)"
+
+    f_add_mul = f1 + f2 * 0.1
+    assert f_add_mul.tag == "f1+0.1*f2"
+
+    f_neg_add = -(f1 + f2)
+    assert f_neg_add.tag == "-(f1+f2)"
+
+    f_rmul_add = 0.1 * (f1 + f2)
+    assert f_rmul_add.tag == "0.1*(f1+f2)"
+
+    f_rmul_add = f1 + 5 * (f2 + 3 * f1)
+    assert f_rmul_add.tag == "f1+5*(f2+3*f1)"
+
+    f_multiple_add = f1 + f1 + f1 + f1 + f1 + f1
+    assert f_multiple_add.tag == "f1+f1+f1+f1+f1+f1"
+
+
+def test_function_call(pep_context: pc.PEPContext) -> None:
+    f = fc.Function(is_basis=True, reuse_gradient=False, tags=["f"])
+    x = point.Point(is_basis=True, eval_expression=None, tags=["x"])
+    assert f.function_value(x) == f(x)
 
 
 def test_function_repr():

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/pep.py

@@ -87,6 +87,13 @@ class PEPBuilder:
         # We should think about a better choice like manager.
         self.relaxed_constraints = []
 
+    def clear_setup(self):
+        self.init_conditions.clear()
+        self.functions.clear()
+        self.interpolation_constraints.clear()
+        self.performance_metric = None
+        self.relaxed_constraints.clear()
+
     @contextlib.contextmanager
     def make_context(
         self, name: str, override: bool = False
@@ -94,7 +101,8 @@ class PEPBuilder:
         if not override and name in self.pep_context_dict:
             raise KeyError(f"There is already a context {name} in the builder")
         try:
-            ctx = pc.PEPContext()
+            self.clear_setup()
+            ctx = pc.PEPContext(name)
             self.pep_context_dict[name] = ctx
             pc.set_current_context(ctx)
             yield ctx

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/pep_context.py

@@ -33,6 +33,8 @@ if TYPE_CHECKING:
 
 # A global variable for storing the current context that is used for points or scalars.
 CURRENT_CONTEXT: PEPContext | None = None
+# Keep the track of all previous created context
+GLOBAL_CONTEXT_DICT: dict[str, PEPContext] = {}
 
 
 def get_current_context() -> PEPContext | None:
@@ -46,12 +48,19 @@ def set_current_context(ctx: PEPContext | None):
 
 
 class PEPContext:
-    def __init__(self):
+    def __init__(self, name: str):
+        self.name = name
         self.points: list[Point] = []
         self.scalars: list[Scalar] = []
         self.triplets: dict[Function, list[Triplet]] = defaultdict(list)
         self.opt_conditions: dict[Function, list[Constraint]] = defaultdict(list)
 
+        GLOBAL_CONTEXT_DICT[name] = self
+
+    def set_as_current(self) -> PEPContext:
+        set_current_context(self)
+        return self
+
     def add_point(self, point: Point):
         self.points.append(point)
 
@@ -66,10 +75,10 @@ class PEPContext:
 
     def get_by_tag(self, tag: str) -> Point | Scalar:
         for p in self.points:
-            if p.tag == tag:
+            if tag in p.tags:
                 return p
         for s in self.scalars:
-            if s.tag == tag:
+            if tag in s.tags:
                 return s
         raise ValueError("Cannot find the point or scalar of given tag")
 

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/pep_context_test.py

@@ -17,17 +17,25 @@
 # specific language governing permissions and limitations
 # under the License.
 
+from typing import Iterator
+
 import pandas as pd
+import pytest
 
 from pepflow import pep_context as pc
 from pepflow.function import SmoothConvexFunction
 from pepflow.point import Point
 
 
-def test_tracked_points():
-    ctx = pc.PEPContext()
-    pc.set_current_context(ctx)
+@pytest.fixture
+def pep_context() -> Iterator[pc.PEPContext]:
+    """Prepare the pep context and reset the context to None at the end."""
+    ctx = pc.PEPContext("test").set_as_current()
+    yield ctx
+    pc.set_current_context(None)
+
 
+def test_tracked_points(pep_context: pc.PEPContext):
     f = SmoothConvexFunction(L=1, is_basis=True)
     f.add_tag("f")
 
@@ -41,16 +49,11 @@ def test_tracked_points():
     _ = f.generate_triplet(p3)
     _ = f.generate_triplet(p_star)
 
-    assert ctx.order_of_point(f) == ["x_1", "x_2", "x_3", "x_*"]
-    assert ctx.tracked_point(f) == [p1, p3, p2, p_star]
-
-    pc.set_current_context(None)
+    assert pep_context.order_of_point(f) == ["x_1", "x_2", "x_3", "x_*"]
+    assert pep_context.tracked_point(f) == [p1, p3, p2, p_star]
 
 
-def test_triplets_to_dataframe():
-    ctx = pc.PEPContext()
-    pc.set_current_context(ctx)
-
+def test_triplets_to_dataframe(pep_context: pc.PEPContext):
     f = SmoothConvexFunction(L=1, is_basis=True)
     f.add_tag("f")
 
@@ -62,7 +65,7 @@ def test_triplets_to_dataframe():
     _ = f.generate_triplet(p2)
     _ = f.generate_triplet(p3)
 
-    func_to_df, func_to_order = ctx.triplets_to_df_and_order()
+    func_to_df, func_to_order = pep_context.triplets_to_df_and_order()
     expected_df = pd.DataFrame(
         {
             "constraint_name": [
@@ -83,20 +86,15 @@ def test_triplets_to_dataframe():
     pd.testing.assert_frame_equal(func_to_df[f], expected_df)
     assert func_to_order[f] == ["x1", "x2", "x3"]
 
-    pc.set_current_context(None)
-
-
-def test_get_by_tag():
-    ctx = pc.PEPContext()
-    pc.set_current_context(ctx)
 
+def test_get_by_tag(pep_context: pc.PEPContext):
     f = SmoothConvexFunction(L=1, is_basis=True)
     f.add_tag("f")
     p1 = Point(is_basis=True, tags=["x1"])
 
     triplet = f.generate_triplet(p1)
 
-    assert ctx.get_by_tag("x1") == p1
-    assert ctx.get_by_tag("f(x1)") == triplet.function_value
-    assert ctx.get_by_tag("gradient_f(x1)") == triplet.gradient
+    assert pep_context.get_by_tag("x1") == p1
+    assert pep_context.get_by_tag("f(x1)") == triplet.function_value
+    assert pep_context.get_by_tag("gradient_f(x1)") == triplet.gradient
     pc.set_current_context(None)

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/point.py

@@ -134,75 +134,110 @@ class Point:
             return self.tag
         return super().__repr__()
 
+    def _repr_latex_(self):
+        s = repr(self)
+        s = s.replace("star", r"\star")
+        s = s.replace("gradient_", r"\nabla ")
+        s = s.replace("|", r"\|")
+        return rf"$\\displaystyle {s}$"
+
     # TODO: add a validator that `is_basis` and `eval_expression` are properly setup.
     def __add__(self, other):
-        assert is_numerical_or_point(other)
+        assert isinstance(other, Point)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.ADD, self, other),
+            tags=[f"{self.tag}+{other.tag}"],
         )
 
     def __radd__(self, other):
-        assert is_numerical_or_point(other)
+        # TODO: come up with better way to handle this
+        if other == 0:
+            return self
+        assert isinstance(other, Point)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.ADD, other, self),
+            tags=[f"{other.tag}+{self.tag}"],
         )
 
     def __sub__(self, other):
-        assert is_numerical_or_point(other)
+        assert isinstance(other, Point)
+        tag_other = utils.parenthesize_tag(other)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.SUB, self, other),
+            tags=[f"{self.tag}-{tag_other}"],
         )
 
     def __rsub__(self, other):
-        assert is_numerical_or_point(other)
+        assert isinstance(other, Point)
+        tag_self = utils.parenthesize_tag(self)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.SUB, other, self),
+            tags=[f"{other.tag}-{tag_self}"],
         )
 
     def __mul__(self, other):
         # TODO allow the other to be point so that we return a scalar.
         assert is_numerical_or_point(other)
+        tag_self = utils.parenthesize_tag(self)
         if utils.is_numerical(other):
             return Point(
                 is_basis=False,
                 eval_expression=EvalExpressionPoint(utils.Op.MUL, self, other),
+                tags=[f"{tag_self}*{other:.4g}"],
             )
         else:
+            tag_other = utils.parenthesize_tag(other)
             return Scalar(
                 is_basis=False,
-                eval_expression=EvalExpressionScalar(utils.Op.MUL, self, other),  # TODO
+                eval_expression=EvalExpressionScalar(utils.Op.MUL, self, other),
+                tags=[f"{tag_self}*{tag_other}"],
             )
 
     def __rmul__(self, other):
         # TODO allow the other to be point so that we return a scalar.
         assert is_numerical_or_point(other)
+        tag_self = utils.parenthesize_tag(self)
         if utils.is_numerical(other):
             return Point(
                 is_basis=False,
                 eval_expression=EvalExpressionPoint(utils.Op.MUL, other, self),
+                tags=[f"{other:.4g}*{tag_self}"],
             )
         else:
+            tag_other = utils.parenthesize_tag(other)
             return Scalar(
                 is_basis=False,
-                eval_expression=EvalExpressionScalar(utils.Op.MUL, other, self),  # TODO
+                eval_expression=EvalExpressionScalar(utils.Op.MUL, other, self),
+                tags=[f"{tag_other}*{tag_self}"],
             )
 
     def __pow__(self, power):
         assert power == 2
-        return self.__rmul__(self)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.MUL, self, self),
+            tags=[rf"|{self.tag}|^{power}"],
+        )
 
     def __neg__(self):
-        return self.__rmul__(other=-1)
+        tag_self = utils.parenthesize_tag(self)
+        return Point(
+            is_basis=False,
+            eval_expression=EvalExpressionPoint(utils.Op.MUL, -1, self),
+            tags=[f"-{tag_self}"],
+        )
 
     def __truediv__(self, other):
         assert utils.is_numerical(other)
+        tag_self = utils.parenthesize_tag(self)
         return Point(
             is_basis=False,
             eval_expression=EvalExpressionPoint(utils.Op.DIV, self, other),
+            tags=[f"1/{other:.4g}*{tag_self}"],
         )
 
     def __hash__(self):
@@ -212,3 +247,14 @@ class Point:
         if not isinstance(other, Point):
             return NotImplemented
         return self.uid == other.uid
+
+    def eval(self, ctx: pc.PEPContext | None = None) -> np.ndarray:
+        from pepflow.expression_manager import ExpressionManager
+
+        # Note this can be inefficient.
+        if ctx is None:
+            ctx = pc.get_current_context()
+        if ctx is None:
+            raise RuntimeError("Did you forget to create a context?")
+        em = ExpressionManager(ctx)
+        return em.eval_point(self).vector

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/point_test.py

@@ -18,47 +18,109 @@
 # under the License.
 
 import time
+from typing import Iterator
 
 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 point, scalar, utils
+from pepflow import pep_context as pc
+from pepflow import point, scalar
 
 
-def test_point_hash_different():
-    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)
+@pytest.fixture
+def pep_context() -> Iterator[pc.PEPContext]:
+    """Prepare the pep context and reset the context to None at the end."""
+    ctx = pc.PEPContext("test").set_as_current()
+    yield ctx
+    pc.set_current_context(None)
+
+
+def test_point_add_tag(pep_context: pc.PEPContext) -> None:
+    p1 = point.Point(is_basis=True, eval_expression=None, tags=["p1"])
+    p2 = point.Point(is_basis=True, eval_expression=None, tags=["p2"])
+
+    p_add = p1 + p2
+    assert p_add.tag == "p1+p2"
+
+    p_sub = p1 - p2
+    assert p_sub.tag == "p1-p2"
+
+    p_sub = p1 - (p2 + p1)
+    assert p_sub.tag == "p1-(p2+p1)"
+
+    p_sub = p1 - (p2 - p1)
+    assert p_sub.tag == "p1-(p2-p1)"
+
+
+def test_point_mul_tag(pep_context: pc.PEPContext) -> None:
+    p = point.Point(is_basis=True, eval_expression=None, tags=["p"])
+
+    p_mul = p * 0.1
+    assert p_mul.tag == "p*0.1"
+
+    p_rmul = 0.1 * p
+    assert p_rmul.tag == "0.1*p"
+
+    p_pow = p**2
+    assert p_pow.tag == "|p|^2"
+
+    p_neg = -p
+    assert p_neg.tag == "-p"
+
+    p_truediv = p / 0.1
+    assert p_truediv.tag == "1/0.1*p"
+
+
+def test_point_add_and_mul_tag(pep_context: pc.PEPContext) -> None:
+    p1 = point.Point(is_basis=True, eval_expression=None, tags=["p1"])
+    p2 = point.Point(is_basis=True, eval_expression=None, tags=["p2"])
+
+    p_add_mul = (p1 + p2) * 0.1
+    assert p_add_mul.tag == "(p1+p2)*0.1"
+
+    p_add_mul = (p1 + p2) * (p1 + p2)
+    assert p_add_mul.tag == "(p1+p2)*(p1+p2)"
+
+    p_add_pow = (p1 + p2) ** 2
+    assert p_add_pow.tag == "|p1+p2|^2"
+
+    p_add_mul = p1 + p2 * 0.1
+    assert p_add_mul.tag == "p1+p2*0.1"
+
+    p_neg_add = -(p1 + p2)
+    assert p_neg_add.tag == "-(p1+p2)"
+
+    p_rmul_add = 0.1 * (p1 + p2)
+    assert p_rmul_add.tag == "0.1*(p1+p2)"
+
+
+def test_point_hash_different(pep_context: pc.PEPContext) -> None:
+    p1 = point.Point(is_basis=True, eval_expression=None)
+    p2 = point.Point(is_basis=True, eval_expression=None)
     assert p1.uid != p2.uid
 
 
-def test_scalar_hash_different():
-    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)
+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_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        p1 = point.Point(is_basis=True, eval_expression=None)
-        p1.add_tag(tag="my_tag")
+def test_point_tag(pep_context: pc.PEPContext) -> None:
+    p1 = point.Point(is_basis=True, eval_expression=None)
+    p1.add_tag(tag="my_tag")
     assert p1.tags == ["my_tag"]
     assert p1.tag == "my_tag"
 
 
-def test_point_repr():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test"):
-        p1 = point.Point(is_basis=True)
-        print(p1)  # it should be fine without tag
-        p1.add_tag("my_tag")
-        assert str(p1) == "my_tag"
+def test_point_repr(pep_context: pc.PEPContext) -> None:
+    p1 = point.Point(is_basis=True)
+    assert str(p1) is not None  # it should be fine without tag
+    p1.add_tag("my_tag")
+    assert str(p1) == "my_tag"
 
 
 def test_scalar_tag():
@@ -73,7 +135,7 @@ def test_scalar_tag():
 def test_scalar_repr():
     pep_builder = pep.PEPBuilder()
     with pep_builder.make_context("test"):
-        s1 = scalar.Scalar(is_basis=True)
+        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"
@@ -136,8 +198,8 @@ def test_expression_manager_on_basis_scalar():
 def test_expression_manager_eval_point():
     pep_builder = pep.PEPBuilder()
     with pep_builder.make_context("test") as ctx:
-        p1 = point.Point(is_basis=True)
-        p2 = point.Point(is_basis=True)
+        p1 = point.Point(is_basis=True, tags=["p1"])
+        p2 = point.Point(is_basis=True, tags=["p2"])
         p3 = 2 * p1 + p2 / 4
         p4 = p3 + p1
 
@@ -146,114 +208,10 @@ def test_expression_manager_eval_point():
     np.testing.assert_allclose(pm.eval_point(p4).vector, np.array([3, 0.25]))
 
 
-def test_expression_manager_eval_scalar():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        s1 = scalar.Scalar(is_basis=True)
-        s2 = scalar.Scalar(is_basis=True)
-        s3 = 2 * s1 + s2 / 4 + 5
-        s4 = s3 + s1
-        s5 = s4 + 5
-
-        p1 = point.Point(is_basis=True)
-        p2 = point.Point(is_basis=True)
-        s6 = p1 * p2
-
-        p3 = point.Point(is_basis=True)
-        p4 = point.Point(is_basis=True)
-        s7 = 5 * p3 * p4
-
-        s8 = s6 + s7
-
-        pm = exm.ExpressionManager(ctx)
-
-    np.testing.assert_allclose(pm.eval_scalar(s3).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(s3).constant, 5)
-    np.testing.assert_allclose(pm.eval_scalar(s4).vector, np.array([3, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(s5).vector, np.array([3, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(s5).constant, 10)
-
-    np.testing.assert_allclose(pm.eval_point(p1).vector, np.array([1, 0, 0, 0]))
-    np.testing.assert_allclose(pm.eval_point(p2).vector, np.array([0, 1, 0, 0]))
-    np.testing.assert_allclose(pm.eval_point(p3).vector, np.array([0, 0, 1, 0]))
-    np.testing.assert_allclose(pm.eval_point(p4).vector, np.array([0, 0, 0, 1]))
-
-    np.testing.assert_allclose(
-        pm.eval_scalar(s6).matrix,
-        np.array(
-            [
-                [0.0, 0.5, 0.0, 0.0],
-                [0.5, 0.0, 0.0, 0.0],
-                [0.0, 0.0, 0.0, 0.0],
-                [0.0, 0.0, 0.0, 0.0],
-            ]
-        ),
-    )
-    np.testing.assert_allclose(
-        pm.eval_scalar(s7).matrix,
-        np.array(
-            [
-                [0.0, 0.0, 0.0, 0.0],
-                [0.0, 0.0, 0.0, 0.0],
-                [0.0, 0.0, 0.0, 2.5],
-                [0.0, 0.0, 2.5, 0.0],
-            ]
-        ),
-    )
-
-    np.testing.assert_allclose(
-        pm.eval_scalar(s8).matrix,
-        np.array(
-            [
-                [0.0, 0.5, 0.0, 0.0],
-                [0.5, 0.0, 0.0, 0.0],
-                [0.0, 0.0, 0.0, 2.5],
-                [0.0, 0.0, 2.5, 0.0],
-            ]
-        ),
-    )
-
-
-def test_constraint():
-    pep_builder = pep.PEPBuilder()
-    with pep_builder.make_context("test") as ctx:
-        s1 = scalar.Scalar(is_basis=True)
-        s2 = scalar.Scalar(is_basis=True)
-        s3 = 2 * s1 + s2 / 4 + 5
-
-        c1 = s3.le(5, name="c1")
-        c2 = s3.lt(5, name="c2")
-        c3 = s3.ge(5, name="c3")
-        c4 = s3.gt(5, name="c4")
-        c5 = s3.eq(5, name="c5")
-
-        pm = exm.ExpressionManager(ctx)
-
-    np.testing.assert_allclose(pm.eval_scalar(c1.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c1.scalar).constant, 0)
-    assert c1.comparator == utils.Comparator.LT
-
-    np.testing.assert_allclose(pm.eval_scalar(c2.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c2.scalar).constant, 0)
-    assert c2.comparator == utils.Comparator.LT
-
-    np.testing.assert_allclose(pm.eval_scalar(c3.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c3.scalar).constant, 0)
-    assert c3.comparator == utils.Comparator.GT
-
-    np.testing.assert_allclose(pm.eval_scalar(c4.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c4.scalar).constant, 0)
-    assert c4.comparator == utils.Comparator.GT
-
-    np.testing.assert_allclose(pm.eval_scalar(c5.scalar).vector, np.array([2, 0.25]))
-    np.testing.assert_allclose(pm.eval_scalar(c5.scalar).constant, 0)
-    assert c5.comparator == utils.Comparator.EQ
-
-
 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) for _ in range(100)]
+        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)):

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/scalar.py

@@ -173,56 +173,94 @@ class Scalar:
             return self.tag
         return super().__repr__()
 
+    def _repr_latex_(self):
+        s = repr(self)
+        s = s.replace("star", r"\star")
+        s = s.replace("gradient_", r"\nabla ")
+        return rf"$\\displaystyle {s}$"
+
     def __add__(self, other):
         assert is_numerical_or_scalar(other)
+        if utils.is_numerical(other):
+            tag_other = f"{other:.4g}"
+        else:
+            tag_other = other.tag
         return Scalar(
             is_basis=False,
             eval_expression=EvalExpressionScalar(utils.Op.ADD, self, other),
+            tags=[f"{self.tag}+{tag_other}"],
         )
 
     def __radd__(self, other):
         assert is_numerical_or_scalar(other)
+        if utils.is_numerical(other):
+            tag_other = f"{other:.4g}"
+        else:
+            tag_other = other.tag
         return Scalar(
             is_basis=False,
             eval_expression=EvalExpressionScalar(utils.Op.ADD, other, self),
+            tags=[f"{tag_other}+{self.tag}"],
         )
 
     def __sub__(self, other):
         assert is_numerical_or_scalar(other)
+        if utils.is_numerical(other):
+            tag_other = f"{other:.4g}"
+        else:
+            tag_other = utils.parenthesize_tag(other)
         return Scalar(
             is_basis=False,
             eval_expression=EvalExpressionScalar(utils.Op.SUB, self, other),
+            tags=[f"{self.tag}-{tag_other}"],
         )
 
     def __rsub__(self, other):
         assert is_numerical_or_scalar(other)
+        tag_self = utils.parenthesize_tag(self)
+        if utils.is_numerical(other):
+            tag_other = f"{other:.4g}"
+        else:
+            tag_other = other.tag
         return Scalar(
             is_basis=False,
             eval_expression=EvalExpressionScalar(utils.Op.SUB, other, self),
+            tags=[f"{tag_other}-{tag_self}"],
         )
 
     def __mul__(self, other):
         assert utils.is_numerical(other)
+        tag_self = utils.parenthesize_tag(self)
         return Scalar(
             is_basis=False,
             eval_expression=EvalExpressionScalar(utils.Op.MUL, self, other),
+            tags=[f"{tag_self}*{other:.4g}"],
         )
 
     def __rmul__(self, other):
         assert utils.is_numerical(other)
+        tag_self = utils.parenthesize_tag(self)
         return Scalar(
             is_basis=False,
             eval_expression=EvalExpressionScalar(utils.Op.MUL, other, self),
+            tags=[f"{other:.4g}*{tag_self}"],
         )
 
     def __neg__(self):
-        return self.__rmul__(other=-1)
+        tag_self = utils.parenthesize_tag(self)
+        return Scalar(
+            is_basis=False,
+            eval_expression=EvalExpressionScalar(utils.Op.MUL, -1, self),
+            tags=[f"-{tag_self}"],
+        )
 
     def __truediv__(self, other):
         assert utils.is_numerical(other)
+        tag_self = utils.parenthesize_tag(self)
         return Scalar(
             is_basis=False,
             eval_expression=EvalExpressionScalar(utils.Op.DIV, self, other),
+            tags=[f"1/{other:.4g}*{tag_self}"],
         )
 
     def __hash__(self):
@@ -247,3 +285,14 @@ class Scalar:
 
     def eq(self, other, name: str) -> ctr.Constraint:
         return ctr.Constraint(self - other, comparator=utils.Comparator.EQ, name=name)
+
+    def eval(self, ctx: pc.PEPContext | None = None) -> EvaluatedScalar:
+        from pepflow.expression_manager import ExpressionManager
+
+        # Note this can be inefficient.
+        if ctx is None:
+            ctx = pc.get_current_context()
+        if ctx is None:
+            raise RuntimeError("Did you forget to create a context?")
+        em = ExpressionManager(ctx)
+        return em.eval_scalar(self)

pepflow-0.1.4/pepflow/scalar_test.py

@@ -0,0 +1,250 @@
+# Copyright: 2025 The PEPFlow Developers
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+
+import numpy as np
+
+from pepflow import expression_manager as exm
+from pepflow import pep as pep
+from pepflow import point, scalar, utils
+
+
+def test_scalar_add_tag():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
+        s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
+
+        s_add = s1 + s2
+        assert s_add.tag == "s1+s2"
+
+        s_add = s1 + 0.1
+        assert s_add.tag == "s1+0.1"
+
+        s_radd = 0.1 + s1
+        assert s_radd.tag == "0.1+s1"
+
+        s_sub = s1 - s2
+        assert s_sub.tag == "s1-s2"
+
+        s_sub = s1 - (s2 + s1)
+        assert s_sub.tag == "s1-(s2+s1)"
+
+        s_sub = s1 - (s2 - s1)
+        assert s_sub.tag == "s1-(s2-s1)"
+
+        s_sub = s1 - 0.1
+        assert s_sub.tag == "s1-0.1"
+
+        s_rsub = 0.1 - s1
+        assert s_rsub.tag == "0.1-s1"
+
+
+def test_scalar_mul_tag():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        s = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s"])
+
+        s_mul = s * 0.1
+        assert s_mul.tag == "s*0.1"
+
+        s_rmul = 0.1 * s
+        assert s_rmul.tag == "0.1*s"
+
+        s_neg = -s
+        assert s_neg.tag == "-s"
+
+        s_truediv = s / 0.1
+        assert s_truediv.tag == "1/0.1*s"
+
+
+def test_scalar_add_and_mul_tag():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test"):
+        s1 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s1"])
+        s2 = scalar.Scalar(is_basis=True, eval_expression=None, tags=["s2"])
+
+        s_add_mul = (s1 + s2) * 0.1
+        assert s_add_mul.tag == "(s1+s2)*0.1"
+
+        s_add_mul = s1 + s2 * 0.1
+        assert s_add_mul.tag == "s1+s2*0.1"
+
+        s_neg_add = -(s1 + s2)
+        assert s_neg_add.tag == "-(s1+s2)"
+
+        s_rmul_add = 0.1 * (s1 + s2)
+        assert s_rmul_add.tag == "0.1*(s1+s2)"
+
+
+def test_scalar_hash_different():
+    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)
+    assert s1.uid != s2.uid
+
+
+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_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_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)
+
+        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]))
+
+        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_scalar():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        s1 = scalar.Scalar(is_basis=True, tags=["s1"])
+        s2 = scalar.Scalar(is_basis=True, tags=["s2"])
+        s3 = 2 * s1 + s2 / 4 + 5
+        s4 = s3 + s1
+        s5 = s4 + 5
+
+        p1 = point.Point(is_basis=True, tags=["p1"])
+        p2 = point.Point(is_basis=True, tags=["p2"])
+        s6 = p1 * p2
+
+        p3 = point.Point(is_basis=True, tags=["p3"])
+        p4 = point.Point(is_basis=True, tags=["p4"])
+        s7 = 5 * p3 * p4
+
+        s8 = s6 + s7
+
+        pm = exm.ExpressionManager(ctx)
+
+    np.testing.assert_allclose(pm.eval_scalar(s3).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(s3).constant, 5)
+    np.testing.assert_allclose(pm.eval_scalar(s4).vector, np.array([3, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(s5).vector, np.array([3, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(s5).constant, 10)
+
+    np.testing.assert_allclose(pm.eval_point(p1).vector, np.array([1, 0, 0, 0]))
+    np.testing.assert_allclose(pm.eval_point(p2).vector, np.array([0, 1, 0, 0]))
+    np.testing.assert_allclose(pm.eval_point(p3).vector, np.array([0, 0, 1, 0]))
+    np.testing.assert_allclose(pm.eval_point(p4).vector, np.array([0, 0, 0, 1]))
+
+    np.testing.assert_allclose(
+        pm.eval_scalar(s6).matrix,
+        np.array(
+            [
+                [0.0, 0.5, 0.0, 0.0],
+                [0.5, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0],
+            ]
+        ),
+    )
+    np.testing.assert_allclose(
+        pm.eval_scalar(s7).matrix,
+        np.array(
+            [
+                [0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 2.5],
+                [0.0, 0.0, 2.5, 0.0],
+            ]
+        ),
+    )
+
+    np.testing.assert_allclose(
+        pm.eval_scalar(s8).matrix,
+        np.array(
+            [
+                [0.0, 0.5, 0.0, 0.0],
+                [0.5, 0.0, 0.0, 0.0],
+                [0.0, 0.0, 0.0, 2.5],
+                [0.0, 0.0, 2.5, 0.0],
+            ]
+        ),
+    )
+
+
+def test_constraint():
+    pep_builder = pep.PEPBuilder()
+    with pep_builder.make_context("test") as ctx:
+        s1 = scalar.Scalar(is_basis=True, tags=["s1"])
+        s2 = scalar.Scalar(is_basis=True, tags=["s2"])
+        s3 = 2 * s1 + s2 / 4 + 5
+
+        c1 = s3.le(5, name="c1")
+        c2 = s3.lt(5, name="c2")
+        c3 = s3.ge(5, name="c3")
+        c4 = s3.gt(5, name="c4")
+        c5 = s3.eq(5, name="c5")
+
+        pm = exm.ExpressionManager(ctx)
+
+    np.testing.assert_allclose(pm.eval_scalar(c1.scalar).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(c1.scalar).constant, 0)
+    assert c1.comparator == utils.Comparator.LT
+
+    np.testing.assert_allclose(pm.eval_scalar(c2.scalar).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(c2.scalar).constant, 0)
+    assert c2.comparator == utils.Comparator.LT
+
+    np.testing.assert_allclose(pm.eval_scalar(c3.scalar).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(c3.scalar).constant, 0)
+    assert c3.comparator == utils.Comparator.GT
+
+    np.testing.assert_allclose(pm.eval_scalar(c4.scalar).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(c4.scalar).constant, 0)
+    assert c4.comparator == utils.Comparator.GT
+
+    np.testing.assert_allclose(pm.eval_scalar(c5.scalar).vector, np.array([2, 0.25]))
+    np.testing.assert_allclose(pm.eval_scalar(c5.scalar).constant, 0)
+    assert c5.comparator == utils.Comparator.EQ

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/solver_test.py

@@ -27,8 +27,8 @@ from pepflow import solver as ps
 def test_cvx_solver_case1():
     pep_builder = pep.PEPBuilder()
     with pep_builder.make_context("test"):
-        p1 = pp.Point(is_basis=True)
-        s1 = pp.Scalar(is_basis=True)
+        p1 = pp.Point(is_basis=True, tags=["p1"])
+        s1 = pp.Scalar(is_basis=True, tags=["s1"])
         s2 = -(1 + p1 * p1)
         constraints = [(p1 * p1).gt(1, name="x^2 >= 1"), s1.gt(0, name="s1 > 0")]
 
@@ -50,9 +50,9 @@ def test_cvx_solver_case1():
 def test_cvx_solver_case2():
     pep_builder = pep.PEPBuilder()
     with pep_builder.make_context("test"):
-        p1 = pp.Point(is_basis=True)
-        s1 = pp.Scalar(is_basis=True)
-        s2 = -(p1 - 1) * (p1 - 2)
+        p1 = pp.Point(is_basis=True, tags=["p1"])
+        s1 = pp.Scalar(is_basis=True, tags=["s1"])
+        s2 = -p1 * p1 + 2
         constraints = [(p1 * p1).lt(1, name="x^2 <= 1"), s1.gt(0, name="s1 > 0")]
 
     solver = ps.CVXSolver(
@@ -61,10 +61,10 @@ def test_cvx_solver_case2():
         context=pep_builder.get_context("test"),
     )
 
-    # It is a simple `min_x (x-1)(x-2); s.t. x^2 <= 1` problem.
+    # It is a simple `min_x x^2-2; s.t. x^2 <= 1` problem.
     problem = solver.build_problem()
     result = problem.solve()
-    assert abs(-result) < 1e-6
+    assert abs(-result + 2) < 1e-6
 
     assert np.isclose(solver.dual_var_manager.dual_value("x^2 <= 1"), 0)
     assert solver.dual_var_manager.dual_value("s1 > 0") == 0

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow/utils.py

@@ -21,10 +21,15 @@ from __future__ import annotations
 
 import enum
 import numbers
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
+if TYPE_CHECKING:
+    from pepflow.function import Function
+    from pepflow.point import Point
+    from pepflow.scalar import Scalar
+
 
 def SOP(v, w):
     """Symmetric Outer Product."""
@@ -50,3 +55,11 @@ class Comparator(enum.Enum):
 
 def is_numerical(val: Any) -> bool:
     return isinstance(val, numbers.Number)
+
+
+def parenthesize_tag(val: Point | Scalar | Function) -> str:
+    tmp_tag = val.tag
+    if not val.is_basis:
+        if val.eval_expression.op == Op.ADD or val.eval_expression.op == Op.SUB:
+            tmp_tag = f"({val.tag})"
+    return tmp_tag

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pepflow
-Version: 0.1.2
+Version: 0.1.4
 Summary: PEPFlow: A framework for Performance Estimation Problem (PEP) Workflow
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown

{pepflow-0.1.2 → pepflow-0.1.4}/pepflow.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 pepflow/__init__.py
 pepflow/constants.py
 pepflow/constraint.py
+pepflow/e2e_test.py
 pepflow/expression_manager.py
 pepflow/function.py
 pepflow/function_test.py
@@ -15,6 +16,7 @@ pepflow/pep_test.py
 pepflow/point.py
 pepflow/point_test.py
 pepflow/scalar.py
+pepflow/scalar_test.py
 pepflow/solver.py
 pepflow/solver_test.py
 pepflow/utils.py

{pepflow-0.1.2 → pepflow-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pepflow"
-version = "0.1.2"
+version = "0.1.4"
 description = "PEPFlow: A framework for Performance Estimation Problem (PEP) Workflow"
 readme = "README.md"
 requires-python = ">=3.9"