ommx-pyscipopt-adapter 1.4.2__tar.gz

ommx_pyscipopt_adapter-1.4.2/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: ommx_pyscipopt_adapter
+Version: 1.4.2
+Summary: An adapter for the SCIP from OMMX.
+Author-email: "Jij Inc." <info@j-ij.com>
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: ommx<2.0.0,>=1.4.1
+Requires-Dist: PySCIPOpt<6.0.0,>=5.1.0
+Provides-Extra: dev
+Requires-Dist: markdown-code-runner; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# OMMX adapter for SCIP
+
+This package provides an adapter for the [SCIP](https://www.scipopt.org/) from [OMMX](https://github.com/Jij-Inc/ommx)
+
+## Usage
+
+`ommx-pyscipopt-adapter` can be installed from PyPI as follows:
+
+```bash
+pip install ommx-pyscipopt-adapter
+```
+
+SCIP can be used through `ommx-pyscipopt-adapter` by using the following:
+
+```python markdown-code-runner
+import ommx_pyscipopt_adapter as adapter
+from ommx.v1 import Instance, DecisionVariable
+
+x1 = DecisionVariable.integer(1, lower=0, upper=5)
+ommx_instance = Instance.from_components(
+    decision_variables=[x1],
+    objective=x1,
+    constraints=[],
+    sense=Instance.MINIMIZE,
+)
+
+# Convert from `ommx.v1.Instance` to `pyscipopt.Model`
+model = adapter.instance_to_model(ommx_instance)
+model.optimize()
+# Create `ommx.v1.State` from Optimized `pyscipopt.Model`
+ommx_state = adapter.model_to_state(model, ommx_instance)
+
+print(ommx_state)
+```
+
+## Reference
+
+TBW

ommx_pyscipopt_adapter-1.4.2/README.md

@@ -0,0 +1,38 @@
+# OMMX adapter for SCIP
+
+This package provides an adapter for the [SCIP](https://www.scipopt.org/) from [OMMX](https://github.com/Jij-Inc/ommx)
+
+## Usage
+
+`ommx-pyscipopt-adapter` can be installed from PyPI as follows:
+
+```bash
+pip install ommx-pyscipopt-adapter
+```
+
+SCIP can be used through `ommx-pyscipopt-adapter` by using the following:
+
+```python markdown-code-runner
+import ommx_pyscipopt_adapter as adapter
+from ommx.v1 import Instance, DecisionVariable
+
+x1 = DecisionVariable.integer(1, lower=0, upper=5)
+ommx_instance = Instance.from_components(
+    decision_variables=[x1],
+    objective=x1,
+    constraints=[],
+    sense=Instance.MINIMIZE,
+)
+
+# Convert from `ommx.v1.Instance` to `pyscipopt.Model`
+model = adapter.instance_to_model(ommx_instance)
+model.optimize()
+# Create `ommx.v1.State` from Optimized `pyscipopt.Model`
+ommx_state = adapter.model_to_state(model, ommx_instance)
+
+print(ommx_state)
+```
+
+## Reference
+
+TBW

ommx_pyscipopt_adapter-1.4.2/ommx_pyscipopt_adapter/__init__.py

@@ -0,0 +1,13 @@
+from .exception import OMMXPySCIPOptAdapterError
+from .ommx_to_pyscipopt import (
+    instance_to_model,
+    model_to_state,
+    model_to_solution,
+)
+
+__all__ = [
+    "instance_to_model",
+    "model_to_state",
+    "model_to_solution",
+    "OMMXPySCIPOptAdapterError",
+]

ommx_pyscipopt_adapter-1.4.2/ommx_pyscipopt_adapter/exception.py

@@ -0,0 +1,2 @@
+class OMMXPySCIPOptAdapterError(Exception):
+    pass

ommx_pyscipopt_adapter-1.4.2/ommx_pyscipopt_adapter/ommx_to_pyscipopt.py

@@ -0,0 +1,301 @@
+import math
+
+import pyscipopt
+
+from ommx.v1 import Constraint, Instance, DecisionVariable, Solution
+from ommx.v1.function_pb2 import Function
+from ommx.v1.solution_pb2 import State
+
+from .exception import OMMXPySCIPOptAdapterError
+
+
+class OMMXSCIPAdapter:
+    def __init__(self, instance: Instance):
+        self._ommx_instance = instance.raw
+        self._model = pyscipopt.Model()
+        self._model.hideOutput()
+
+    def _set_decision_variables(self):
+        ommx_objective = self._ommx_instance.objective
+
+        for var in self._ommx_instance.decision_variables:
+            if var.kind == DecisionVariable.BINARY:
+                self._model.addVar(
+                    name=str(var.id),
+                    vtype="B",
+                )
+            elif var.kind == DecisionVariable.INTEGER:
+                self._model.addVar(
+                    name=str(var.id),
+                    vtype="I",
+                    lb=var.bound.lower,
+                    ub=var.bound.upper,
+                )
+            elif var.kind == DecisionVariable.CONTINUOUS:
+                self._model.addVar(
+                    name=str(var.id),
+                    vtype="C",
+                    lb=var.bound.lower,
+                    ub=var.bound.upper,
+                )
+            else:
+                raise OMMXPySCIPOptAdapterError(
+                    f"Not supported decision variable kind: "
+                    f"id: {var.id}, kind: {var.kind}"
+                )
+        if ommx_objective.HasField("quadratic"):
+            # If objective function is quadratic, add the auxiliary variable for the linealized objective function,
+            # because the setObjective method in PySCIPOpt does not support quadratic objective functions.
+            self._model.addVar(
+                name="auxiliary_for_linearized_objective", vtype="C", lb=None, ub=None
+            )
+        self._varname_to_var = {var.name: var for var in self._model.getVars()}
+
+    def _make_linear_expr(
+        self,
+        ommx_function: Function,
+    ) -> pyscipopt.Expr:
+        ommx_linear = ommx_function.linear
+
+        return (
+            pyscipopt.quicksum(
+                term.coefficient * self._varname_to_var[str(term.id)]
+                for term in ommx_linear.terms
+            )
+            + ommx_linear.constant
+        )
+
+    def _make_quadratic_expr(
+        self,
+        ommx_function: Function,
+    ) -> pyscipopt.Expr:
+        ommx_quadratic = ommx_function.quadratic
+        quadratic_term = pyscipopt.quicksum(
+            self._varname_to_var[str(row)] * self._varname_to_var[str(column)] * value
+            for row, column, value in zip(
+                ommx_quadratic.rows, ommx_quadratic.columns, ommx_quadratic.values
+            )
+        )
+        linear_term = pyscipopt.quicksum(
+            term.coefficient * self._varname_to_var[str(term.id)]
+            for term in ommx_quadratic.linear.terms
+        )
+        constant = ommx_quadratic.linear.constant
+        return quadratic_term + linear_term + constant
+
+    def _set_objective_function(self):
+        ommx_objective = self._ommx_instance.objective
+        if self._ommx_instance.sense == Instance.MAXIMIZE:
+            sense = "maximize"
+        elif self._ommx_instance.sense == Instance.MINIMIZE:
+            sense = "minimize"
+        else:
+            raise OMMXPySCIPOptAdapterError(
+                f"Not supported sense: {self._ommx_instance.sense}"
+            )
+
+        if ommx_objective.HasField("constant"):
+            self._model.setObjective(ommx_objective.constant, sense=sense)
+        elif ommx_objective.HasField("linear"):
+            expr = self._make_linear_expr(ommx_objective)
+            self._model.setObjective(expr, sense=sense)
+        elif ommx_objective.HasField("quadratic"):
+            # The setObjective method in PySCIPOpt does not support quadratic objective functions.
+            # So we introduce the auxiliary variable to linearize the objective function,
+            # Example:
+            #     input problem: min x^2 + y^2
+            #
+            #     introduce the auxiliary variable z, and the linearized objective function problem is:
+            #         min z
+            #         s.t. z >= x^2 + y^2
+            auxilary_var = self._varname_to_var["auxiliary_for_linearized_objective"]
+
+            # Add the auxiliary variable to the objective function.
+            self._model.setObjective(auxilary_var, sense=sense)
+
+            # Add the constraint for the auxiliary variable.
+            expr = self._make_quadratic_expr(ommx_objective)
+            if sense == "minimize":
+                constr_expr = auxilary_var >= expr
+            else:  # sense == "maximize"
+                constr_expr = auxilary_var <= expr
+
+            self._model.addCons(constr_expr, name="constraint_for_linearized_objective")
+
+        else:
+            raise OMMXPySCIPOptAdapterError(
+                "The objective function must be `constant`, `linear`, `quadratic`."
+            )
+
+    def _set_constraints(self):
+        ommx_constraints = self._ommx_instance.constraints
+
+        for constraint in ommx_constraints:
+            if constraint.function.HasField("linear"):
+                expr = self._make_linear_expr(constraint.function)
+            elif constraint.function.HasField("quadratic"):
+                expr = self._make_quadratic_expr(constraint.function)
+            elif constraint.function.HasField("constant"):
+                if constraint.equality == Constraint.EQUAL_TO_ZERO and math.isclose(
+                    constraint.function.constant, 0, abs_tol=1e-6
+                ):
+                    continue
+                elif (
+                    constraint.equality == Constraint.LESS_THAN_OR_EQUAL_TO_ZERO
+                    and constraint.function.constant <= 1e-6
+                ):
+                    continue
+                else:
+                    raise OMMXPySCIPOptAdapterError(
+                        f"Infeasible constant constraint was found:"
+                        f"id: {constraint.id}"
+                    )
+            else:
+                raise OMMXPySCIPOptAdapterError(
+                    f"Constraints must be either `constant`, `linear` or `quadratic`."
+                    f"id: {constraint.id}, "
+                    f"type: {constraint.function.WhichOneof('function')}"
+                )
+
+            if constraint.equality == Constraint.EQUAL_TO_ZERO:
+                constr_expr = expr == 0
+            elif constraint.equality == Constraint.LESS_THAN_OR_EQUAL_TO_ZERO:
+                constr_expr = expr <= 0
+            else:
+                raise OMMXPySCIPOptAdapterError(
+                    f"Not supported constraint equality: "
+                    f"id: {constraint.id}, equality: {constraint.equality}"
+                )
+
+            self._model.addCons(constr_expr, name=str(constraint.id))
+
+    def build(self) -> pyscipopt.Model:
+        self._set_decision_variables()
+        self._set_objective_function()
+        self._set_constraints()
+
+        return self._model
+
+
+def instance_to_model(instance: Instance) -> pyscipopt.Model:
+    """
+    Convert ommx.v1.Instance to pyscipopt.Model.
+
+    Examples
+    =========
+
+    .. doctest::
+
+        The following example shows how to create a pyscipopt.Model from an ommx.v1.Instance.
+
+        >>> import ommx_pyscipopt_adapter as adapter
+        >>> from ommx.v1 import Instance, DecisionVariable
+
+        >>> x1 = DecisionVariable.integer(1, lower=0, upper=5)
+        >>> ommx_instance = Instance.from_components(
+        ...     decision_variables=[x1],
+        ...     objective=x1,
+        ...     constraints=[],
+        ...     sense=Instance.MINIMIZE,
+        ... )
+        >>> model = adapter.instance_to_model(ommx_instance)
+        >>> model.optimize()
+
+        >>> ommx_state = adapter.model_to_state(model, ommx_instance)
+        >>> ommx_state.entries
+        {1: -0.0}
+
+    """
+
+    builder = OMMXSCIPAdapter(instance)
+    return builder.build()
+
+
+def model_to_state(model: pyscipopt.Model, instance: Instance) -> State:
+    """
+    Convert optimized pyscipopt.Model and ommx.v1.Instance to ommx.v1.State.
+
+    Examples
+    =========
+
+    .. doctest::
+
+        The following example shows how to solve an unconstrained linear optimization problem with `x1` as the objective function.
+
+        >>> import ommx_pyscipopt_adapter as adapter
+        >>> from ommx.v1 import Instance, DecisionVariable
+
+        >>> x1 = DecisionVariable.integer(1, lower=0, upper=5)
+        >>> ommx_instance = Instance.from_components(
+        ...     decision_variables=[x1],
+        ...     objective=x1,
+        ...     constraints=[],
+        ...     sense=Instance.MINIMIZE,
+        ... )
+        >>> model = adapter.instance_to_model(ommx_instance)
+        >>> model.optimize()
+
+        >>> ommx_state = adapter.model_to_state(model, ommx_instance)
+        >>> ommx_state.entries
+        {1: -0.0}
+
+    """
+
+    if model.getStatus() == "unknown":
+        raise OMMXPySCIPOptAdapterError(
+            "The model may not be optimized. [status: unknown]"
+        )
+
+    # NOTE: It is assumed that getBestSol will return an error
+    #       if there is no feasible solution.
+    try:
+        sol = model.getBestSol()
+        varname_to_var = {var.name: var for var in model.getVars()}
+        return State(
+            entries={
+                var.id: sol[varname_to_var[str(var.id)]]
+                for var in instance.raw.decision_variables
+            }
+        )
+    except Exception:
+        raise OMMXPySCIPOptAdapterError(
+            f"There is no feasible solution. [status: {model.getStatus()}]"
+        )
+
+
+def model_to_solution(model: pyscipopt.Model, instance: Instance) -> Solution:
+    """
+    Convert optimized pyscipopt.Model and ommx.v1.Instance to ommx.v1.Solution.
+
+    Examples
+    =========
+
+    .. doctest::
+
+        >>> import ommx_pyscipopt_adapter as adapter
+        >>> from ommx.v1 import Instance, DecisionVariable
+
+        >>> p = [10, 13, 18, 31, 7, 15]
+        >>> w = [11, 15, 20, 35, 10, 33]
+        >>> x = [DecisionVariable.binary(i) for i in range(6)]
+        >>> instance = Instance.from_components(
+        ...     decision_variables=x,
+        ...     objective=sum(p[i] * x[i] for i in range(6)),
+        ...     constraints=[sum(w[i] * x[i] for i in range(6)) <= 47],
+        ...     sense=Instance.MAXIMIZE,
+        ... )
+
+        >>> model = adapter.instance_to_model(instance)
+        >>> model.optimize()
+
+        >>> solution = adapter.model_to_solution(model, instance)
+        >>> solution.objective
+        41.0
+
+    """
+    state = model_to_state(model, instance)
+    solution = instance.evaluate(state)
+
+    # TODO: Add the feature to store dual variables in `solution`.
+
+    return solution

ommx_pyscipopt_adapter-1.4.2/ommx_pyscipopt_adapter.egg-info/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: ommx_pyscipopt_adapter
+Version: 1.4.2
+Summary: An adapter for the SCIP from OMMX.
+Author-email: "Jij Inc." <info@j-ij.com>
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: ommx<2.0.0,>=1.4.1
+Requires-Dist: PySCIPOpt<6.0.0,>=5.1.0
+Provides-Extra: dev
+Requires-Dist: markdown-code-runner; extra == "dev"
+Requires-Dist: pyright; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# OMMX adapter for SCIP
+
+This package provides an adapter for the [SCIP](https://www.scipopt.org/) from [OMMX](https://github.com/Jij-Inc/ommx)
+
+## Usage
+
+`ommx-pyscipopt-adapter` can be installed from PyPI as follows:
+
+```bash
+pip install ommx-pyscipopt-adapter
+```
+
+SCIP can be used through `ommx-pyscipopt-adapter` by using the following:
+
+```python markdown-code-runner
+import ommx_pyscipopt_adapter as adapter
+from ommx.v1 import Instance, DecisionVariable
+
+x1 = DecisionVariable.integer(1, lower=0, upper=5)
+ommx_instance = Instance.from_components(
+    decision_variables=[x1],
+    objective=x1,
+    constraints=[],
+    sense=Instance.MINIMIZE,
+)
+
+# Convert from `ommx.v1.Instance` to `pyscipopt.Model`
+model = adapter.instance_to_model(ommx_instance)
+model.optimize()
+# Create `ommx.v1.State` from Optimized `pyscipopt.Model`
+ommx_state = adapter.model_to_state(model, ommx_instance)
+
+print(ommx_state)
+```
+
+## Reference
+
+TBW

ommx_pyscipopt_adapter-1.4.2/ommx_pyscipopt_adapter.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+ommx_pyscipopt_adapter/__init__.py
+ommx_pyscipopt_adapter/exception.py
+ommx_pyscipopt_adapter/ommx_to_pyscipopt.py
+ommx_pyscipopt_adapter.egg-info/PKG-INFO
+ommx_pyscipopt_adapter.egg-info/SOURCES.txt
+ommx_pyscipopt_adapter.egg-info/dependency_links.txt
+ommx_pyscipopt_adapter.egg-info/requires.txt
+ommx_pyscipopt_adapter.egg-info/top_level.txt
+tests/test_error.py
+tests/test_integration.py

ommx_pyscipopt_adapter-1.4.2/ommx_pyscipopt_adapter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ommx_pyscipopt_adapter-1.4.2/ommx_pyscipopt_adapter.egg-info/requires.txt

@@ -0,0 +1,8 @@
+ommx<2.0.0,>=1.4.1
+PySCIPOpt<6.0.0,>=5.1.0
+
+[dev]
+markdown-code-runner
+pyright
+pytest
+ruff

ommx_pyscipopt_adapter-1.4.2/ommx_pyscipopt_adapter.egg-info/top_level.txt

@@ -0,0 +1 @@
+ommx_pyscipopt_adapter

ommx_pyscipopt_adapter-1.4.2/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ommx_pyscipopt_adapter"
+version = "1.4.2"
+description = "An adapter for the SCIP from OMMX."
+authors = [
+    { name="Jij Inc.", email="info@j-ij.com" },
+]
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: Apache Software License",
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "ommx >= 1.4.1, < 2.0.0",
+    "PySCIPOpt >= 5.1.0, < 6.0.0",
+]
+
+
+[project.optional-dependencies]
+dev = [
+    "markdown-code-runner",
+    "pyright",
+    "pytest",
+    "ruff",
+]

ommx_pyscipopt_adapter-1.4.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ommx_pyscipopt_adapter-1.4.2/tests/test_error.py

@@ -0,0 +1,151 @@
+import pytest
+import pyscipopt
+
+from ommx_pyscipopt_adapter import (
+    instance_to_model,
+    model_to_state,
+    OMMXPySCIPOptAdapterError,
+)
+
+from ommx.v1 import Constraint, Instance, DecisionVariable, Polynomial
+from ommx.v1.decision_variables_pb2 import DecisionVariable as _DecisionVariable
+from ommx.v1.constraint_pb2 import Equality
+
+
+def test_error_not_suppoerted_decision_variable():
+    ommx_instance = Instance.from_components(
+        decision_variables=[
+            _DecisionVariable(id=1, kind=_DecisionVariable.KIND_UNSPECIFIED)
+        ],
+        objective=0,
+        constraints=[],
+        sense=Instance.MINIMIZE,
+    )
+    with pytest.raises(OMMXPySCIPOptAdapterError) as e:
+        instance_to_model(ommx_instance)
+    assert "Not supported decision variable" in str(e.value)
+
+
+def test_error_polynomial_objective():
+    # Objective function: 2.3 * x * x * x
+    ommx_instance = Instance.from_components(
+        decision_variables=[DecisionVariable.continuous(1)],
+        objective=Polynomial(terms={(1, 1, 1): 2.3}),
+        constraints=[],
+        sense=Instance.MINIMIZE,
+    )
+    with pytest.raises(OMMXPySCIPOptAdapterError) as e:
+        instance_to_model(ommx_instance)
+    assert "The objective function must be" in str(e.value)
+
+
+def test_error_nonlinear_constraint():
+    # Objective function: 0
+    # Constraint: 2.3 * x * x * x = 0
+    ommx_instance = Instance.from_components(
+        decision_variables=[DecisionVariable.continuous(1)],
+        objective=0,
+        constraints=[
+            Constraint(
+                function=Polynomial(terms={(1, 1, 1): 2.3}),
+                equality=Constraint.EQUAL_TO_ZERO,
+            ),
+        ],
+        sense=Instance.MINIMIZE,
+    )
+    with pytest.raises(OMMXPySCIPOptAdapterError) as e:
+        instance_to_model(ommx_instance)
+    assert "Constraints must be either `constant`, `linear` or `quadratic`." in str(
+        e.value
+    )
+
+
+def test_error_not_supported_constraint_equality():
+    # Objective function: 0
+    # Constraint: 2x ?? 0 (equality: unspecified)
+    x = DecisionVariable.continuous(1)
+    ommx_instance = Instance.from_components(
+        decision_variables=[x],
+        objective=0,
+        constraints=[
+            Constraint(
+                function=2 * x,
+                equality=Equality.EQUALITY_UNSPECIFIED,
+            ),
+        ],
+        sense=Instance.MINIMIZE,
+    )
+    with pytest.raises(OMMXPySCIPOptAdapterError) as e:
+        instance_to_model(ommx_instance)
+    assert "Not supported constraint equality" in str(e.value)
+
+
+def test_error_not_optimized_model():
+    model = pyscipopt.Model()
+    instance = Instance.from_components(
+        decision_variables=[],
+        objective=0,
+        constraints=[],
+        sense=Instance.MINIMIZE,
+    )
+    with pytest.raises(OMMXPySCIPOptAdapterError) as e:
+        model_to_state(model, instance)
+    assert "The model may not be optimized." in str(e.value)
+
+
+def test_error_infeasible_model():
+    x = DecisionVariable.continuous(1)
+    ommx_instance = Instance.from_components(
+        decision_variables=[x],
+        objective=0,
+        constraints=[
+            Constraint(
+                function=x,
+                equality=Constraint.EQUAL_TO_ZERO,
+            ),
+            Constraint(
+                function=x - 1,
+                equality=Constraint.EQUAL_TO_ZERO,
+            ),
+        ],
+        sense=Instance.MINIMIZE,
+    )
+    model = instance_to_model(ommx_instance)
+    model.optimize()
+    with pytest.raises(OMMXPySCIPOptAdapterError) as e:
+        model_to_state(model, ommx_instance)
+    assert "There is no feasible solution." in str(e.value)
+
+
+def test_error_infeasible_constant_equality_constraint():
+    ommx_instance = Instance.from_components(
+        decision_variables=[],
+        objective=0,
+        constraints=[
+            Constraint(
+                function=-1,
+                equality=Constraint.EQUAL_TO_ZERO,
+            ),
+        ],
+        sense=Instance.MINIMIZE,
+    )
+    with pytest.raises(OMMXPySCIPOptAdapterError) as e:
+        instance_to_model(ommx_instance)
+    assert "Infeasible constant constraint was found" in str(e.value)
+
+
+def test_error_infeasible_constant_inequality_constraint():
+    ommx_instance = Instance.from_components(
+        decision_variables=[],
+        objective=0,
+        constraints=[
+            Constraint(
+                function=1,
+                equality=Constraint.LESS_THAN_OR_EQUAL_TO_ZERO,
+            ),
+        ],
+        sense=Instance.MINIMIZE,
+    )
+    with pytest.raises(OMMXPySCIPOptAdapterError) as e:
+        instance_to_model(ommx_instance)
+    assert "Infeasible constant constraint was found" in str(e.value)

ommx_pyscipopt_adapter-1.4.2/tests/test_integration.py

@@ -0,0 +1,247 @@
+import pytest
+
+from ommx_pyscipopt_adapter import (
+    instance_to_model,
+    model_to_state,
+)
+
+from ommx.v1 import Constraint, Instance, DecisionVariable, Quadratic, Linear
+from ommx.testing import SingleFeasibleLPGenerator, DataType
+
+
+@pytest.mark.parametrize(
+    "generater",
+    [
+        SingleFeasibleLPGenerator(10, DataType.INT),
+        SingleFeasibleLPGenerator(10, DataType.FLOAT),
+    ],
+)
+def test_integration_lp(generater):
+    # Objective function: 0
+    # Constraints:
+    #     A @ x = b    (A: regular matrix, b: constant vector)
+    instance = generater.get_v1_instance()
+
+    model = instance_to_model(instance)
+    model.optimize()
+    state = model_to_state(model, instance)
+    expected = generater.get_v1_state()
+
+    actual_entries = state.entries
+    expected_entries = expected.entries
+
+    # Check the solution of each decision variable
+    for key, actual_value in actual_entries.items():
+        expected_value = expected_entries[key]
+        assert actual_value == pytest.approx(expected_value)
+
+
+def test_integration_milp():
+    # Objective function: - x1 - x2
+    # Constraints:
+    #     3x1 - x2 - 6 <= 0
+    #     -x1 + 3x2 - 6 <= 0
+    #     0 <= x1 <= 10    (x1: integer)
+    #     0 <= x2 <= 10    (x2: continuous)
+    # Optimal solution: x1 = 3, x2 = 3
+    LOWER_BOUND = 0
+    UPPER_BOUND = 10
+    x1 = DecisionVariable.integer(1, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    x2 = DecisionVariable.continuous(2, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    instance = Instance.from_components(
+        decision_variables=[x1, x2],
+        objective=-x1 - x2,
+        constraints=[
+            3 * x1 - x2 <= 6,
+            -x1 + 3 * x2 <= 6,
+        ],
+        sense=Instance.MINIMIZE,
+    )
+
+    model = instance_to_model(instance)
+    model.optimize()
+
+    state = model_to_state(model, instance)
+
+    actual_entries = state.entries
+    assert actual_entries[1] == pytest.approx(3)
+    assert actual_entries[2] == pytest.approx(3)
+
+
+def test_integration_binary():
+    # Objective function: - x1 + x2
+    #     x1, x2: binary
+    # Optimal solution: x1 = 1, x2 = 0
+    x1 = DecisionVariable.binary(1)
+    x2 = DecisionVariable.binary(2)
+    instance = Instance.from_components(
+        decision_variables=[x1, x2],
+        objective=-x1 + x2,
+        constraints=[],
+        sense=Instance.MINIMIZE,
+    )
+
+    model = instance_to_model(instance)
+    model.optimize()
+    state = model_to_state(model, instance)
+
+    actual_entries = state.entries
+    assert actual_entries[1] == pytest.approx(1)
+    assert actual_entries[2] == pytest.approx(0)
+
+
+def test_integration_maximize():
+    # Objective function: - x1 + x2（Maximize）
+    #     x1, x2: binary
+    # Optimal solution: x1 = 0, x2 = 1
+    x1 = DecisionVariable.binary(1)
+    x2 = DecisionVariable.binary(2)
+    instance = Instance.from_components(
+        decision_variables=[x1, x2],
+        objective=-x1 + x2,
+        constraints=[],
+        sense=Instance.MAXIMIZE,
+    )
+
+    model = instance_to_model(instance)
+    model.optimize()
+    state = model_to_state(model, instance)
+
+    actual_entries = state.entries
+    assert actual_entries[1] == pytest.approx(0)
+    assert actual_entries[2] == pytest.approx(1)
+
+
+def test_integration_constant_objective():
+    # Objective function: 0
+    # Constraints:
+    #     x1 + x2 - 5 = 0
+    #     0 <= x1 <= 10    (x1: integer)
+    #     0 <= x2 <= 10    (x2: continuous)
+    # Optimal solution: x1, x2, such that x1 + x2 = 5
+    LOWER_BOUND = 0
+    UPPER_BOUND = 10
+    x1 = DecisionVariable.integer(1, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    x2 = DecisionVariable.continuous(2, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    instance = Instance.from_components(
+        decision_variables=[x1, x2],
+        objective=0,
+        constraints=[x1 + x2 - 5 == 0],
+        sense=Instance.MINIMIZE,
+    )
+
+    model = instance_to_model(instance)
+    model.optimize()
+
+    # chack objective
+    assert model.getObjVal() == 0
+
+    state = model_to_state(model, instance)
+
+    actual_entries = state.entries
+    assert actual_entries[1] + actual_entries[2] == pytest.approx(5)
+
+
+def test_integration_quadratic_objective():
+    # Objective function: x1 * x1 + x2 * x2
+    # Constraints:
+    #     x1 + x2 - 4 = 0
+    #     0 <= x1 <= 10    (x1: integer)
+    #     0 <= x2 <= 10    (x2: continuous)
+    # Optimal solution: x1 = 2, x2 = 2
+    LOWER_BOUND = 0
+    UPPER_BOUND = 10
+    x1 = DecisionVariable.integer(1, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    x2 = DecisionVariable.continuous(2, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    instance = Instance.from_components(
+        sense=Instance.MINIMIZE,
+        decision_variables=[x1, x2],
+        objective=Quadratic(
+            rows=[1, 2],
+            columns=[1, 2],
+            values=[1, 1],
+        ),
+        constraints=[x1 + x2 == 4],
+    )
+
+    model = instance_to_model(instance)
+    model.optimize()
+    state = model_to_state(model, instance)
+
+    actual_entries = state.entries
+    assert actual_entries[1] == pytest.approx(2)
+    assert actual_entries[2] == pytest.approx(2)
+
+
+def test_integration_quadratic_constraint():
+    # Objective function: - x1 - x2
+    # Constraints:
+    #     x1 * x1 + x2 * x2 - 100 <= 0
+    #     0 <= x1 <= 10    (x1: integer)
+    #     0 <= x2 <= 10    (x2: continuous)
+    # Optimal solution: x1 = 7, x2 = sqrt(51)
+    LOWER_BOUND = 0
+    UPPER_BOUND = 10
+    x1 = DecisionVariable.integer(1, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    x2 = DecisionVariable.continuous(2, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    instance = Instance.from_components(
+        sense=Instance.MINIMIZE,
+        decision_variables=[x1, x2],
+        objective=-x1 - x2,
+        constraints=[
+            Constraint(
+                function=Quadratic(
+                    columns=[1, 2],
+                    rows=[1, 2],
+                    values=[1, 1],
+                    linear=Linear(terms={}, constant=-100),
+                ),
+                equality=Constraint.LESS_THAN_OR_EQUAL_TO_ZERO,
+            ),
+        ],
+    )
+
+    model = instance_to_model(instance)
+    model.optimize()
+    state = model_to_state(model, instance)
+
+    actual_entries = state.entries
+    assert actual_entries[1] == pytest.approx(7)
+    assert actual_entries[2] == pytest.approx(51**0.5)
+
+
+def test_integration_feasible_constant_constraint():
+    # Objective function: - x1 - x2
+    # Constraints:
+    #     3x1 - x2 - 6 <= 0
+    #     -x1 + 3x2 - 6 <= 0
+    #     0 <= x1 <= 10    (x1: integer)
+    #     0 <= x2 <= 10    (x2: continuous)
+    #     -1 <= 0          (feasible constant constraint)
+    # Optimal solution: x1 = 3, x2 = 3
+    LOWER_BOUND = 0
+    UPPER_BOUND = 10
+    x1 = DecisionVariable.integer(1, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    x2 = DecisionVariable.continuous(2, lower=LOWER_BOUND, upper=UPPER_BOUND)
+    instance = Instance.from_components(
+        decision_variables=[x1, x2],
+        objective=-x1 - x2,
+        constraints=[
+            3 * x1 - x2 <= 6,
+            -x1 + 3 * x2 <= 6,
+            Constraint(
+                function=-1,
+                equality=Constraint.LESS_THAN_OR_EQUAL_TO_ZERO,
+            ),
+        ],
+        sense=Instance.MINIMIZE,
+    )
+
+    model = instance_to_model(instance)
+    model.optimize()
+
+    state = model_to_state(model, instance)
+
+    actual_entries = state.entries
+    assert actual_entries[1] == pytest.approx(3)
+    assert actual_entries[2] == pytest.approx(3)