ommx-openjij-adapter 1.9.0rc1__tar.gz → 1.9.0rc2__tar.gz

{ommx_openjij_adapter-1.9.0rc1 → ommx_openjij_adapter-1.9.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommx_openjij_adapter
-Version: 1.9.0rc1
+Version: 1.9.0rc2
 Summary: OMMX Adapter for OpenJij.
 Author-email: "Jij Inc." <info@j-ij.com>
 Project-URL: Repository, https://github.com/Jij-Inc/ommx

{ommx_openjij_adapter-1.9.0rc1 → ommx_openjij_adapter-1.9.0rc2}/ommx_openjij_adapter/__init__.py

@@ -4,6 +4,8 @@ from ommx.v1 import Instance, State, Samples, SampleSet
 from ommx.adapter import SamplerAdapter
 import openjij as oj
 from typing_extensions import deprecated
+from typing import Optional
+import copy
 
 
 class OMMXOpenJijSAAdapter(SamplerAdapter):
@@ -46,6 +48,13 @@ class OMMXOpenJijSAAdapter(SamplerAdapter):
     seed: int | None = None
     """ seed for Monte Carlo algorithm """
 
+    uniform_penalty_weight: Optional[float] = None
+    """ Weight for uniform penalty, passed to ``Instance.to_qubo`` """
+    penalty_weights: dict[int, float] = {}
+    """ Penalty weights for each constraint, passed to ``Instance.to_qubo`` """
+    inequality_integer_slack_max_range: int = 32
+    """ Max range for integer slack variables in inequality constraints, passed to ``Instance.to_qubo`` """
+
     @classmethod
     def sample(
         cls,
@@ -61,6 +70,9 @@ class OMMXOpenJijSAAdapter(SamplerAdapter):
         sparse: bool | None = None,
         reinitialize_state: bool | None = None,
         seed: int | None = None,
+        uniform_penalty_weight: Optional[float] = None,
+        penalty_weights: dict[int, float] = {},
+        inequality_integer_slack_max_range: int = 32,
     ) -> SampleSet:
         sampler = cls(
             ommx_instance,
@@ -74,6 +86,9 @@ class OMMXOpenJijSAAdapter(SamplerAdapter):
             sparse=sparse,
             reinitialize_state=reinitialize_state,
             seed=seed,
+            uniform_penalty_weight=uniform_penalty_weight,
+            penalty_weights=penalty_weights,
+            inequality_integer_slack_max_range=inequality_integer_slack_max_range,
         )
         response = sampler._sample()
         return sampler.decode_to_sampleset(response)
@@ -92,8 +107,11 @@ class OMMXOpenJijSAAdapter(SamplerAdapter):
         sparse: bool | None = None,
         reinitialize_state: bool | None = None,
         seed: int | None = None,
+        uniform_penalty_weight: Optional[float] = None,
+        penalty_weights: dict[int, float] = {},
+        inequality_integer_slack_max_range: int = 32,
     ):
-        self.ommx_instance = ommx_instance
+        self.ommx_instance = copy.deepcopy(ommx_instance)
         self.beta_min = beta_min
         self.beta_max = beta_max
         self.num_sweeps = num_sweeps
@@ -104,6 +122,9 @@ class OMMXOpenJijSAAdapter(SamplerAdapter):
         self.sparse = sparse
         self.reinitialize_state = reinitialize_state
         self.seed = seed
+        self.uniform_penalty_weight = uniform_penalty_weight
+        self.penalty_weights = penalty_weights
+        self.inequality_integer_slack_max_range = inequality_integer_slack_max_range
 
     def decode_to_sampleset(self, data: oj.Response) -> SampleSet:
         samples = decode_to_samples(data)
@@ -119,12 +140,16 @@ class OMMXOpenJijSAAdapter(SamplerAdapter):
 
     @property
     def sampler_input(self) -> dict[tuple[int, int], float]:
-        qubo, _offset = self.ommx_instance.as_qubo_format()
+        qubo, _offset = self.ommx_instance.to_qubo(
+            uniform_penalty_weight=self.uniform_penalty_weight,
+            penalty_weights=self.penalty_weights,
+            inequality_integer_slack_max_range=self.inequality_integer_slack_max_range,
+        )
         return qubo
 
     def _sample(self) -> oj.Response:
         sampler = oj.SASampler()
-        qubo, _offset = self.ommx_instance.as_qubo_format()
+        qubo = self.sampler_input
         return sampler.sample_qubo(
             qubo,  # type: ignore
             beta_min=self.beta_min,
@@ -189,10 +214,8 @@ def sample_qubo_sa(
     """
     Deprecated: Use :meth:`OMMXOpenJijSAAdapter.sample` instead
     """
-    q, _offset = instance.as_qubo_format()
-    sampler = oj.SASampler()
-    response = sampler.sample_qubo(
-        q,  # type: ignore
+    sampler = OMMXOpenJijSAAdapter(
+        instance,
         beta_min=beta_min,
         beta_max=beta_max,
         num_sweeps=num_sweeps,
@@ -204,4 +227,5 @@ def sample_qubo_sa(
         reinitialize_state=reinitialize_state,
         seed=seed,
     )
+    response = sampler._sample()
     return decode_to_samples(response)

{ommx_openjij_adapter-1.9.0rc1 → ommx_openjij_adapter-1.9.0rc2}/ommx_openjij_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommx_openjij_adapter
-Version: 1.9.0rc1
+Version: 1.9.0rc2
 Summary: OMMX Adapter for OpenJij.
 Author-email: "Jij Inc." <info@j-ij.com>
 Project-URL: Repository, https://github.com/Jij-Inc/ommx

{ommx_openjij_adapter-1.9.0rc1 → ommx_openjij_adapter-1.9.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ommx_openjij_adapter"
-version = "1.9.0rc1"
+version = "1.9.0rc2"
 
 description = "OMMX Adapter for OpenJij."
 authors = [{ name = "Jij Inc.", email = "info@j-ij.com" }]

ommx_openjij_adapter-1.9.0rc2/tests/test_sample.py

@@ -0,0 +1,147 @@
+from ommx.v1 import Instance, DecisionVariable
+from ommx_openjij_adapter import OMMXOpenJijSAAdapter
+import pytest
+
+
+def binary_no_constraint_minimize():
+    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
+    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
+    instance = Instance.from_components(
+        decision_variables=[x0, x1],
+        objective=x0 + x1,
+        constraints=[],
+        sense=Instance.MINIMIZE,
+    )
+    ans = {(0,): 0.0, (1,): 0.0}
+    return pytest.param(instance, ans, id="binary_no_constraint_minimize")
+
+
+def binary_no_constraint_maximize():
+    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
+    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
+    instance = Instance.from_components(
+        decision_variables=[x0, x1],
+        objective=x0 + x1,
+        constraints=[],
+        sense=Instance.MAXIMIZE,
+    )
+    ans = {(0,): 1.0, (1,): 1.0}
+    return pytest.param(instance, ans, id="binary_no_constraint_maximize")
+
+
+def binary_equality():
+    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
+    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
+    x2 = DecisionVariable.binary(2, name="x", subscripts=[2])
+
+    instance = Instance.from_components(
+        decision_variables=[x0, x1, x2],
+        objective=x0 + 2 * x1 + 3 * x2,
+        constraints=[x1 * x2 == 0],
+        sense=Instance.MAXIMIZE,
+    )
+
+    # x0 = x2 = 1, x1 = 0 is maximum
+    ans = {(0,): 1.0, (1,): 0.0, (2,): 1.0}
+    return pytest.param(instance, ans, id="binary_equality")
+
+
+def binary_inequality():
+    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
+    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
+    x2 = DecisionVariable.binary(2, name="x", subscripts=[2])
+
+    instance = Instance.from_components(
+        decision_variables=[x0, x1, x2],
+        objective=x0 + 2 * x1 + 3 * x2,
+        constraints=[x0 + x1 + x2 <= 2],
+        sense=Instance.MAXIMIZE,
+    )
+
+    # x1 = x2 = 1, x0 = 0 is maximum
+    ans = {(0,): 0.0, (1,): 1.0, (2,): 1.0}
+    return pytest.param(instance, ans, id="binary_inequality")
+
+
+def integer_equality():
+    x0 = DecisionVariable.integer(0, name="x", lower=-1, upper=1, subscripts=[0])
+    x1 = DecisionVariable.integer(1, name="x", lower=-1, upper=1, subscripts=[1])
+
+    instance = Instance.from_components(
+        decision_variables=[x0, x1],
+        objective=x0 + 2 * x1,
+        constraints=[x0 + x1 == 0],
+        sense=Instance.MAXIMIZE,
+    )
+
+    # x1 = -x0 = 1 is maximum
+    ans = {(0,): -1.0, (1,): 1.0}
+    return pytest.param(instance, ans, id="integer_equality")
+
+
+def integer_inequality():
+    x0 = DecisionVariable.integer(0, name="x", lower=-1, upper=1, subscripts=[0])
+    x1 = DecisionVariable.integer(1, name="x", lower=-1, upper=1, subscripts=[1])
+
+    instance = Instance.from_components(
+        decision_variables=[x0, x1],
+        objective=x0 + 2 * x1,
+        constraints=[x0 + x1 <= 0],
+        sense=Instance.MAXIMIZE,
+    )
+
+    # x1 = -x0 = 1 is maximum
+    ans = {(0,): -1.0, (1,): 1.0}
+    return pytest.param(instance, ans, id="integer_inequality")
+
+
+@pytest.mark.parametrize(
+    "instance, ans",
+    [
+        binary_no_constraint_minimize(),
+        binary_no_constraint_maximize(),
+        binary_equality(),
+        binary_inequality(),
+        integer_equality(),
+        integer_inequality(),
+    ],
+)
+def test_sample(instance, ans):
+    sample_set = OMMXOpenJijSAAdapter.sample(
+        instance, num_reads=1, uniform_penalty_weight=3.0, seed=12345
+    )
+    assert sample_set.extract_decision_variables("x", 0) == ans
+
+
+@pytest.mark.parametrize(
+    "instance, ans",
+    [
+        binary_no_constraint_minimize(),
+        binary_no_constraint_maximize(),
+        binary_equality(),
+        binary_inequality(),
+        integer_equality(),
+        integer_inequality(),
+    ],
+)
+def test_solve(instance, ans):
+    solution = OMMXOpenJijSAAdapter.solve(
+        instance, num_reads=1, uniform_penalty_weight=3.0, seed=12345
+    )
+    assert solution.extract_decision_variables("x") == ans
+
+
+@pytest.mark.parametrize(
+    "instance, ans",
+    [
+        binary_no_constraint_minimize(),
+        binary_no_constraint_maximize(),
+        binary_equality(),
+        binary_inequality(),
+        integer_equality(),
+        integer_inequality(),
+    ],
+)
+def test_sample_twice(instance, ans):
+    test_sample(instance, ans)
+    test_sample(instance, ans)

ommx_openjij_adapter-1.9.0rc1/tests/test_sample.py

@@ -1,35 +0,0 @@
-from ommx.v1 import Instance, DecisionVariable
-from ommx_openjij_adapter import OMMXOpenJijSAAdapter
-
-
-def test_minimize():
-    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
-    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
-
-    instance = Instance.from_components(
-        decision_variables=[x0, x1],
-        objective=x0 + x1,
-        constraints=[],
-        sense=Instance.MINIMIZE,
-    )
-    sample_set = OMMXOpenJijSAAdapter.sample(instance, num_reads=1)
-
-    # x0 = x1 = 0 is minimum
-    assert sample_set.extract_decision_variables("x", 0) == {(0,): 0.0, (1,): 0.0}
-
-
-def test_maximize():
-    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
-    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
-
-    instance = Instance.from_components(
-        decision_variables=[x0, x1],
-        objective=x0 + x1,
-        constraints=[],
-        sense=Instance.MAXIMIZE,
-    )
-    instance.as_minimization_problem()
-    sample_set = OMMXOpenJijSAAdapter.sample(instance, num_reads=1)
-
-    # x0 = x1 = 1 is maximum
-    assert sample_set.extract_decision_variables("x", 0) == {(0,): 1.0, (1,): 1.0}