gamspy 1.18.1__py3-none-any.whl → 1.18.3__py3-none-any.whl

gamspy/_algebra/domain.py

@@ -90,4 +90,4 @@ class Domain:
         -------
         str
         """
-        return utils._get_domain_str(self.sets)[1:-1]
+        return utils._get_domain_str(self.sets, latex=True)[1:-1]

gamspy/_algebra/expression.py

@@ -234,7 +234,7 @@ def create_latex_expression(root_node: Expression) -> str:
             if node.right is not None:
                 s1.append(node.right)
 
-    # 2. Build the GAMS expression
+    # 2. Build the LaTeX expression
     eval_stack: list[tuple[str, float]] = []
     for node in reversed(post_order_nodes):
         if not isinstance(node, Expression):

gamspy/_algebra/operation.py

@@ -96,8 +96,15 @@ class Operation(operable.Operable):
         """
         assert self.container is not None
         temp_name = "a" + utils._get_unique_name()
+        domain: list[Set | Alias] = []
+        for elem in self.domain:
+            if hasattr(elem, "dimension") and elem.dimension > 1:
+                domain.extend(elem.domain)
+            else:
+                domain.append(elem)
+
         temp_param = syms.Parameter._constructor_bypass(
-            self.container, temp_name, self.domain
+            self.container, temp_name, domain
         )
         temp_param[...] = self
         del self.container.data[temp_name]
@@ -756,7 +763,7 @@ class Ord(operable.Operable):
         -------
         str
         """
-        return f"ord({self._symbol.name})"
+        return f"ord({self._symbol._latex_name})"
 
 
 class Card(operable.Operable):
@@ -835,4 +842,4 @@ class Card(operable.Operable):
         -------
         str
         """
-        return f"card({self._symbol.name})"
+        return f"card({self._symbol._latex_name})"

gamspy/_cli/cli.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import typer
 
-from . import gdx, install, list, probe, retrieve, run, show, uninstall
+from . import gdx, install, list, mps2gms, probe, retrieve, run, show, uninstall
 
 app = typer.Typer(
     rich_markup_mode="rich",
@@ -16,6 +16,7 @@ app.add_typer(retrieve.app, name="retrieve")
 app.add_typer(run.app, name="run")
 app.add_typer(show.app, name="show")
 app.add_typer(uninstall.app, name="uninstall")
+app.command(name="mps2gms")(mps2gms.mps2gms)
 
 
 def version_callback(value: bool):

gamspy/_cli/mps2gms.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import os
+import platform
+import subprocess
+from pathlib import Path  # noqa: TC003
+from typing import Annotated
+
+import gamspy_base
+import typer
+
+# Valid values for categorical parameters based on help string
+VALID_YN = {"0", "N", "1", "Y"}
+VALID_DUPLICATES = {"NOCHECK", "ADD", "IGNORE", "ERROR"}
+VALID_ORIGNAMES = {"NO", "MODIFIED", "ALL"}
+VALID_CONVERTSENSE = {"0", "N", "1", "Y", "MIN", "-1", "MAX"}
+
+
+# Completion functions for Typer
+def complete_yn(ctx: typer.Context, incomplete: str):
+    return [v for v in VALID_YN if v.lower().startswith(incomplete.lower())]
+
+
+def complete_duplicates(ctx: typer.Context, incomplete: str):
+    return [v for v in VALID_DUPLICATES if v.lower().startswith(incomplete.lower())]
+
+
+def complete_orignames(ctx: typer.Context, incomplete: str):
+    return [v for v in VALID_ORIGNAMES if v.lower().startswith(incomplete.lower())]
+
+
+def complete_convertsense(ctx: typer.Context, incomplete: str):
+    return [v for v in VALID_CONVERTSENSE if v.lower().startswith(incomplete.lower())]
+
+
+def mps2gms(
+    input_file: Annotated[
+        Path, typer.Argument(help="MPS or LP file to translate.", exists=True)
+    ],
+    gdx_file: Annotated[
+        Path | None, typer.Argument(help="Name of GDX output file.")
+    ] = None,
+    gms_file: Annotated[
+        Path | None, typer.Argument(help="Name of GAMS program output file.")
+    ] = None,
+    py_file: Annotated[
+        str | None, typer.Option("--py", help="Name of GAMSPy program output file.")
+    ] = None,
+    dec_file: Annotated[
+        str | None, typer.Option("--dec", help="DEC file for decomposition info.")
+    ] = None,
+    column_int_vars_binary: Annotated[
+        str | None,
+        typer.Option(
+            "--columnintvarsarebinary",
+            help="Integer variables appearing first are binary.",
+            autocompletion=complete_yn,
+        ),
+    ] = None,
+    duplicates: Annotated[
+        str | None,
+        typer.Option(
+            help="How to handle multiple coefficients.",
+            autocompletion=complete_duplicates,
+        ),
+    ] = None,
+    orignames: Annotated[
+        str | None,
+        typer.Option(
+            help="Whether to make original names available.",
+            autocompletion=complete_orignames,
+        ),
+    ] = None,
+    stageshift: Annotated[
+        int | None, typer.Option(help="Shift block numbers by this integer.")
+    ] = None,
+    convertsense: Annotated[
+        str | None,
+        typer.Option(
+            help="Convert the objective function sense.",
+            autocompletion=complete_convertsense,
+        ),
+    ] = None,
+):
+    """
+    Translates an MPS or LP file into equivalent generic GAMS and GAMSPy programs.
+    Defaults to writing .py and .gdx files if no outputs are specified.
+    """
+    binary_name = "mps2gms.exe" if platform.system() == "Windows" else "mps2gms"
+    MPS2GMS_PATH = os.path.join(gamspy_base.directory, binary_name)
+
+    if not os.path.exists(MPS2GMS_PATH):
+        typer.echo(f"Binary not found: {MPS2GMS_PATH}", err=True)
+        raise typer.Exit(code=1)
+
+    # Determine default names based on input stem
+    input_name = input_file.with_suffix("")
+    actual_gdx = gdx_file if gdx_file else f"{input_name}.gdx"
+    actual_py = py_file if py_file else f"{input_name}.py"
+
+    # mps2gms <input> <gdx>
+    cmd = [MPS2GMS_PATH, str(input_file), str(actual_gdx)]
+
+    # If gms_file is provided, add it as the third positional;
+    # otherwise, explicitly disable GMS output to prioritize py/gdx.
+    if gms_file:
+        cmd.append(str(gms_file))
+    else:
+        cmd.append("GMS=")
+
+    # Construct key=value parameters for the binary call
+    params = {
+        "PY": actual_py,
+        "DEC": dec_file,
+        "COLUMNINTVARSAREBINARY": column_int_vars_binary,
+        "DUPLICATES": duplicates,
+        "ORIGNAMES": orignames,
+        "STAGESHIFT": stageshift,
+        "CONVERTSENSE": convertsense,
+    }
+
+    for key, value in params.items():
+        if value is not None:
+            cmd.append(f"{key}={value}")
+
+    print(f"Running command: {' '.join(cmd)}")
+    result = subprocess.run(cmd, text=True)
+    raise typer.Exit(code=result.returncode)

gamspy/_container.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import atexit
 import os
 import platform
+import re
 import shutil
 import signal
 import sys
@@ -42,6 +43,7 @@ if TYPE_CHECKING:
         Model,
         Parameter,
         Set,
+        UniverseAlias,
         Variable,
     )
     from gamspy._algebra.expression import Expression
@@ -139,6 +141,7 @@ class Container(gt.Container):
         self.output = output
         self._gams_string = ""
         self.models: dict[str, Model] = {}
+        self._mpsge_models: list[str] = []
         if IS_MIRO_INIT:
             atexit.register(self._write_miro_files)
 
@@ -838,6 +841,14 @@ class Container(gt.Container):
 
         for _, symbol in self:
             symbol.modified = False
+
+        # Unfortunately MPSGE requires a dirty trick
+        pattern = re.compile(r"^\$sysInclude\s+mpsgeset\s+(\w+)\s*$", re.MULTILINE)
+        match = pattern.search(gams_code)
+        if match:
+            model_name = match.group(1)
+            self._mpsge_models.append(model_name.lower())
+
         self._unsaved_statements = []
 
     def close(self) -> None:
@@ -888,6 +899,37 @@ class Container(gt.Container):
 
         return gp.Alias(self, name, alias_with)
 
+    def addUniverseAlias(self, name: str | None = None) -> UniverseAlias:
+        """
+        Creates a new UniverseAlias and adds it to the container
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the universe alias.
+
+        Returns
+        -------
+        UniverseAlias
+
+        Raises
+        ------
+        ValueError
+            If there is symbol with same name but different type in the
+            Container
+
+        Examples
+        --------
+        >>> import gamspy as gp
+        >>> m = gp.Container()
+        >>> a = m.addUniverseAlias("a")
+
+        """
+        if name is None:
+            name = self._get_symbol_name(prefix="u")
+
+        return gp.UniverseAlias(self, name)
+
     def addSet(
         self,
         name: str | None = None,
@@ -1099,7 +1141,7 @@ class Container(gt.Container):
         self,
         name: str | None = None,
         type: str | EquationType = "regular",
-        domain: Sequence[Set | Alias | str] | Set | Alias | str | None = None,
+        domain: Sequence[Set | Alias] | Set | Alias | None = None,
         definition: Variable | Operation | Expression | None = None,
         records: Any | None = None,
         domain_forwarding: bool | list[bool] = False,
@@ -1117,7 +1159,7 @@ class Container(gt.Container):
             Name of the equation. Name is autogenerated by default.
         type : str
             Type of the equation. "regular" by default.
-        domain : Sequence[Set | Alias | str] | Set | Alias | str, optional
+        domain : Sequence[Set | Alias] | Set | Alias, optional
             Domain of the variable.
         definition: Expression, optional
             Definition of the equation.

gamspy/_convert.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 import os
 import subprocess
 from collections.abc import Sequence
@@ -28,14 +27,6 @@ if TYPE_CHECKING:
 
     SymbolType: TypeAlias = Alias | Set | Parameter | Variable | Equation
 
-logger = logging.getLogger("CONVERTER")
-logger.setLevel(logging.INFO)
-stream_handler = logging.StreamHandler()
-stream_handler.setLevel(logging.INFO)
-formatter = logging.Formatter("[%(name)s - %(levelname)s] %(message)s")
-stream_handler.setFormatter(formatter)
-logger.addHandler(stream_handler)
-
 GAMS_JACOBIAN_TEMPLATE = """$onEmpty
 Set
    i        'equations index'
@@ -388,9 +379,9 @@ class GamsConverter:
         self.path = path
         self.options = options
         self.dump_gams_state = dump_gams_state
-        self.gdx_path = str((path / f"{model.name}_data.gdx").resolve())
-        self.gms_path = str((path / f"{model.name}.gms").resolve())
-        self.g00_path = str((path / f"{model.name}.g00").resolve())
+        self.gdx_path = path / f"{model.name}_data.gdx"
+        self.gms_path = path / f"{model.name}.gms"
+        self.g00_path = path / f"{model.name}.g00"
 
     def get_definitions(self) -> list[str]:
         definitions = []
@@ -438,8 +429,8 @@ class GamsConverter:
             em_name = self.model._external_module
             em_file = self.model._external_module_file
             declarations.append(f"File {em_file} /{em_name}/;")
-            logger.info("Converter will not copy external module files")
-            logger.info(
+            print("Converter will not copy external module files")
+            print(
                 f"You need to ensure your external module is accessible from {self.path}"
             )
 
@@ -482,7 +473,9 @@ class GamsConverter:
         with open(self.gms_path, "w", encoding="utf-8") as file:
             file.write(gams_string)
 
-        logger.info(f"GAMS (.gms) file has been generated under {self.gms_path}")
+        print("=" * 80)
+        print(f"GAMS (.gms) file has been generated under {self.gms_path}")
+        print("=" * 80)
 
 
 TABLE_HEADER = """\\begin{tabularx}{\\textwidth}{| l | l | X |}
@@ -496,7 +489,7 @@ TABLE_FOOTER = "\\hline\n\\end{tabularx}"
 
 
 class LatexConverter:
-    def __init__(self, model: Model, path: Path) -> None:
+    def __init__(self, model: Model, path: Path, rename: dict[str, str] | None) -> None:
         os.makedirs(path, exist_ok=True)
         self.model = model
         self.container = model.container
@@ -512,11 +505,21 @@ class LatexConverter:
                     ):
                         symbols.append(elem.name)
 
+        for name in self.model._autogen_symbols:
+            if name in symbols:
+                symbols.remove(name)
+
         self.symbols = sorted(symbols, key=list(self.container.data.keys()).index)
 
-        for name in self.model._autogen_symbols:
-            if name in self.symbols:
-                self.symbols.remove(name)
+        if rename is not None:
+            for name, latex_name in rename.items():
+                try:
+                    symbol = self.container[name]
+                    symbol._latex_name = latex_name
+                except KeyError as e:
+                    raise KeyError(
+                        f"`{name}` does not exist in the Container. You can only rename symbols that already exist in the container."
+                    ) from e
 
         self.header = self.get_header()
         self.set_header = "\\subsection*{Sets}"
@@ -551,8 +554,9 @@ class LatexConverter:
         if self.model._objective is None:
             ...
         elif isinstance(self.model._objective, syms.Variable):
+            var_name = self.model._objective._latex_name
             latex_strs.append(
-                f"\\textbf{{{str(self.model.sense).lower()}}} ${self.model._objective_variable.name}$\\\\"  # type: ignore
+                f"\\textbf{{{str(self.model.sense).lower()}}} ${var_name}$\\\\"
             )
             latex_strs.append("\\textbf{s.t.}")
         else:
@@ -572,26 +576,35 @@ class LatexConverter:
         with open(self.tex_path, "w", encoding="utf-8") as file:  # Write the TEX file
             file.write(latex_str)
 
-        logger.info(
+        print("=" * 80)
+        print(
             f"LaTeX (.tex) file has been generated under {os.path.join(self.path, self.model.name + '.tex')}"
         )
+        print("=" * 80)
 
         self.latex_str = latex_str
 
     def to_pdf(self) -> None:
-        process = subprocess.run(["pdflatex", "-v"])
-        if process.returncode:
+        try:
+            subprocess.run(["xelatex", "-version"], check=True, text=True)
+        except subprocess.CalledProcessError as e:
             raise ValidationError(
-                "`pdflatex` is required to generate the pdf! Please install `pdflatex` and add it to the path."
+                "`xelatex` is required to generate the pdf! Please install `xelatex` and add it to the path."
+            ) from e
+
+        try:
+            subprocess.run(
+                [
+                    "xelatex",
+                    "-verbose",
+                    f"-output-directory={self.path}",
+                    self.tex_path,
+                ],
+                check=True,
+                text=True,
             )
-
-        process = subprocess.run(
-            ["pdflatex", f"-output-directory={self.path}", self.tex_path],
-            capture_output=True,
-            text=True,
-        )
-        if process.returncode:
-            raise LatexException(f"Could not generate pdf file: {process.stderr}")
+        except subprocess.CalledProcessError as e:
+            raise LatexException(f"Could not generate pdf file: {e}") from e
 
     def get_table(self, symbol_type) -> str:
         table = [TABLE_HEADER]
@@ -604,10 +617,11 @@ class LatexConverter:
                 if isinstance(symbol, syms.Variable) and self.model._limited_variables:
                     for elem in self.model._limited_variables:
                         if elem.name == symbol.name:
-                            domain_str = utils._get_domain_str(elem.domain)[1:-1]
+                            domain_str = utils._get_domain_str(elem.domain, latex=True)[
+                                1:-1
+                            ]
 
-                row = f"{summary['name']} & {domain_str} & {summary['description']}\\\\"
-                row = row.replace("_", "\\_")
+                row = f"{symbol._latex_name} & {domain_str} & {summary['description']}\\\\"
                 table.append(row)
 
         table.append(TABLE_FOOTER)
@@ -615,16 +629,16 @@ class LatexConverter:
         return "\n".join(table)
 
     def get_definitions(self) -> str:
-        definitions = []
+        definitions: list[str] = []
         for equation in self.model.equations:
             if equation.name in self.model._autogen_symbols:
                 continue
 
-            domain_str = ",".join([elem.name for elem in equation.domain])
-            header = "\\subsubsection*{$" + equation.name.replace("_", "\\_")
+            domain_str = ",".join([elem.latexRepr() for elem in equation.domain])
+            header = "\\subsubsection*{" + equation._latex_name
             if domain_str:
-                header += f"_{{{domain_str}}}"
-            header += "$}\n"
+                header += f"$_{{{domain_str}}}$"
+            header += "}\n"
 
             footer = "\n\\vspace{5pt}\n\\hrule"
             latex_repr = f"{header}{equation.latexRepr()}{footer}"
@@ -633,28 +647,41 @@ class LatexConverter:
         return "\n".join(definitions)
 
     def get_constraints(self) -> str:
-        constraints = ["\\bigskip"]
+        constraints = [r"\begin{flalign*}"]
         for name in self.symbols:
             symbol = self.container[name]
             if not isinstance(symbol, syms.Variable):
                 continue
 
-            constraint = "$" + symbol.latexRepr()
+            constraint = "&" + symbol.latexRepr()
             if symbol.type == "binary":
-                constraint += (
-                    "\\in "
-                    + r"\{0,1\}"
-                    + " ~ \\forall "
-                    + ",".join(symbol.domain_names)
-                )
+                constraint += "\\in " + r"\{0,1\}"
+                if symbol.domain:
+                    constraint += (
+                        " ~ \\forall "
+                        + utils._get_domain_str(symbol.domain, latex=True)[1:-1]
+                    )
             elif symbol.type == "integer":
-                constraint += "\\in \\mathbb{Z}_{+} \\forall " + ",".join(
-                    symbol.domain_names
-                )
+                constraint += "\\in \\mathbb{Z}_{+}"
+                if symbol.domain:
+                    constraint += (
+                        " ~ \\forall "
+                        + utils._get_domain_str(symbol.domain, latex=True)[1:-1]
+                    )
             elif symbol.type == "positive":
-                constraint += "\\geq 0 ~ \\forall " + ",".join(symbol.domain_names)
+                constraint += "\\geq 0"
+                if symbol.domain:
+                    constraint += (
+                        " ~ \\forall "
+                        + utils._get_domain_str(symbol.domain, latex=True)[1:-1]
+                    )
             elif symbol.type == "negative":
-                constraint += "\\leq 0 ~ \\forall " + ",".join(symbol.domain_names)
+                constraint += "\\leq 0"
+                if symbol.domain:
+                    constraint += (
+                        " ~ \\forall "
+                        + utils._get_domain_str(symbol.domain, latex=True)[1:-1]
+                    )
             elif symbol.type == "sos1":
                 constraint += "SOS1"
             elif symbol.type == "sos2":
@@ -666,24 +693,28 @@ class LatexConverter:
             else:
                 continue
 
-            constraint += "\\\\$"
+            constraint += "&\\\\"
             constraints.append(constraint)
 
+        constraints.append(r"\end{flalign*}")
         return "\n".join(constraints)
 
     def get_header(self) -> str:
-        header = """\\documentclass[11pt]{article}
-\\usepackage{geometry}
-\\usepackage[american]{babel}
-\\usepackage{amsmath}
-\\usepackage{amssymb}
-\\usepackage[hidelinks]{hyperref}
-\\usepackage{tabularx}
-\\usepackage{ltablex}
-\\keepXColumns
-
-\\begin{document}
-\\section*{Symbols}
+        header = r"""\documentclass[11pt]{article}
+\usepackage{geometry}
+\usepackage[american]{babel}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\usepackage{fontspec}
+\setmainfont{CMU Serif} % 1. Sets a font that knows Greek in text mode
+\usepackage{unicode-math} % 2. Allows Greek keys to work in math mode
+\usepackage[hidelinks]{hyperref}
+\usepackage{tabularx}
+\usepackage{ltablex}
+\keepXColumns
+
+\begin{document}
+\section*{Symbols}
 
 """
         return header

gamspy/_extrinsic.py

@@ -120,7 +120,23 @@ class ExtrinsicFunction(operable.Operable):
         -------
         str
         """
-        return self.gamsRepr()
+        representation = self.name.replace("_", r"\_")
+
+        if self.args:
+            arg_strs = []
+            for arg in self.args:
+                arg_str = (
+                    str(arg).replace("_", r"\_")
+                    if isinstance(arg, (int, float, str))
+                    else arg.latexRepr()
+                )
+                arg_strs.append(arg_str)
+
+            args = ",".join(arg_strs)
+
+            representation = f"{representation}({args})"
+
+        return representation
 
 
 class ExtrinsicLibrary:

gamspy/_model.py

@@ -114,9 +114,6 @@ class Problem(Enum):
     EMP = "EMP"
     """Extended Mathematical Program"""
 
-    MPSGE = "MPSGE"
-    """General Equilibrium"""
-
     @classmethod
     def values(cls):
         """Convenience function to return all values of enum"""
@@ -371,7 +368,7 @@ class Model:
     equations : Sequence[Equation]
         Sequence of Equation objects.
     problem : Problem | str, optional
-        'LP', 'NLP', 'QCP', 'DNLP', 'MIP', 'RMIP', 'MINLP', 'RMINLP', 'MIQCP', 'RMIQCP', 'MCP', 'CNS', 'MPEC', 'RMPEC', 'EMP', or 'MPSGE',
+        'LP', 'NLP', 'QCP', 'DNLP', 'MIP', 'RMIP', 'MINLP', 'RMINLP', 'MIQCP', 'RMIQCP', 'MCP', 'CNS', 'MPEC', 'RMPEC', 'EMP',
         by default Problem.LP.
     sense : Sense | str, optional
         "MIN", "MAX", or "FEASIBILITY". By default, Sense.FEASIBILITY
@@ -396,7 +393,7 @@ class Model:
 
     # Prefix for auto-generated symbols
     _generate_prefix = "autogenerated_"
-    _autogen_symbols: ClassVar[set[Variable | Equation]] = set()
+    _autogen_symbols: ClassVar[set[str]] = set()
 
     def __init__(
         self,
@@ -415,6 +412,7 @@ class Model:
         limited_variables: Sequence[ImplicitVariable] | None = None,
         external_module: str | None = None,
     ):
+        self._is_mpsge = False
         self._auto_id = "m" + utils._get_unique_name()
         if equations is None:
             equations = []
@@ -1213,8 +1211,8 @@ class Model:
         >>> v = gp.Variable(m, "v")
         >>> e = gp.Equation(m, "e", definition= v == 5)
         >>> my_model = gp.Model(m, "my_model", problem="LP", equations=[e])
-        >>> my_model.convert("output_directory", gp.FileFormat.GAMS)
-        >>> my_model.convert("output_directory", [gp.FileFormat.GAMS, gp.FileFormat.AMPL])
+        >>> my_model.convert("tmp", gp.FileFormat.GAMS)
+        >>> my_model.convert("tmp", [gp.FileFormat.GAMS, gp.FileFormat.AMPL])
 
         """
         path = Path(path)
@@ -1553,6 +1551,19 @@ class Model:
         ------
         ValidationError
             In case the given options is not of type gp.Options.
+
+        Examples
+        --------
+        >>> import gamspy as gp
+        >>> m = gp.Container()
+        >>> v = gp.Variable(m, "v")
+        >>> e = gp.Equation(m, "e", definition= v == 5)
+        >>> my_model = gp.Model(m, "my_model", problem="LP", equations=[e])
+        >>> my_model.toGams("tmp")  # doctest: +ELLIPSIS
+        ================================================================================
+        GAMS (.gms) file has been generated under ...
+        ================================================================================
+
         """
         if options is not None and not isinstance(options, gp.Options):
             raise ValidationError(
@@ -1563,7 +1574,13 @@ class Model:
         converter = GamsConverter(self, path, options, dump_gams_state)
         converter.convert()
 
-    def toLatex(self, path: str | Path, generate_pdf: bool = False) -> None:
+    def toLatex(
+        self,
+        path: str | Path,
+        rename: dict[str, str] | None = None,
+        *,
+        generate_pdf: bool = False,
+    ) -> None:
         """
         Generates a latex file that contains the model definition under path/<model_name>.tex
 
@@ -1571,9 +1588,27 @@ class Model:
         ----------
         path : str | Path
             Path to the directory which will contain the .tex file.
+        rename: dict[str, str], optional
+            A dictionary to rename symbols in the LaTeX file. Keys are GAMSPy symbol names
+            and values are the names that will be used in the LaTeX file.
+        generate_pdf: bool, False by default
+            Generates a pdf file if it is set. Requires pdflatex to be installed.
+
+        Examples
+        --------
+        >>> import gamspy as gp
+        >>> m = gp.Container()
+        >>> v = gp.Variable(m, "v")
+        >>> e = gp.Equation(m, "e", definition= v == 5)
+        >>> my_model = gp.Model(m, "my_model", problem="LP", equations=[e])
+        >>> my_model.toLatex("tmp")  # doctest: +ELLIPSIS
+        ================================================================================
+        LaTeX (.tex) file has been generated under ...
+        ================================================================================
+
         """
         path = Path(path)
-        converter = LatexConverter(self, path)
+        converter = LatexConverter(self, path, rename)
         converter.convert()
 
         if generate_pdf:

gamspy/_symbols/alias.py

@@ -72,6 +72,7 @@ class Alias(gt.Alias, operable.Operable, Symbol, SetMixin):
 
         # gamspy attributes
         obj.where = condition.Condition(obj)
+        obj._latex_name = name.replace("_", r"\_")
         obj.container._add_statement(obj)
         obj._metadata = {}
 
@@ -145,6 +146,7 @@ class Alias(gt.Alias, operable.Operable, Symbol, SetMixin):
                 name = container._get_symbol_name(prefix="a")
 
             super().__init__(container, name, alias_with)
+            self._latex_name = self.name.replace("_", r"\_")
 
             validation.validate_container(self, self.domain)
             self.where = condition.Condition(self)

gamspy/_symbols/equation.py

@@ -160,6 +160,7 @@ class Equation(gt.Equation, Symbol):
         # gamspy attributes
         obj._definition = None
         obj.where = condition.Condition(obj)
+        obj._latex_name = name.replace("_", r"\_")
         obj.container._add_statement(obj)
         obj._synchronize = True
         obj._metadata = {}
@@ -225,7 +226,7 @@ class Equation(gt.Equation, Symbol):
         container: Container | None = None,
         name: str | None = None,
         type: str | EquationType = "regular",
-        domain: Sequence[Set | Alias | str] | Set | Alias | str | None = None,
+        domain: Sequence[Set | Alias] | Set | Alias | None = None,
         definition: Variable | Operation | Expression | None = None,
         records: Any | None = None,
         domain_forwarding: bool | list[bool] = False,
@@ -250,7 +251,7 @@ class Equation(gt.Equation, Symbol):
         if domain is None:
             domain = []
 
-        if isinstance(domain, (gp.Set, gp.Alias, str)):
+        if isinstance(domain, (gp.Set, gp.Alias)):
             domain = [domain]
 
         if isinstance(domain, gp.math.Dim):
@@ -330,6 +331,7 @@ class Equation(gt.Equation, Symbol):
                 description=description,
                 uels_on_axes=uels_on_axes,
             )
+            self._latex_name = self.name.replace("_", r"\_")
 
             if is_miro_output:
                 container._miro_output_symbols.append(self.name)
@@ -532,7 +534,7 @@ class Equation(gt.Equation, Symbol):
             eq_type in rhs_repr for eq_type in EQ_TYPES
         ):
             # x - c -> x - c == 0
-            rhs = rhs == 0
+            rhs = rhs == gp.Number(0)
 
         rhs_repr = rhs.gamsRepr()
         if not any(eq_type in rhs_repr for eq_type in EQ_TYPES):
@@ -1143,6 +1145,8 @@ class Equation(gt.Equation, Symbol):
                 "Equation must be defined to get its latex representation."
             )
 
+        # The LHS of an equation definition can either be an ImplicitEquation or a condition.
+        # e.g. e[i] = ... or e[i].where[b[i]] = ...
         assert isinstance(
             self._definition.left,
             (implicits.ImplicitEquation, condition.Condition),
@@ -1152,21 +1156,25 @@ class Equation(gt.Equation, Symbol):
         if isinstance(self._definition.left, implicits.ImplicitEquation):
             if len(self._definition.left.domain) > 0:
                 domain_str = ",".join(
-                    [symbol.name for symbol in self._definition.left.domain]
+                    [symbol.latexRepr() for symbol in self._definition.left.domain]
                 )
                 right_side = f"\\hfill \\forall {domain_str}"
         else:
             domain_str = ",".join(
                 [
-                    symbol.name
+                    symbol.latexRepr()
                     for symbol in self._definition.left.conditioning_on.domain  # type: ignore
                 ]
             )
             domain_str = f"\\forall {domain_str}"
 
-            constraint_str = str(self._definition.left.condition)
+            assert self._definition.left.condition is not None
             if hasattr(self._definition.left.condition, "latexRepr"):
-                constraint_str = self._definition.left.condition.latexRepr()  # type: ignore
+                constraint_str = self._definition.left.condition.latexRepr()
+            else:
+                assert isinstance(self._definition.left.condition, (int, float))
+                constraint_str = str(self._definition.left.condition)
+
             right_side = f"\\hfill {domain_str} ~ | ~ {constraint_str}"
 
         assert self._definition.right is not None

gamspy/_symbols/implicits/implicit_set.py

@@ -83,7 +83,7 @@ class ImplicitSet(ImplicitSymbol, operable.Operable):
         return temp_param.records
 
     def latexRepr(self):
-        name = self.name.replace("_", "\\_")
+        name = self._latex_name
         representation = name
 
         if self.extension is not None:
@@ -100,6 +100,7 @@ class ImplicitSet(ImplicitSymbol, operable.Operable):
                 if isinstance(elem, (syms.Set, syms.Alias, ImplicitSet)):
                     set_strs.append(elem.latexRepr())
                 elif isinstance(elem, str):
+                    elem = elem.replace("_", r"\_")
                     set_strs.append(f"\\textquotesingle {elem} \\textquotesingle")
 
             domain_str = "{" + ",".join(set_strs) + "}"

gamspy/_symbols/implicits/implicit_symbol.py

@@ -46,6 +46,10 @@ class ImplicitSymbol(ABC):
 
         self.fix_domain_scalars(parent_scalar_domains)
 
+    @property
+    def _latex_name(self) -> str:
+        return self.parent._latex_name
+
     def __bool__(self):
         raise ValidationError("A symbol cannot be used as a truth value.")
 
@@ -101,7 +105,7 @@ class ImplicitSymbol(ABC):
     def latexRepr(self):
         from .implicit_set import ImplicitSet
 
-        name = self.name.replace("_", "\\_")
+        name = self._latex_name
         representation = name
         domain = list(self.domain)
 
@@ -114,6 +118,7 @@ class ImplicitSymbol(ABC):
                 if isinstance(elem, (gp.Set, gp.Alias, ImplicitSet)):
                     set_strs.append(elem.latexRepr())
                 elif isinstance(elem, str):
+                    elem = elem.replace("_", r"\_")
                     set_strs.append(f"\\textquotesingle {elem} \\textquotesingle")
 
             domain_str = "{" + ",".join(set_strs) + "}"

gamspy/_symbols/parameter.py

@@ -113,6 +113,7 @@ class Parameter(gt.Parameter, operable.Operable, Symbol):
         # gamspy attributes
         obj._synchronize = True
         obj.where = condition.Condition(obj)
+        obj._latex_name = name.replace("_", r"\_")
         obj.container._add_statement(obj)
         obj._metadata = {}
         obj._winner = "python"
@@ -263,6 +264,7 @@ class Parameter(gt.Parameter, operable.Operable, Symbol):
                 description=description,
                 uels_on_axes=uels_on_axes,
             )
+            self._latex_name = self.name.replace("_", r"\_")
 
             if is_miro_input:
                 self._already_loaded = False

gamspy/_symbols/set.py

@@ -482,6 +482,7 @@ class Set(gt.Set, operable.Operable, Symbol, SetMixin):
 
         # gamspy attributes
         obj.where = condition.Condition(obj)
+        obj._latex_name = name.replace("_", r"\_")
         obj.container._add_statement(obj)
         obj._synchronize = True
         obj._metadata = {}
@@ -642,6 +643,7 @@ class Set(gt.Set, operable.Operable, Symbol, SetMixin):
                 description=description,
                 uels_on_axes=uels_on_axes,
             )
+            self._latex_name = self.name.replace("_", r"\_")
 
             if is_miro_input:
                 self._already_loaded = False

gamspy/_symbols/symbol.py

@@ -47,8 +47,7 @@ class Symbol:
         -------
         str
         """
-        name = self.name.replace("_", "\\_")
-        return name
+        return self._latex_name
 
     @property
     def synchronize(

gamspy/_symbols/universe_alias.py

@@ -63,6 +63,7 @@ class UniverseAlias(gt.UniverseAlias):
 
         # gamspy attributes
         obj.where = condition.Condition(obj)
+        obj._latex_name = name.replace("_", r"\_")
 
         # add statement
         obj.container._add_statement(obj)
@@ -95,7 +96,11 @@ class UniverseAlias(gt.UniverseAlias):
 
     def __init__(self, container: Container | None = None, name: str = "universe"):
         # check if the name is a reserved word
-        name = validation.validate_name(name)
+        if name is not None:
+            name = validation.validate_name(name)
+        else:
+            name = container._get_symbol_name(prefix="u")
+
         if container is None:
             try:
                 container = gp._ctx_managers[(os.getpid(), threading.get_native_id())]
@@ -103,6 +108,7 @@ class UniverseAlias(gt.UniverseAlias):
                 raise ValidationError("UniverseAlias requires a container.") from e
 
         super().__init__(container, name)
+        self._latex_name = self.name.replace("_", r"\_")
 
         # allow conditions
         self.where = condition.Condition(self)
@@ -137,6 +143,25 @@ class UniverseAlias(gt.UniverseAlias):
         """
         return self.name
 
+    def latexRepr(self) -> str:
+        """
+        Representation of the UniverseAlias in LaTeX.
+
+        Returns
+        -------
+        str
+
+        Examples
+        --------
+        >>> import gamspy as gp
+        >>> m = gp.Container()
+        >>> i = gp.UniverseAlias(m, name="universe_alias")
+        >>> i.latexRepr()
+        'universe\\_alias'
+
+        """
+        return self._latex_name
+
     def getDeclaration(self) -> str:
         """
         Declaration of the UniverseAlias in GAMS

gamspy/_symbols/variable.py

@@ -155,6 +155,7 @@ class Variable(gt.Variable, operable.Operable, Symbol):
 
         # gamspy attributes
         obj.where = condition.Condition(obj)
+        obj._latex_name = name.replace("_", r"\_")
         obj.container._add_statement(obj)
         obj._synchronize = True
         obj._metadata = {}
@@ -319,6 +320,7 @@ class Variable(gt.Variable, operable.Operable, Symbol):
                 description=description,
                 uels_on_axes=uels_on_axes,
             )
+            self._latex_name = self.name.replace("_", r"\_")
 
             if is_miro_output:
                 container._miro_output_symbols.append(self.name)

gamspy/_validation.py

@@ -187,7 +187,7 @@ def validate_dimension(
 
     if dimension != symbol.dimension:
         raise ValidationError(
-            f"The `{symbol}` is referenced with"
+            f"The `{symbol.gamsRepr()}` is referenced with"
             f" {'more' if dimension > symbol.dimension else 'less'} indices"
             f" than declared. Declared dimension is {symbol.dimension} but"
             f" given dimension is {dimension}"
@@ -584,9 +584,18 @@ def validate_equations(model: Model) -> None:
     if not get_option("VALIDATION"):
         return
 
+    # We don't have the definitions of equations as an expression tree if the container
+    # is restarted. We have it instead as a string. Hence, do not try to do validation.
     if model.container._is_restarted:
         return
 
+    # We don't have the definition of MPSGE equations since they are autogenerated on the GAMS side.
+    if (
+        model.problem == Problem.MCP
+        and model.name.lower() in model.container._mpsge_models
+    ):
+        return
+
     allow_ambiguous_equations = get_option("ALLOW_AMBIGUOUS_EQUATIONS").lower()
 
     for equation in model.equations:

gamspy/math/misc.py

@@ -8,6 +8,7 @@ import gamspy._algebra.operable as operable
 import gamspy._symbols as syms
 import gamspy._validation as validation
 import gamspy.utils as utils
+from gamspy._container import Container
 from gamspy.exceptions import ValidationError
 
 if TYPE_CHECKING:
@@ -55,13 +56,16 @@ class MathOp(operable.Operable):
         -------
         pd.DataFrame | None
         """
-        assert self.container is not None
+        container = self.container
+        if container is None:
+            container = Container()
+
         temp_name = "a" + utils._get_unique_name()
         temp_param = syms.Parameter._constructor_bypass(
-            self.container, temp_name, self.domain
+            container, temp_name, self.domain
         )
         temp_param[...] = self
-        del self.container.data[temp_name]
+        del container.data[temp_name]
         return temp_param.records
 
     def toValue(self) -> float | None:
@@ -121,11 +125,14 @@ class MathOp(operable.Operable):
             "abs": "\\lvert",
         }
 
-        operands_str = ",".join([_stringify(elem) for elem in self.elements])
+        operands_str = ",".join(
+            [_stringify(elem, latex=True) for elem in self.elements]
+        )
         if self.op_name in op_map:
             return f"{op_map[self.op_name]}{{{operands_str}}}"
 
-        return f"{self.op_name}({operands_str})"
+        op_name = self.op_name.replace("_", r"\_")
+        return f"{op_name}({operands_str})"
 
     def __str__(self):
         return self.gamsRepr()
@@ -134,14 +141,20 @@ class MathOp(operable.Operable):
         return len(self.gamsRepr())
 
 
-def _stringify(x: str | int | float | Symbol | ImplicitSymbol):
+def _stringify(x: str | int | float | Symbol | ImplicitSymbol, *, latex: bool = False):
     if isinstance(x, (int, float)):
         x = utils._map_special_values(x)
 
         return str(x)
     elif isinstance(x, str):
+        if latex:
+            x = x.replace("_", r"\_")
+
         return f'"{x}"'
 
+    if latex:
+        return x.latexRepr()
+
     return x.gamsRepr()  # type: ignore
 
 

gamspy/utils.py

@@ -137,6 +137,7 @@ def getSolverCapabilities(system_directory: str) -> dict[str, list[str]]:
 
         capabilities[solver] = problem_types
 
+    capabilities.pop("MPSGE", None)
     _capabilities[system_directory] = capabilities
     return capabilities
 
@@ -584,7 +585,9 @@ def _map_special_values(value: float):
     return value
 
 
-def _get_domain_str(domain: Iterable[Set | Alias | ImplicitSet | str]) -> str:
+def _get_domain_str(
+    domain: Iterable[Set | Alias | ImplicitSet | str], *, latex: bool = False
+) -> str:
     """
     Creates the string format of a given domain
 
@@ -601,21 +604,29 @@ def _get_domain_str(domain: Iterable[Set | Alias | ImplicitSet | str]) -> str:
     Exception
         Given domain must contain only sets, aliases or strings
     """
-    set_strs = []
-    for set in domain:
-        if isinstance(set, (gt.Set, gt.Alias, gt.UniverseAlias, implicits.ImplicitSet)):
-            set_strs.append(set.gamsRepr())
-        elif isinstance(set, str):
-            if set == "*":
-                set_strs.append(set)
+    domain_strs = []
+    for elem in domain:
+        if isinstance(
+            elem, (gt.Set, gt.Alias, gt.UniverseAlias, implicits.ImplicitSet)
+        ):
+            if latex:
+                domain_strs.append(elem.latexRepr())
+            else:
+                domain_strs.append(elem.gamsRepr())
+        elif isinstance(elem, str):
+            if elem == "*":
+                domain_strs.append(elem)
             else:
-                set_strs.append('"' + set + '"')
+                if latex:
+                    domain_strs.append('"' + elem.replace("_", r"\_") + '"')
+                else:
+                    domain_strs.append('"' + elem + '"')
         else:
             raise ValidationError(
-                f"Domain type must be str, Set or Alias but found {type(set)}"
+                f"Domain type must be str, Set or Alias but found {type(elem)}"
             )
 
-    return "(" + ",".join(set_strs) + ")"
+    return "(" + ",".join(domain_strs) + ")"
 
 
 def _permute_domain(domain, dims):

{gamspy-1.18.1.dist-info → gamspy-1.18.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gamspy
-Version: 1.18.1
+Version: 1.18.3
 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.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: gamsapi<53.0.0,>=52.1.0
-Requires-Dist: gamspy_base<53.0.0,>=52.1.0
+Requires-Dist: gamsapi<53.0.0,>=52.2.0
+Requires-Dist: gamspy_base<53.0.0,>=52.2.0
 Requires-Dist: pandas<2.4,>=2.2.2
 Requires-Dist: pydantic>=2.0
 Requires-Dist: requests>=2.28.0

{gamspy-1.18.1.dist-info → gamspy-1.18.3.dist-info}/RECORD

@@ -2,39 +2,40 @@ gamspy/__init__.py,sha256=HZulKBgt2ubfX6r6v6Xv3MJVI6Prm40j5W45aUetQok,1797
 gamspy/__main__.py,sha256=3HW3NYEe4pZnGhJ10s1G0vaZAkI9Zl_lXqHT9iDNXQg,108
 gamspy/_communication.py,sha256=18drDsKxi1Iv6oAKZfKGJcPYYWebBQsyeOxiEKXZngE,7148
 gamspy/_config.py,sha256=n7RXUFczIlol15-mxhnj54fHXHet8HcOnWiGm3mpMgg,3589
-gamspy/_container.py,sha256=w5zftBCrgFSkZEOgwh2zyFjiDA4AohzNHi-BuF0Hjas,45884
-gamspy/_convert.py,sha256=z_ju0T2duAAeYE0ahW7E2GMdMMVZsQ5936HV583hXzs,22294
+gamspy/_container.py,sha256=r4-uGBy2yxBl7yPaxAPdgmJ-bkb7moeXJtx8xupY9DE,46966
+gamspy/_convert.py,sha256=3_agmO6QPXqy-wyiEncdMk9B2KuqK73G2d5T9SB3phM,23456
 gamspy/_database.py,sha256=SVo4lEfS0Q2f80uMu7k71BBQNRwUei-2KFc_EGxsOcw,6873
-gamspy/_extrinsic.py,sha256=6pBam_ruzKaYjEpALjAQ5d9uPrlOf1lVMYjRYqHH8o0,4337
+gamspy/_extrinsic.py,sha256=OGrlNzcSQjoIZw8lpsk_4SObEAhGX5bkc_D0d3lPZMQ,4807
 gamspy/_miro.py,sha256=MeFGcaFtNgtydWjH0KS0l9y3mNy7tPyXwm43jwomodg,12245
-gamspy/_model.py,sha256=Qd8JdDDUUSjWXQUKGR4N0-2J_PHnzh8sjSG3U7A4aKk,51359
+gamspy/_model.py,sha256=CPupNZ8Hpkco9DgC_0cuPSRI1qnccQtOlx57sCQ8iZE,52828
 gamspy/_model_instance.py,sha256=ZHG3-inc6vDx7F2Oo9HYWYAi8hki6upIgAQn5II_o1U,24384
 gamspy/_options.py,sha256=FTty65WRdikvnhPyWSTuwuUz0Rs6aZwDFWL-UsfEgd0,27211
 gamspy/_serialization.py,sha256=fwAQpABCZQyxtAkddsvCDjtyQyPUT3EJy19r9BKR6aY,4062
 gamspy/_types.py,sha256=_KQjRntvIAicc9_sZ5BYWAHjs-WBURf2NJwTpJQT5xw,162
-gamspy/_validation.py,sha256=k4e8M8X32hEFybJyISyXLNrzO1mmWXQPnSThT7rOC5U,21608
+gamspy/_validation.py,sha256=uaLzEeXE2h-1_9-x_Gv28qio08vk1q52vgtr-lahq3E,22029
 gamspy/_workspace.py,sha256=QrnC8aPN5C9zyqbaYvfuPlRHvBrDx_i4Imw1AzsJs7k,2175
 gamspy/exceptions.py,sha256=q-Cb6syXv1abf2JBfNFidGkvOWkp9FXU5NzJwkR5W7o,2929
 gamspy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-gamspy/utils.py,sha256=6eO4R0iBLRm2oTRCz_croiQhKpiIyF8bOa0NDfw9aUU,19777
+gamspy/utils.py,sha256=nDmyhkCv5yk40jf3OL-HtW-wWTWh20UDC3bO4D5Vc4k,20114
 gamspy/version.py,sha256=GsqTw9rQ4Zz80ZSlIo44vYqgcVBJSbGOqJFJW3j_z88,109
 gamspy/_algebra/__init__.py,sha256=HdTHRBzfOGXihibQOAOAHGHKinlMuHVnpuP4pJWSQCc,479
 gamspy/_algebra/condition.py,sha256=mVJeCk65dvLgYalTQHfZt0bEFFf9yoTWLXjhODf7gvg,6229
-gamspy/_algebra/domain.py,sha256=WN9ftyz8DPwPOtlECo_E8Cz3Qxk-0hBPGIuu5bzvX6Y,2929
-gamspy/_algebra/expression.py,sha256=rBG4chXXjP9AtbCkQG8XK419kOTHjLhc3l5T5o1ZGMs,25392
+gamspy/_algebra/domain.py,sha256=6hBYxxZuQ-tJ5QcjEpW68SxI3i0SkgxbwgSsK93wLRc,2941
+gamspy/_algebra/expression.py,sha256=yOrPeDhB-tkyfgp27U6VbyArmGQo6SnQUipyYcL8agg,25393
 gamspy/_algebra/number.py,sha256=Yf7kYLwkmXCipiAzQP7LtTchMMK7OccChuXnTIYl1w4,1680
 gamspy/_algebra/operable.py,sha256=1sFr29_7A9RKVxDlTY9fC_g4sNRavNOYpjACWzvyjRc,6315
-gamspy/_algebra/operation.py,sha256=e3gYxS5OPh8JYGAnAS1wEpzafFpfBt0UbcL4PKZyoY0,22990
+gamspy/_algebra/operation.py,sha256=SRFHnAFRqciR5cLnrxfTQXvjYNO1fxyci5oVQAb_L6M,23235
 gamspy/_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gamspy/_backend/backend.py,sha256=VgLL3CiFydkf1ZF8ttaOlWsDtkJIoRdi_md4tVh789Q,9217
 gamspy/_backend/engine.py,sha256=N3BIb4CDmH76CQIj87JSJBNnMLln3jsUuLy9_O5sEJ0,31826
 gamspy/_backend/local.py,sha256=-LE7obmZT3zdB-0LJHJ9xfulMBw5vvzFIS9WJ7ISE-4,3804
 gamspy/_backend/neos.py,sha256=I21TOqPZC5cBp_rQpz5S9cmLPRJcizIT0KuncwMcUrw,17762
 gamspy/_cli/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
-gamspy/_cli/cli.py,sha256=a4AtD-VI5jk0ZcO0JAwD0f0KJRwmxA8MzR_2MmhPWpg,1580
+gamspy/_cli/cli.py,sha256=SUnkhiReUirVZBJoGxSZ_mvENzHqhSKmS0gr3sEsacs,1634
 gamspy/_cli/gdx.py,sha256=YRu1delsmDh-dpzEr8n1kTK0JFdXlNqz4YuUQzK1mvo,12024
 gamspy/_cli/install.py,sha256=Kr09kp146LujiO64GpoJxMPRZmY9GnhxuhWm-ZU2l4w,13257
 gamspy/_cli/list.py,sha256=fMmaIZcZf-Tf_-J37tJ4zrk2bcVO9cPSfs08mQyGWiY,2907
+gamspy/_cli/mps2gms.py,sha256=4zmM5gS_YlgkzBcgHDzjM6F_r2vKJTi0P_ZYgZxjoEw,4192
 gamspy/_cli/probe.py,sha256=K7fYwfdk-2mGGQKAxXFvkWMRJ1qYTUpX2tvklU56JZU,1122
 gamspy/_cli/retrieve.py,sha256=bnTcIbHJfkq-dvrFitdkxsjQNZz-Cx4-LiaRfhe0cYM,2446
 gamspy/_cli/run.py,sha256=oaWT4alxSXqPDF2mRYmfy5aOWCKoEExUfqYoAT_zSUM,4387
@@ -42,18 +43,18 @@ gamspy/_cli/show.py,sha256=NTZJBtdns0Bd6UOdlTDIelhU92xmLJjT9HuDLqS3YJ4,11144
 gamspy/_cli/uninstall.py,sha256=_g3SbT6G7DZcYgtmHLhaGl1B9jY1K3D0sStifxIyqxQ,5183
 gamspy/_cli/util.py,sha256=ey3Wn7tCEggkr-sjcLqrVBda-jdadjWOn-APhSe4toE,2849
 gamspy/_symbols/__init__.py,sha256=p0Zd7XytuOe8kRclN1lFrRFaN_btFSSGdIBSXrlp03E,450
-gamspy/_symbols/alias.py,sha256=lIoNynvLd-tfXrVBs8Asy0TEkhs-xkTeNl4yLtzehiA,8795
-gamspy/_symbols/equation.py,sha256=W_8eQdZ9Mou9YVI1l0X_gwFB--TVNOK02OGpWmO3Xek,39719
-gamspy/_symbols/parameter.py,sha256=i5UWz8KQEHDBOjGV7JmL8GhnLnL-CiFMUhfSrBZOqQs,19721
-gamspy/_symbols/set.py,sha256=j3Izvgs470xiauwCbgXZOelZy-KAzslDGXuKeHn_g3g,29130
-gamspy/_symbols/symbol.py,sha256=Mn_O51nW99_d0G395JQ4C9SwXnMvdwqY7P6j_YyFL8E,10921
-gamspy/_symbols/universe_alias.py,sha256=8xoVhG9GGdl06tj56-NgN7T0dXwhp4rgKbCkjn8WhC8,4059
-gamspy/_symbols/variable.py,sha256=_yarP4aD-f76btWyGsGohuAgqQh1fcRWBGOngdehnic,30524
+gamspy/_symbols/alias.py,sha256=BidmqvYxqMXLxU9tSJHJ484P1R-7pq9J-cP0ITNmkVc,8907
+gamspy/_symbols/equation.py,sha256=qQi24g9GD3qpMOMl2R-bQJbVYWHIy3bbsoHt6ZgD2oQ,40136
+gamspy/_symbols/parameter.py,sha256=nZVE_AEbY2vyQ6OedrH8TC6ffPtSZk75MRstV-zY1z8,19833
+gamspy/_symbols/set.py,sha256=aUw8AO72sEmZlH-BpGBlMXMvJHLc-Skx0cpPvPJxOag,29242
+gamspy/_symbols/symbol.py,sha256=azKG8vJzrBrjGXCcKe865I5rEEbT1ZqQ02khQXPtiGs,10888
+gamspy/_symbols/universe_alias.py,sha256=3JBG710YIJi6jmNp9tKKqW6IoiXsUaSUf8flj9woFiU,4672
+gamspy/_symbols/variable.py,sha256=T6cMVz2pYgJIIY8_HxUkH7PgcDJhC-pMCcRPWplYe2s,30636
 gamspy/_symbols/implicits/__init__.py,sha256=bvYl_lYtnTztfNUTMxqteIztotwh1T2CUQpidQITSMQ,391
 gamspy/_symbols/implicits/implicit_equation.py,sha256=V28B9kJBpeCYekFPEvHKFwxNxkX3VEPSoMcXP6fEvzo,5070
 gamspy/_symbols/implicits/implicit_parameter.py,sha256=6w1O1-jSFH2J2S4FhssSs4ksAGwq281SodXCTzTFQQ0,8600
-gamspy/_symbols/implicits/implicit_set.py,sha256=ec1qXcbc1FKZ1s46cbycek7SJKrhC6LCF5FMgMLy0OE,3728
-gamspy/_symbols/implicits/implicit_symbol.py,sha256=YDt2DVH4WOd88gOgbqYZzq8Wm5UPRmrwg8Og4vuektM,9009
+gamspy/_symbols/implicits/implicit_set.py,sha256=T-gYrvuvJwbkJxWNac8EdrMP3SQxhN5LjXqElgrm0A4,3767
+gamspy/_symbols/implicits/implicit_symbol.py,sha256=dGK7vN2rCabuj1UXReO8PppbgbjcUu-lKv3IJ8_tgJo,9136
 gamspy/_symbols/implicits/implicit_variable.py,sha256=a1deGojPLXW7OLiOAOErgAGdRNlRCrBHt6r0WNchQVs,7662
 gamspy/formulations/__init__.py,sha256=-FZiCsc0Uydyc3j1nXpPvIUkB5H2dBs7FdWgFSJln2g,990
 gamspy/formulations/piecewise.py,sha256=uSyxylMEZuIhrqVdv3wuv4FAHegLf3rD9KCIdiHvALc,24421
@@ -78,12 +79,12 @@ gamspy/math/__init__.py,sha256=pyYOIEAi1I4h8gu0pCAnMh389566Ygrl0BtQh1P3OB0,3120
 gamspy/math/activation.py,sha256=XQHTKUKIT7d4-JqJdWwhyxBtnAJ6MajCjx3FWBi3k1s,24569
 gamspy/math/log_power.py,sha256=oXQmHNdaDPLdhtmv8znmSzq0MPa4fHkxGdx8hSaQq-Y,9184
 gamspy/math/matrix.py,sha256=PmYsMhF8Pq3bcgtyINryq4xV36i4KW0BtcFApOvt8GQ,16365
-gamspy/math/misc.py,sha256=FaSRYFjMN6AULqOqGIF6_AXDw6KVqgxm2EtZsDcBFmE,37432
+gamspy/math/misc.py,sha256=qrduVOZ7CmD9wjUJx86t2J_2XMQzTz2vhd40sFwuRUk,37727
 gamspy/math/probability.py,sha256=gAVU_PTfbjXuN6i8XNjZpIYvFg8dPk1imZCbKQloSG0,4290
 gamspy/math/trigonometric.py,sha256=VBWQcP3ggl1oGDEzRs2M_T88HPJn9N0QfMJZwEUkx4w,4276
-gamspy-1.18.1.dist-info/licenses/LICENSE,sha256=D4HfHbHRs3LVWo3uXq44WQc1FkBP5srUCEa-vO0W9tE,1189
-gamspy-1.18.1.dist-info/METADATA,sha256=E7-RHCJZIutvTFYwaNd7NtgGD35BKwa-RV-IBFyoG5Y,5301
-gamspy-1.18.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-gamspy-1.18.1.dist-info/entry_points.txt,sha256=tzgC7L0Y_BiyagBCaYOPK7lE4olRJKM_PH2inmMvj60,48
-gamspy-1.18.1.dist-info/top_level.txt,sha256=fsq4q5lfdb2GEZC9O3PUih38s7TfIgolIaO5NgR3Hf8,7
-gamspy-1.18.1.dist-info/RECORD,,
+gamspy-1.18.3.dist-info/licenses/LICENSE,sha256=D4HfHbHRs3LVWo3uXq44WQc1FkBP5srUCEa-vO0W9tE,1189
+gamspy-1.18.3.dist-info/METADATA,sha256=-2s1hRKHXEJuOl3HvHz3ggCLxXcEfXjzD10KOBDb9us,5301
+gamspy-1.18.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+gamspy-1.18.3.dist-info/entry_points.txt,sha256=tzgC7L0Y_BiyagBCaYOPK7lE4olRJKM_PH2inmMvj60,48
+gamspy-1.18.3.dist-info/top_level.txt,sha256=fsq4q5lfdb2GEZC9O3PUih38s7TfIgolIaO5NgR3Hf8,7
+gamspy-1.18.3.dist-info/RECORD,,