2.3.44

Author: vlkong

examples/cp/basic/color.py

@@ -14,18 +14,18 @@
 Please refer to documentation for appropriate setup of solving configuration.
 """
 
-from docplex.cp.model import *
+from docplex.cp.model import CpoModel
 
 # Create CPO model
 mdl = CpoModel()
 
 # Create model variables containing colors of the countries
-Belgium     = integer_var(0, 3, "Belgium")
-Denmark     = integer_var(0, 3, "Denmark")
-France      = integer_var(0, 3, "France")
-Germany     = integer_var(0, 3, "Germany")
-Luxembourg  = integer_var(0, 3, "Luxembourg")
-Netherlands = integer_var(0, 3, "Netherlands")
+Belgium     = mdl.integer_var(0, 3, "Belgium")
+Denmark     = mdl.integer_var(0, 3, "Denmark")
+France      = mdl.integer_var(0, 3, "France")
+Germany     = mdl.integer_var(0, 3, "Germany")
+Luxembourg  = mdl.integer_var(0, 3, "Luxembourg")
+Netherlands = mdl.integer_var(0, 3, "Netherlands")
 ALL_COUNTRIES = (Belgium, Denmark, France, Germany, Luxembourg, Netherlands)
 
 # Create constraints

examples/cp/basic/facility.py

@@ -31,9 +31,9 @@
 from docplex.cp.model import CpoModel
 from collections import namedtuple
 
-##############################################################################
-## Problem data
-##############################################################################
+#-----------------------------------------------------------------------------
+# Initialize the problem data
+#-----------------------------------------------------------------------------
 
 Warehouse = namedtuple('Wharehouse', ('city',      # Name of the city
                                       'capacity',  # Capacity of the warehouse
@@ -62,9 +62,9 @@
                (54, 64, 65, 89, 89))
 
 
-##############################################################################
-## Modeling
-##############################################################################
+#-----------------------------------------------------------------------------
+# Build the model
+#-----------------------------------------------------------------------------
 
 # Create CPO model
 mdl = CpoModel()
@@ -93,9 +93,9 @@
 mdl.add(mdl.minimize(total_cost))
 
 
-##############################################################################
-## Solving
-##############################################################################
+#-----------------------------------------------------------------------------
+# Solve the model and display the result
+#-----------------------------------------------------------------------------
 
 # Solve model
 print("\nSolving model....")

examples/cp/basic/golomb_ruler.py

@@ -17,22 +17,39 @@
 Please refer to documentation for appropriate setup of solving configuration.
 """
 
-from docplex.cp.model import *
+from docplex.cp.model import CpoModel
 from sys import stdout
 
-# Set model parameters
-ORDER = 8                      # Number of marks
-MAX_LENGTH = (ORDER - 1) ** 2  # Max rule length
+
+#-----------------------------------------------------------------------------
+# Initialize the problem data
+#-----------------------------------------------------------------------------
+
+# Number of marks on the ruler
+ORDER = 8
+
+
+#-----------------------------------------------------------------------------
+# Prepare the data for modeling
+#-----------------------------------------------------------------------------
+
+# Estimate an upper bound to the ruler length
+MAX_LENGTH = (ORDER - 1) ** 2
+
+
+#-----------------------------------------------------------------------------
+# Build the model
+#-----------------------------------------------------------------------------
 
 # Create model
 mdl = CpoModel()
 
 # Create array of variables corresponding to position ruler marks
-marks = integer_var_list(ORDER, 0, MAX_LENGTH, "M")
+marks = mdl.integer_var_list(ORDER, 0, MAX_LENGTH, "M")
 
 # Create marks distances that should be all different
 dist = [marks[i] - marks[j] for i in range(1, ORDER) for j in range(0, i)]
-mdl.add(all_diff(dist))
+mdl.add(mdl.all_diff(dist))
 
 # Avoid symmetric solutions by ordering marks
 mdl.add(marks[0] == 0)
@@ -43,9 +60,13 @@
 mdl.add((marks[1] - marks[0]) < (marks[ORDER - 1] - marks[ORDER - 2]))
 
 # Minimize ruler size (position of the last mark)
-mdl.add(minimize(marks[ORDER - 1]))
+mdl.minimize(marks[ORDER - 1])
+
+
+#-----------------------------------------------------------------------------
+# Solve the model and display the result
+#-----------------------------------------------------------------------------
 
-# Solve model
 print("\nSolving model....")
 msol = mdl.solve(TimeLimit=100)
 

examples/cp/basic/golomb_ruler_all_solutions.py

@@ -29,22 +29,39 @@
 """
 
 
-from docplex.cp.model import *
+from docplex.cp.model import CpoModel
+from docplex.cp.utils import CpoNotSupportedException
 from sys import stdout
 
-# Set model parameters
-ORDER = 7                      # Number of marks
-MAX_LENGTH = (ORDER - 1) ** 2  # Max rule length
+#-----------------------------------------------------------------------------
+# Initialize the problem data
+#-----------------------------------------------------------------------------
+
+# Number of marks on the ruler
+ORDER = 7
+
+
+#-----------------------------------------------------------------------------
+# Prepare the data for modeling
+#-----------------------------------------------------------------------------
+
+# Estimate an upper bound to the ruler length
+MAX_LENGTH = (ORDER - 1) ** 2
+
+
+#-----------------------------------------------------------------------------
+# Build the model
+#-----------------------------------------------------------------------------
 
 # Create model
 mdl = CpoModel()
 
 # Create array of variables corresponding to position rule marks
-marks = integer_var_list(ORDER, 0, MAX_LENGTH, "M")
+marks = mdl.integer_var_list(ORDER, 0, MAX_LENGTH, "M")
 
 # Create marks distances that should be all different
 dist = [marks[i] - marks[j] for i in range(1, ORDER) for j in range(0, i)]
-mdl.add(all_diff(dist))
+mdl.add(mdl.all_diff(dist))
 
 # Avoid symmetric solutions by ordering marks
 mdl.add(marks[0] == 0)
@@ -55,9 +72,14 @@
 mdl.add((marks[1] - marks[0]) < (marks[ORDER - 1] - marks[ORDER - 2]))
 
 # Minimize ruler size (position of the last mark)
-minexpr = minimize(marks[ORDER - 1])
+minexpr = mdl.minimize(marks[ORDER - 1])
 mdl.add(minexpr)
 
+
+#-----------------------------------------------------------------------------
+# Solve the model and display the result
+#-----------------------------------------------------------------------------
+
 # First solve the model to find the smallest ruler length
 msol = mdl.solve(TimeLimit=100)
 if not msol:

examples/cp/basic/golomb_ruler_with_propagate.py

@@ -22,24 +22,38 @@
 Please refer to documentation for appropriate setup of solving configuration.
 """
 
-from docplex.cp.model import *
-from sys import stdout
+from docplex.cp.model import CpoModel, CpoNotSupportedException
 
-from docplex.cp.config import context
 
-# Set model parameters
-ORDER = 10                     # Number of marks
-MAX_LENGTH = (ORDER - 1) ** 2  # Max rule length
+#-----------------------------------------------------------------------------
+# Initialize the problem data
+#-----------------------------------------------------------------------------
+
+# Number of marks on the ruler
+ORDER = 8
+
+
+#-----------------------------------------------------------------------------
+# Prepare the data for modeling
+#-----------------------------------------------------------------------------
+
+# Estimate an upper bound to the ruler length
+MAX_LENGTH = (ORDER - 1) ** 2
+
+
+#-----------------------------------------------------------------------------
+# Build the model
+#-----------------------------------------------------------------------------
 
 # Create model
 mdl = CpoModel()
 
 # Create array of variables corresponding to position rule marks
-marks = integer_var_list(ORDER, 0, MAX_LENGTH, "M")
+marks = mdl.integer_var_list(ORDER, 0, MAX_LENGTH, "M")
 
 # Create marks distances that should be all different
 dist = [marks[i] - marks[j] for i in range(1, ORDER) for j in range(0, i)]
-mdl.add(all_diff(dist))
+mdl.add(mdl.all_diff(dist))
 
 # Avoid symmetric solutions by ordering marks
 mdl.add(marks[0] == 0)
@@ -50,13 +64,16 @@
 mdl.add((marks[1] - marks[0]) < (marks[ORDER - 1] - marks[ORDER - 2]))
 
 # Minimize ruler size (position of the last mark)
-minexpr = minimize(marks[ORDER - 1])
-mdl.add(minexpr)
+mdl.add(mdl.minimize(marks[ORDER - 1]))
+
+
+#-----------------------------------------------------------------------------
+# Solve the model and display the result
+#-----------------------------------------------------------------------------
 
 # Call propagation
-solver = CpoSolver(mdl)
 try:
-    msol = solver.propagate()
-    msol.print_solution()
+   msol = mdl.propagate()
+   msol.print_solution()
 except CpoNotSupportedException:
-    print("The configured solver agent does not support propagation.")
+    print("Method 'propagate' not supported by this solver agent")

examples/cp/basic/golomb_ruler_with_refine_conflicts.py

@@ -23,22 +23,37 @@
 """
 
 
-from docplex.cp.model import *
-from sys import stdout
+from docplex.cp.model import CpoModel
 
-# Set model parameters
-ORDER = 5        # Number of marks
-MAX_LENGTH = 10  # Max rule length, voluntarily TOO SHORT
+#-----------------------------------------------------------------------------
+# Initialize the problem data
+#-----------------------------------------------------------------------------
+
+# Number of marks on the ruler
+ORDER = 5
+
+
+#-----------------------------------------------------------------------------
+# Prepare the data for modeling (Voluntarily wrong)
+#-----------------------------------------------------------------------------
+
+# Estimate an upper bound to the ruler length
+MAX_LENGTH = 10  # TOO SHORT
+
+
+#-----------------------------------------------------------------------------
+# Build the model
+#-----------------------------------------------------------------------------
 
 # Create model
 mdl = CpoModel()
 
 # Create array of variables corresponding to position rule marks
-marks = integer_var_list(ORDER, 0, MAX_LENGTH, "M")
+marks = mdl.integer_var_list(ORDER, 0, MAX_LENGTH, "M")
 
 # Create marks distances that should be all different
 dist = [marks[i] - marks[j] for i in range(1, ORDER) for j in range(0, i)]
-mdl.add(all_diff(dist))
+mdl.add(mdl.all_diff(dist))
 
 # Avoid symmetric solutions by ordering marks
 mdl.add(marks[0] == 0)
@@ -49,17 +64,17 @@
 mdl.add((marks[1] - marks[0]) < (marks[ORDER - 1] - marks[ORDER - 2]))
 
 # Minimize ruler size (position of the last mark)
-minexpr = minimize(marks[ORDER - 1])
-mdl.add(minexpr)
+mdl.add(mdl.minimize(marks[ORDER - 1]))
+
+
+#-----------------------------------------------------------------------------
+# Solve the model and display the result
+#-----------------------------------------------------------------------------
 
 # First solve the model
-solver = CpoSolver(mdl)
-msol = solver.solve()
+msol = mdl.solve()
 if msol:
     msol.print_solution()
 else:
-    try:
-        rsol = solver.refine_conflict()
-        rsol.print_conflict()
-    except CpoNotSupportedException:
-        print("The configured solver agent does not support conflict refiner.")
+    rsol = mdl.refine_conflict()
+    rsol.print_conflict()