gamspy 1.14.0__tar.gz → 1.15.1__tar.gz

{gamspy-1.14.0 → gamspy-1.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gamspy
-Version: 1.14.0
+Version: 1.15.1
 Summary: Python-based algebraic modeling interface to GAMS
 Author-email: GAMS Development Corporation <support@gams.com>
 Project-URL: homepage, https://gams.com/sales/gamspy_facts/
@@ -31,8 +31,8 @@ Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: gamsapi[transfer]==50.3.0
-Requires-Dist: gamspy_base==50.3.0
+Requires-Dist: gamsapi[transfer]==50.4.1
+Requires-Dist: gamspy_base==50.4.1
 Requires-Dist: pydantic>=2.0
 Requires-Dist: certifi>=2022.09.14
 Requires-Dist: urllib3>=2.0.7

{gamspy-1.14.0 → gamspy-1.15.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gamspy"
-version = "1.14.0"
+version = "1.15.1"
 authors = [
   { name = "GAMS Development Corporation", email = "support@gams.com" },
 ]
@@ -36,8 +36,8 @@ classifiers = [
   "Operating System :: Microsoft :: Windows",
 ]
 dependencies = [
-  "gamsapi[transfer] == 50.3.0",
-  "gamspy_base == 50.3.0",
+  "gamsapi[transfer] == 50.4.1",
+  "gamspy_base == 50.4.1",
   "pydantic >= 2.0",
   "certifi >= 2022.09.14",
   "urllib3 >= 2.0.7",

{gamspy-1.14.0 → gamspy-1.15.1}/src/gamspy/_algebra/condition.py

@@ -137,11 +137,15 @@ class Condition(operable.Operable):
             if hasattr(self.condition, "gamsRepr")
             else str(self.condition)
         )
+        conditioning_on_str = self.conditioning_on.gamsRepr()
 
         if isinstance(self.condition, bool):
             condition_str = str(int(self.condition))
 
-        return f"({self.conditioning_on.gamsRepr()} $ {condition_str})"  # type: ignore
+        if isinstance(self.conditioning_on, expression.Expression):
+            conditioning_on_str = f"({conditioning_on_str})"
+
+        return f"{conditioning_on_str} $ ({condition_str})"  # type: ignore
 
     def getDeclaration(self) -> str:
         return self.gamsRepr()

{gamspy-1.14.0 → gamspy-1.15.1}/src/gamspy/_algebra/expression.py

@@ -20,6 +20,8 @@ from gamspy.exceptions import ValidationError
 from gamspy.math.misc import MathOp
 
 if TYPE_CHECKING:
+    from numbers import Real
+
     import pandas as pd
 
     from gamspy import Alias, Set
@@ -41,6 +43,266 @@ def peek(stack):
     return None
 
 
+# Higher number means higher precedence.
+PRECEDENCE = {
+    "..": 0,
+    "=": 0,
+    "or": 1,
+    "xor": 2,
+    "and": 3,
+    "=e=": 4,
+    "=n=": 4,
+    "=b=": 4,
+    "eq": 4,
+    "ne": 4,
+    ">=": 4,
+    "<=": 4,
+    ">": 4,
+    "<": 4,
+    "=g=": 4,
+    "=l=": 4,
+    "=x=": 4,
+    "+": 5,
+    "-": 5,
+    "*": 6,
+    "/": 6,
+    "not": 7,
+    "u-": 7,
+}
+
+# Defines how operators of the same precedence are grouped.
+ASSOCIATIVITY = {
+    "or": "left",
+    "xor": "left",
+    "and": "left",
+    "=e=": "left",
+    "=n=": "left",
+    "=x=": "left",
+    "=b=": "left",
+    "eq": "left",
+    "ne": "left",
+    "=": "left",
+    ">=": "left",
+    "<=": "left",
+    ">": "left",
+    "<": "left",
+    "=g=": "left",
+    "=l=": "left",
+    "..": "non",
+    "+": "left",
+    "-": "left",
+    "*": "left",
+    "/": "left",
+    "not": "right",
+    "u-": "right",
+}
+
+# Precedence for a leaf node is considered infinite.
+LEAF_PRECEDENCE = float("inf")
+
+
+def get_operand_gams_repr(operand) -> str:
+    if hasattr(operand, "gamsRepr"):
+        return operand.gamsRepr()
+
+    representation = str(operand)
+
+    # b[i] * -1   -> not valid
+    # b[i] * (-1) -> valid
+    if isinstance(operand, (int, float)) and operand < 0:
+        representation = f"({representation})"
+
+    return representation
+
+
+def get_operand_latex_repr(operand) -> str:
+    if hasattr(operand, "latexRepr"):
+        return operand.latexRepr()
+
+    if isinstance(operand, float):
+        operand = utils._map_special_values(operand)
+
+    representation = str(operand)
+
+    return representation
+
+
+def create_gams_expression(root_node: Expression) -> str:
+    """
+    Creates GAMS representation of a binary expression tree without recursion.
+    It uses an iterative post-order traversal to build the expression,
+    adding parentheses only when necessary based on operator precedence and
+    associativity rules.
+    """
+    if not isinstance(root_node, Expression):
+        return get_operand_gams_repr(root_node)
+
+    # 1. Get nodes in post-order (left - right - parent).
+    s1: list[OperableType | ImplicitEquation | str] = [root_node]
+    post_order_nodes = []
+    while s1:
+        node = s1.pop()
+        post_order_nodes.append(node)
+        if isinstance(node, Expression):
+            if node.left is not None:
+                s1.append(node.left)
+            if node.right is not None:
+                s1.append(node.right)
+
+    # 2. Build the GAMS expression
+    eval_stack: list[tuple[str, Real]] = []
+    for node in reversed(post_order_nodes):
+        if not isinstance(node, Expression):
+            eval_stack.append((get_operand_gams_repr(node), LEAF_PRECEDENCE))
+            continue
+
+        op = node.operator
+        op_prec = PRECEDENCE[op]
+        op_assoc = ASSOCIATIVITY[op]
+
+        # Handle unary ops
+        if op in ("u-", "not"):
+            operand_str, operand_prec = eval_stack.pop()
+
+            # Add parentheses if the operand's operator has lower precedence
+            if operand_prec < op_prec:
+                operand_str = f"({operand_str})"
+
+            if op == "u-":
+                new_str = f"(-{operand_str})"
+                # A parenthesized expression has the highest precedence
+                eval_stack.append((new_str, LEAF_PRECEDENCE))
+            else:  # Standard handling for 'not'
+                new_str = f"not {operand_str}"
+                eval_stack.append((new_str, op_prec))
+
+        # Handle binary ops
+        else:
+            right_str, right_prec = eval_stack.pop()
+            left_str, left_prec = eval_stack.pop()
+
+            if left_prec < op_prec or (
+                left_prec == op_prec and op_assoc == "right"
+            ):
+                left_str = f"({left_str})"
+
+            if right_prec < op_prec or (
+                right_prec == op_prec and op_assoc == "left"
+            ):
+                right_str = f"({right_str})"
+
+            # get around 80000 line length limitation in GAMS
+            length = len(left_str) + len(op) + len(right_str)
+            if length >= GMS_MAX_LINE_LENGTH - LINE_LENGTH_OFFSET:
+                new_str = f"{left_str} {op}\n {right_str}"
+            else:
+                new_str = f"{left_str} {op} {right_str}"
+            eval_stack.append((new_str, op_prec))
+
+    final_string = eval_stack[0][0]
+
+    if root_node.operator in ("=", ".."):
+        return f"{final_string};"
+
+    return final_string
+
+
+def create_latex_expression(root_node: Expression) -> str:
+    """
+    Creates LaTeX representation of a binary expression tree without recursion.
+    It uses an iterative post-order traversal to build the expression,
+    adding parentheses only when necessary based on operator precedence and
+    associativity rules.
+    """
+    if not isinstance(root_node, Expression):
+        return get_operand_latex_repr(root_node)
+
+    op_map = {
+        "=g=": "\\geq",
+        "=l=": "\\leq",
+        "=e=": "=",
+        "*": "\\cdot",
+        "and": "\\wedge",
+        "or": "\\vee",
+        "xor": "\\oplus",
+        "$": "|",
+    }
+
+    # 1. Get nodes in post-order (left - right - parent).
+    s1: list[OperableType | ImplicitEquation | str] = [root_node]
+    post_order_nodes = []
+    while s1:
+        node = s1.pop()
+        post_order_nodes.append(node)
+        if isinstance(node, Expression):
+            if node.left is not None:
+                s1.append(node.left)
+            if node.right is not None:
+                s1.append(node.right)
+
+    # 2. Build the GAMS expression
+    eval_stack: list[tuple[str, Real]] = []
+    for node in reversed(post_order_nodes):
+        if not isinstance(node, Expression):
+            eval_stack.append((get_operand_latex_repr(node), LEAF_PRECEDENCE))
+            continue
+
+        op = node.operator
+        op_prec = PRECEDENCE[op]
+        op_assoc = ASSOCIATIVITY[op]
+
+        # Handle unary ops
+        if op in ("u-", "not"):
+            operand_str, operand_prec = eval_stack.pop()
+
+            # Add parentheses if the operand's operator has lower precedence
+            if operand_prec < op_prec:
+                operand_str = f"({operand_str})"
+
+            if op == "u-":
+                new_str = f"(-{operand_str})"
+                # A parenthesized expression has the highest precedence
+                eval_stack.append((new_str, LEAF_PRECEDENCE))
+            else:  # Standard handling for 'not'
+                new_str = f"not {operand_str}"
+                eval_stack.append((new_str, op_prec))
+
+        # Handle binary ops
+        else:
+            right_str, right_prec = eval_stack.pop()
+            left_str, left_prec = eval_stack.pop()
+
+            if left_prec < op_prec or (
+                left_prec == op_prec and op_assoc == "right"
+            ):
+                left_str = f"({left_str})"
+
+            if right_prec < op_prec or (
+                right_prec == op_prec and op_assoc == "left"
+            ):
+                right_str = f"({right_str})"
+
+            if op == "/":
+                eval_stack.append(
+                    (f"\\frac{{{left_str}}}{{{right_str}}}", op_prec)
+                )
+                continue
+
+            op = op_map.get(op, op)
+
+            # get around 80000 line length limitation in GAMS
+            length = len(left_str) + len(op) + len(right_str)
+            if length >= GMS_MAX_LINE_LENGTH - LINE_LENGTH_OFFSET:
+                new_str = f"{left_str} {op}\n {right_str}"
+            else:
+                new_str = f"{left_str} {op} {right_str}"
+            eval_stack.append((new_str, op_prec))
+
+    final_string = eval_stack[0][0]
+
+    return final_string
+
+
 class Expression(operable.Operable):
     """
     Expression of two operands and an operation.
@@ -62,14 +324,14 @@ class Expression(operable.Operable):
     >>> b = gp.Parameter(m, name="b")
     >>> expression = a * b
     >>> expression.gamsRepr()
-    '(a * b)'
+    'a * b'
 
     """
 
     def __init__(
         self,
         left: OperableType | ImplicitEquation | None,
-        data: str,
+        operator: str,
         right: OperableType | str | None,
     ):
         self.left = (
@@ -77,20 +339,17 @@ class Expression(operable.Operable):
             if isinstance(left, float)
             else left
         )
-        self.data = data
+        self.operator = operator
         self.right = (
             utils._map_special_values(right)
             if isinstance(right, float)
             else right
         )
 
-        if data == "=" and isinstance(right, Expression):
+        if operator == "=" and isinstance(right, Expression):
             right._fix_equalities()
 
-        if get_option("LAZY_EVALUATION"):
-            self._representation = None
-        else:
-            self._representation = self._create_output_str()
+        self._representation: str | None = None
         self.where = condition.Condition(self)
         self._create_domain()
         left_control = getattr(left, "controlled_domain", [])
@@ -107,7 +366,7 @@ class Expression(operable.Operable):
     @property
     def representation(self) -> str:
         if self._representation is None:
-            self._representation = self._create_output_str()
+            self._representation = create_gams_expression(self)
 
         return self._representation
 
@@ -175,7 +434,7 @@ class Expression(operable.Operable):
         left = self.left[left_domain] if left_domain else self.left
         right = self.right[right_domain] if right_domain else self.right
 
-        return Expression(left, self.data, right)
+        return Expression(left, self.operator, right)
 
     @property
     def records(self) -> pd.DataFrame | None:
@@ -266,60 +525,6 @@ class Expression(operable.Operable):
 
         return None
 
-    def _get_operand_representations(self) -> tuple[str, str]:
-        left_str, right_str = "", ""
-        if self.left is not None:
-            left_str = (
-                str(self.left)
-                if isinstance(self.left, (int, float, str))
-                else self.left.gamsRepr()
-            )
-
-        if self.right is not None:
-            right_str = (
-                str(self.right)
-                if isinstance(self.right, (int, float, str))
-                else self.right.gamsRepr()
-            )
-
-        # ((((ord(n) - 1) / 10) * -1) + ((ord(n) / 10) * 0));   -> not valid
-        # ((((ord(n) - 1) / 10) * (-1)) + ((ord(n) / 10) * 0)); -> valid
-        if isinstance(self.left, (int, float)) and self.left < 0:
-            left_str = f"({left_str})"
-
-        if isinstance(self.right, (int, float)) and self.right < 0:
-            right_str = f"({right_str})"
-
-        # (voycap(j,k)$vc(j,k)) .. sum(.) -> not valid
-        #  voycap(j,k)$vc(j,k)  .. sum(.) -> valid
-        if self.data in ("..", "=") and isinstance(
-            self.left, condition.Condition
-        ):
-            left_str = left_str[1:-1]
-
-        return left_str, right_str
-
-    def _create_output_str(self) -> str:
-        left_str, right_str = self._get_operand_representations()
-
-        # get around 80000 line length limitation in GAMS
-        length = len(left_str) + len(self.data) + len(right_str)
-        if length >= GMS_MAX_LINE_LENGTH - LINE_LENGTH_OFFSET:
-            out_str = f"{left_str} {self.data}\n {right_str}"
-        else:
-            out_str = f"{left_str} {self.data} {right_str}"
-
-        if self.data == ".":
-            return out_str.replace(" ", "")
-
-        if self.data in ("..", "="):
-            return f"{out_str};"
-
-        if self.data in ("=g=", "=l=", "=e=", "=n=", "=x=", "=c=", "=b="):
-            return out_str
-
-        return f"({out_str})"
-
     def __eq__(self, other):
         return Expression(self, "=e=", other)
 
@@ -335,13 +540,10 @@ class Expression(operable.Operable):
         )
 
     def __repr__(self) -> str:
-        return f"Expression(left={self.left}, data={self.data}, right={self.right})"
+        return f"Expression(left={self.left}, data={self.operator}, right={self.right})"
 
     def _replace_operator(self, operator: str):
-        self.data = operator
-
-        if not get_option("LAZY_EVALUATION"):
-            self._representation = self._create_output_str()
+        self.operator = operator
 
     def latexRepr(self) -> str:
         """
@@ -351,55 +553,7 @@ class Expression(operable.Operable):
         -------
         str
         """
-        data_map = {
-            "=g=": "\\geq",
-            "=l=": "\\leq",
-            "=e=": "=",
-            "*": "\\cdot",
-            "and": "\\wedge",
-            "or": "\\vee",
-            "xor": "\\oplus",
-            "$": "|",
-        }
-
-        if isinstance(self.left, float):
-            self.left = utils._map_special_values(self.left)
-
-        if isinstance(self.right, float):
-            self.right = utils._map_special_values(self.right)
-
-        if self.left is None:
-            left_str = ""
-        else:
-            left_str = (
-                str(self.left)
-                if isinstance(self.left, (int, float, str))
-                else self.left.latexRepr()  # type: ignore
-            )
-
-        if self.right is None:
-            right_str = ""
-        else:
-            right_str = (
-                str(self.right)
-                if isinstance(self.right, (int, float, str))
-                else self.right.latexRepr()  # type: ignore
-            )
-
-        data = self.data
-        if isinstance(self.data, str):
-            data = data_map.get(self.data, self.data)
-
-        data_str = (
-            str(data)
-            if isinstance(data, (int, float, str))
-            else data.latexRepr()
-        )
-
-        if self.data == "/":
-            return f"\\frac{{{left_str}}}{{{right_str}}}"
-
-        return f"({left_str} {data_str} {right_str})"
+        return create_latex_expression(self)
 
     def gamsRepr(self) -> str:
         """
@@ -417,7 +571,7 @@ class Expression(operable.Operable):
         >>> b = gp.Parameter(m, name="b")
         >>> expression = a * b
         >>> expression.gamsRepr()
-        '(a * b)'
+        'a * b'
 
         """
         return self.representation
@@ -438,7 +592,7 @@ class Expression(operable.Operable):
         >>> b = gp.Parameter(m, name="b")
         >>> expression = a * b
         >>> expression.getDeclaration()
-        '(a * b)'
+        'a * b'
 
         """
         return self.gamsRepr()
@@ -465,12 +619,8 @@ class Expression(operable.Operable):
 
             root = stack.pop()
 
-            if isinstance(root, Expression):
-                if root.data in EQ_MAP:
-                    root._replace_operator(EQ_MAP[root.data])
-                else:
-                    if not get_option("LAZY_EVALUATION"):
-                        root._representation = root._create_output_str()
+            if isinstance(root, Expression) and root.operator in EQ_MAP:
+                root._replace_operator(EQ_MAP[root.operator])
 
             last_item = peek(stack)
             if (
@@ -500,6 +650,9 @@ class Expression(operable.Operable):
 
                 if isinstance(node, Symbol):
                     if node.name not in symbols:
+                        if type(node) is gp_syms.Alias:
+                            symbols.append(node.alias_with.name)
+
                         symbols.append(node.name)
                     stack += node.domain
                     node = None
@@ -633,7 +786,7 @@ class SetExpression(Expression):
                     self.right = "yes"
                 else:
                     raise ValidationError(
-                        f"Incompatible operand `{self.right}` for the set operation `{self.data}`."
+                        f"Incompatible operand `{self.right}` for the set operation `{self.operator}`."
                     )
             elif isinstance(self.right, condition.Condition) and isinstance(
                 self.right.conditioning_on, number.Number
@@ -643,7 +796,7 @@ class SetExpression(Expression):
                 elif self.right.conditioning_on._value == 1:
                     self.right.conditioning_on._value = "yes"
                 raise ValidationError(
-                    f"Incompatible operand `{self.right}` for the set operation `{self.data}`."
+                    f"Incompatible operand `{self.right}` for the set operation `{self.operator}`."
                 )
 
         if isinstance(self.right, (ImplicitSet, SetExpression)):
@@ -654,7 +807,7 @@ class SetExpression(Expression):
                     self.left = "yes"
                 else:
                     raise ValidationError(
-                        f"Incompatible operand `{self.left}` for the set operation `{self.data}`."
+                        f"Incompatible operand `{self.left}` for the set operation `{self.operator}`."
                     )
             elif isinstance(self.left, condition.Condition) and isinstance(
                 self.left.conditioning_on, number.Number
@@ -665,8 +818,5 @@ class SetExpression(Expression):
                     self.left.conditioning_on._value = "yes"
                 else:
                     raise ValidationError(
-                        f"Incompatible operand `{self.left}` for the set operation `{self.data}`."
+                        f"Incompatible operand `{self.left}` for the set operation `{self.operator}`."
                     )
-
-        if not get_option("LAZY_EVALUATION"):
-            self._representation = self._create_output_str()

{gamspy-1.14.0 → gamspy-1.15.1}/src/gamspy/_algebra/operable.py

@@ -76,7 +76,7 @@ class Operable:
         return expression.Expression(other, "-", self)
 
     def __neg__(self):
-        return expression.Expression(None, "-", self)
+        return expression.Expression(None, "u-", self)
 
     def __truediv__(self, other: OperableType):
         return expression.Expression(self, "/", other)

{gamspy-1.14.0 → gamspy-1.15.1}/src/gamspy/_algebra/operation.py

@@ -176,14 +176,7 @@ class Operation(operable.Operable):
 
     def _get_index_str(self) -> str:
         if len(self.op_domain) == 1:
-            op_domain = self.op_domain[0]
-            representation = op_domain.gamsRepr()
-            if isinstance(op_domain, condition.Condition):
-                # sum((l(root,s,s1,s2) $ od(root,s)),1); -> not valid
-                # sum(l(root,s,s1,s2) $ od(root,s),1); -> valid
-                return representation[1:-1]
-
-            return representation
+            return self.op_domain[0].gamsRepr()
 
         return (
             "("
@@ -274,7 +267,7 @@ class Operation(operable.Operable):
             else self.rhs.latexRepr()
         )
         representation = (
-            f"\\{op_map[self._op_name]}_\\text{{{index_str}}} {expression_str}"
+            f"\\{op_map[self._op_name]}_{{{index_str}}} {expression_str}"
         )
         return representation
 
@@ -348,7 +341,7 @@ class Sum(Operation):
         >>> c = Parameter(m, "c", domain=i)
         >>> v = Variable(m, "v", domain=i)
         >>> Sum(i, c[i]*v[i]).gamsRepr()
-        'sum(i,(c(i) * v(i)))'
+        'sum(i,c(i) * v(i))'
 
         """
         repr = super().gamsRepr()
@@ -424,7 +417,7 @@ class Product(Operation):
         >>> c = Parameter(m, "c", domain=i)
         >>> v = Variable(m, "v", domain=i)
         >>> Product(i, c[i]*v[i]).gamsRepr()
-        'prod(i,(c(i) * v(i)))'
+        'prod(i,c(i) * v(i))'
 
         """
         repr = super().gamsRepr()
@@ -500,7 +493,7 @@ class Smin(Operation):
         >>> c = Parameter(m, "c", domain=i)
         >>> v = Variable(m, "v", domain=i)
         >>> Smin(i, c[i]*v[i]).gamsRepr()
-        'smin(i,(c(i) * v(i)))'
+        'smin(i,c(i) * v(i))'
 
         """
         repr = super().gamsRepr()
@@ -576,7 +569,7 @@ class Smax(Operation):
         >>> c = Parameter(m, "c", domain=i)
         >>> v = Variable(m, "v", domain=i)
         >>> Smax(i, c[i]*v[i]).gamsRepr()
-        'smax(i,(c(i) * v(i)))'
+        'smax(i,c(i) * v(i))'
 
         """
         repr = super().gamsRepr()