always-cautious/ortools-clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

constraint_solver: Start Black formating

Browse Source
This commit is contained in:
Corentin Le Molgat
2023-07-05 18:34:23 +02:00
parent 8be7663396
commit 4ba6ce4e49
3 changed files with 763 additions and 515 deletions
Download Patch File Download Diff File Expand all files Collapse all files

834
ortools/constraint_solver/docs/routing_svg.py
View File

File diff suppressed because it is too large Load Diff

135
ortools/constraint_solver/python/pywrapcp_test.py
View File

@@ -11,6 +11,7 @@
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Unit tests for python/constraint_solver.i. Not exhaustive."""
import sys
@@ -20,7 +21,6 @@ from ortools.constraint_solver import pywrapcp
class SearchMonitorTest(pywrapcp.SearchMonitor):
def __init__(self, solver, nexts):
pywrapcp.SearchMonitor.__init__(self, solver)
self._nexts = nexts
@@ -33,38 +33,35 @@ class SearchMonitorTest(pywrapcp.SearchMonitor):
class DemonTest(pywrapcp.PyDemon):
def __init__(self, x):
pywrapcp.PyDemon.__init__(self)
self._x = x
print('Demon built')
print("Demon built")
def Run(self, solver):
print('in Run(), saw ' + str(self._x))
print("in Run(), saw " + str(self._x))
class ConstraintTest(pywrapcp.PyConstraint):
def __init__(self, solver, x):
pywrapcp.Constraint.__init__(self, solver)
self._x = x
print('Constraint built')
print("Constraint built")
def Post(self):
print('in Post()')
print("in Post()")
self._demon = DemonTest(self._x)
self._x.WhenBound(self._demon)
print('out of Post()')
print("out of Post()")
def InitialPropagate(self):
print('in InitialPropagate()')
print("in InitialPropagate()")
self._x.SetMin(5)
print(self._x)
print('out of InitialPropagate()')
print("out of InitialPropagate()")
class InitialPropagateDemon(pywrapcp.PyDemon):
def __init__(self, ct):
pywrapcp.Demon.__init__(self)
self._ct = ct
@@ -74,7 +71,6 @@ class InitialPropagateDemon(pywrapcp.PyDemon):
class DumbGreaterOrEqualToFive(pywrapcp.PyConstraint):
def __init__(self, solver, x):
pywrapcp.Constraint.__init__(self, solver)
self._x = x
@@ -86,25 +82,23 @@ class DumbGreaterOrEqualToFive(pywrapcp.PyConstraint):
def InitialPropagate(self):
if self._x.Bound():
if self._x.Value() < 5:
print('Reject %d' % self._x.Value())
print("Reject %d" % self._x.Value())
self.solver().Fail()
else:
print('Accept %d' % self._x.Value())
print("Accept %d" % self._x.Value())
class WatchDomain(pywrapcp.PyDemon):
def __init__(self, x):
pywrapcp.Demon.__init__(self)
self._x = x
def Run(self, solver):
for i in self._x.HoleIterator():
print('Removed %d' % i)
print("Removed %d" % i)
class HoleConstraintTest(pywrapcp.PyConstraint):
def __init__(self, solver, x):
pywrapcp.Constraint.__init__(self, solver)
self._x = x
@@ -118,7 +112,6 @@ class HoleConstraintTest(pywrapcp.PyConstraint):
class BinarySum(pywrapcp.PyConstraint):
def __init__(self, solver, x, y, z):
pywrapcp.Constraint.__init__(self, solver)
self._x = x
@@ -132,39 +125,35 @@ class BinarySum(pywrapcp.PyConstraint):
self._z.WhenRange(self._demon)
def InitialPropagate(self):
self._z.SetRange(self._x.Min() + self._y.Min(),
self._x.Max() + self._y.Max())
self._x.SetRange(self._z.Min() - self._y.Max(),
self._z.Max() - self._y.Min())
self._y.SetRange(self._z.Min() - self._x.Max(),
self._z.Max() - self._x.Min())
self._z.SetRange(self._x.Min() + self._y.Min(), self._x.Max() + self._y.Max())
self._x.SetRange(self._z.Min() - self._y.Max(), self._z.Max() - self._y.Min())
self._y.SetRange(self._z.Min() - self._x.Max(), self._z.Max() - self._x.Min())
class PyWrapCp(unittest.TestCase):
def test_member(self):
print('test_member')
solver = pywrapcp.Solver('test member')
x = solver.IntVar(1, 10, 'x')
print("test_member")
solver = pywrapcp.Solver("test member")
x = solver.IntVar(1, 10, "x")
ct = x.Member([1, 2, 3, 5])
print(ct)
def test_sparse_var(self):
print('test_sparse_var')
solver = pywrapcp.Solver('test_sparse_var')
x = solver.IntVar([1, 3, 5], 'x')
print("test_sparse_var")
solver = pywrapcp.Solver("test_sparse_var")
x = solver.IntVar([1, 3, 5], "x")
print(x)
def test_modulo(self):
print('test_modulo')
solver = pywrapcp.Solver('test_modulo')
x = solver.IntVar(0, 10, 'x')
y = solver.IntVar(2, 4, 'y')
print("test_modulo")
solver = pywrapcp.Solver("test_modulo")
x = solver.IntVar(0, 10, "x")
y = solver.IntVar(2, 4, "y")
print(x % 3)
print(x % y)
def test_limit(self):
solver = pywrapcp.Solver('test_limit')
solver = pywrapcp.Solver("test_limit")
# TODO(user): expose the proto-based MakeLimit() API in or-tools and test it
# here.
time = 10000 # ms
@@ -173,80 +162,78 @@ class PyWrapCp(unittest.TestCase):
solutions = sys.maxsize
smart_time_check = True
cumulative = False
limit = solver.Limit(time, branches, failures, solutions,
smart_time_check, cumulative)
limit = solver.Limit(
time, branches, failures, solutions, smart_time_check, cumulative
)
print(limit)
def test_search_monitor(self):
print('test_search_monitor')
solver = pywrapcp.Solver('test search_monitor')
x = solver.IntVar(1, 10, 'x')
ct = (x == 3)
print("test_search_monitor")
solver = pywrapcp.Solver("test search_monitor")
x = solver.IntVar(1, 10, "x")
ct = x == 3
solver.Add(ct)
db = solver.Phase([x], solver.CHOOSE_FIRST_UNBOUND,
solver.ASSIGN_MIN_VALUE)
db = solver.Phase([x], solver.CHOOSE_FIRST_UNBOUND, solver.ASSIGN_MIN_VALUE)
monitor = SearchMonitorTest(solver, x)
solver.Solve(db, monitor)
def test_demon(self):
print('test_demon')
solver = pywrapcp.Solver('test_demon')
x = solver.IntVar(1, 10, 'x')
print("test_demon")
solver = pywrapcp.Solver("test_demon")
x = solver.IntVar(1, 10, "x")
demon = DemonTest(x)
demon.Run(solver)
def test_constraint(self):
print('test_constraint')
solver = pywrapcp.Solver('test_constraint')
x = solver.IntVar(1, 10, 'x')
print("test_constraint")
solver = pywrapcp.Solver("test_constraint")
x = solver.IntVar(1, 10, "x")
myct = ConstraintTest(solver, x)
solver.Add(myct)
db = solver.Phase([x], solver.CHOOSE_FIRST_UNBOUND,
solver.ASSIGN_MIN_VALUE)
db = solver.Phase([x], solver.CHOOSE_FIRST_UNBOUND, solver.ASSIGN_MIN_VALUE)
solver.Solve(db)
def test_failing_constraint(self):
print('test_failing_constraint')
solver = pywrapcp.Solver('test failing constraint')
x = solver.IntVar(1, 10, 'x')
print("test_failing_constraint")
solver = pywrapcp.Solver("test failing constraint")
x = solver.IntVar(1, 10, "x")
myct = DumbGreaterOrEqualToFive(solver, x)
solver.Add(myct)
db = solver.Phase([x], solver.CHOOSE_FIRST_UNBOUND,
solver.ASSIGN_MIN_VALUE)
db = solver.Phase([x], solver.CHOOSE_FIRST_UNBOUND, solver.ASSIGN_MIN_VALUE)
solver.Solve(db)
def test_domain_iterator(self):
print('test_domain_iterator')
solver = pywrapcp.Solver('test_domain_iterator')
x = solver.IntVar([1, 2, 4, 6], 'x')
print("test_domain_iterator")
solver = pywrapcp.Solver("test_domain_iterator")
x = solver.IntVar([1, 2, 4, 6], "x")
for i in x.DomainIterator():
print(i)
def test_hole_iterator(self):
print('test_hole_iterator')
solver = pywrapcp.Solver('test_hole_iterator')
x = solver.IntVar(1, 10, 'x')
print("test_hole_iterator")
solver = pywrapcp.Solver("test_hole_iterator")
x = solver.IntVar(1, 10, "x")
myct = HoleConstraintTest(solver, x)
solver.Add(myct)
db = solver.Phase([x], solver.CHOOSE_FIRST_UNBOUND,
solver.ASSIGN_MIN_VALUE)
db = solver.Phase([x], solver.CHOOSE_FIRST_UNBOUND, solver.ASSIGN_MIN_VALUE)
solver.Solve(db)
def test_sum_constraint(self):
print('test_sum_constraint')
solver = pywrapcp.Solver('test_sum_constraint')
x = solver.IntVar(1, 5, 'x')
y = solver.IntVar(1, 5, 'y')
z = solver.IntVar(1, 5, 'z')
print("test_sum_constraint")
solver = pywrapcp.Solver("test_sum_constraint")
x = solver.IntVar(1, 5, "x")
y = solver.IntVar(1, 5, "y")
z = solver.IntVar(1, 5, "z")
binary_sum = BinarySum(solver, x, y, z)
solver.Add(binary_sum)
db = solver.Phase([x, y, z], solver.CHOOSE_FIRST_UNBOUND,
solver.ASSIGN_MIN_VALUE)
db = solver.Phase(
[x, y, z], solver.CHOOSE_FIRST_UNBOUND, solver.ASSIGN_MIN_VALUE
)
solver.NewSearch(db)
while solver.NextSolution():
print('%d + %d == %d' % (x.Value(), y.Value(), z.Value()))
print("%d + %d == %d" % (x.Value(), y.Value(), z.Value()))
solver.EndSearch()
if __name__ == '__main__':
if __name__ == "__main__":
unittest.main()

309
ortools/constraint_solver/python/pywraprouting_test.py
View File

@@ -11,6 +11,7 @@
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Test routing API."""
from functools import partial
@@ -46,7 +47,6 @@ def Three(unused_i, unused_j):
class Callback(object):
def __init__(self, model):
self.model = model
self.costs = []
@@ -56,12 +56,11 @@ class Callback(object):
class TestRoutingIndexManager(unittest.TestCase):
def testCtor(self):
manager = pywrapcp.RoutingIndexManager(42, 3, 7)
self.assertIsNotNone(manager)
if __debug__:
print(f'class RoutingIndexManager: {dir(manager)}')
print(f"class RoutingIndexManager: {dir(manager)}")
self.assertEqual(42, manager.GetNumberOfNodes())
self.assertEqual(3, manager.GetNumberOfVehicles())
self.assertEqual(42 + 3 * 2 - 1, manager.GetNumberOfIndices())
@@ -86,13 +85,11 @@ class TestRoutingIndexManager(unittest.TestCase):
self.assertEqual(3, manager.GetNumberOfVehicles())
self.assertEqual(42, manager.GetNumberOfIndices())
for i in range(manager.GetNumberOfVehicles()):
self.assertEqual(i + 1,
manager.IndexToNode(manager.GetStartIndex(i)))
self.assertEqual(i + 1, manager.IndexToNode(manager.GetStartIndex(i)))
self.assertEqual(i + 4, manager.IndexToNode(manager.GetEndIndex(i)))
class TestRoutingModel(unittest.TestCase):
def testCtor(self):
manager = pywrapcp.RoutingIndexManager(42, 3, 7)
self.assertIsNotNone(manager)
@@ -102,7 +99,7 @@ class TestRoutingModel(unittest.TestCase):
self.assertEqual(7, manager.IndexToNode(model.Start(i)))
self.assertEqual(7, manager.IndexToNode(model.End(i)))
if __debug__:
print(f'class RoutingModel: {dir(model)}')
print(f"class RoutingModel: {dir(model)}")
def testSolve(self):
manager = pywrapcp.RoutingIndexManager(42, 3, 7)
@@ -131,12 +128,10 @@ class TestRoutingModel(unittest.TestCase):
self.assertIsNotNone(manager)
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
self.assertEqual(1, transit_idx)
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
self.assertEqual(pywrapcp.RoutingModel.ROUTING_NOT_SOLVED,
model.status())
self.assertEqual(pywrapcp.RoutingModel.ROUTING_NOT_SOLVED, model.status())
assignment = model.Solve()
self.assertTrue(assignment)
self.assertEqual(pywrapcp.RoutingModel.ROUTING_SUCCESS, model.status())
@@ -147,8 +142,7 @@ class TestRoutingModel(unittest.TestCase):
self.assertIsNotNone(manager)
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
transit_id = model.RegisterTransitCallback(
lambda from_index, to_index: 1)
transit_id = model.RegisterTransitCallback(lambda from_index, to_index: 1)
self.assertEqual(1, transit_id)
model.SetArcCostEvaluatorOfAllVehicles(transit_id)
self.assertEqual(model.ROUTING_NOT_SOLVED, model.status())
@@ -178,7 +172,8 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
transit_idx = model.RegisterUnaryTransitCallback(
partial(UnaryTransitDistance, manager))
partial(UnaryTransitDistance, manager)
)
self.assertEqual(1, transit_idx)
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
self.assertEqual(model.ROUTING_NOT_SOLVED, model.status())
@@ -222,14 +217,14 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
self.assertEqual(model.ROUTING_NOT_SOLVED, model.status())
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(model.ROUTING_SUCCESS, model.status())
self.assertEqual(90, assignment.ObjectiveValue())
@@ -248,13 +243,13 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(89, assignment.ObjectiveValue())
# Inspect solution
@@ -265,8 +260,7 @@ class TestRoutingModel(unittest.TestCase):
index = assignment.Value(model.NextVar(index))
visited_nodes.append(manager.IndexToNode(index))
self.assertEqual(expected_visited_nodes, visited_nodes)
self.assertTrue(
model.IsEnd(assignment.Value(model.NextVar(model.Start(0)))))
self.assertTrue(model.IsEnd(assignment.Value(model.NextVar(model.Start(0)))))
def testDimensionTSP(self):
manager = pywrapcp.RoutingIndexManager(10, 1, 0)
@@ -274,24 +268,23 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add generic dimension
model.AddDimension(transit_idx, 90, 90, True, 'distance')
distance_dimension = model.GetDimensionOrDie('distance')
model.AddDimension(transit_idx, 90, 90, True, "distance")
distance_dimension = model.GetDimensionOrDie("distance")
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(90, assignment.ObjectiveValue())
# Inspect solution
node = model.Start(0)
cumul = 0
while not model.IsEnd(node):
self.assertEqual(
cumul, assignment.Value(distance_dimension.CumulVar(node)))
self.assertEqual(cumul, assignment.Value(distance_dimension.CumulVar(node)))
next_node = assignment.Value(model.NextVar(node))
cumul += Distance(node, next_node)
node = next_node
@@ -302,25 +295,23 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add generic dimension
model.AddDimensionWithVehicleCapacity(transit_idx, 90, [90], True,
'distance')
distance_dimension = model.GetDimensionOrDie('distance')
model.AddDimensionWithVehicleCapacity(transit_idx, 90, [90], True, "distance")
distance_dimension = model.GetDimensionOrDie("distance")
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(90, assignment.ObjectiveValue())
# Inspect solution
node = model.Start(0)
cumul = 0
while not model.IsEnd(node):
self.assertEqual(
cumul, assignment.Value(distance_dimension.CumulVar(node)))
self.assertEqual(cumul, assignment.Value(distance_dimension.CumulVar(node)))
next_node = assignment.Value(model.NextVar(node))
cumul += Distance(node, next_node)
node = next_node
@@ -331,25 +322,23 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add generic dimension
model.AddDimensionWithVehicleTransits([transit_idx], 90, 90, True,
'distance')
distance_dimension = model.GetDimensionOrDie('distance')
model.AddDimensionWithVehicleTransits([transit_idx], 90, 90, True, "distance")
distance_dimension = model.GetDimensionOrDie("distance")
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(90, assignment.ObjectiveValue())
# Inspect solution
node = model.Start(0)
cumul = 0
while not model.IsEnd(node):
self.assertEqual(
cumul, assignment.Value(distance_dimension.CumulVar(node)))
self.assertEqual(cumul, assignment.Value(distance_dimension.CumulVar(node)))
next_node = assignment.Value(model.NextVar(node))
cumul += Distance(node, next_node)
node = next_node
@@ -360,22 +349,21 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add generic dimension
distances = [
model.RegisterTransitCallback(One),
model.RegisterTransitCallback(Two),
model.RegisterTransitCallback(Three)
model.RegisterTransitCallback(Three),
]
model.AddDimensionWithVehicleTransits(distances, 90, 90, True,
'distance')
distance_dimension = model.GetDimensionOrDie('distance')
model.AddDimensionWithVehicleTransits(distances, 90, 90, True, "distance")
distance_dimension = model.GetDimensionOrDie("distance")
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(90, assignment.ObjectiveValue())
# Inspect solution
@@ -384,7 +372,8 @@ class TestRoutingModel(unittest.TestCase):
cumul = 0
while not model.IsEnd(node):
self.assertEqual(
cumul, assignment.Min(distance_dimension.CumulVar(node)))
cumul, assignment.Min(distance_dimension.CumulVar(node))
)
next_node = assignment.Value(model.NextVar(node))
# Increment cumul by the vehicle distance which is equal to the vehicle
# index + 1, cf. distances.
@@ -397,26 +386,25 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add constant dimension
constant_id, success = model.AddConstantDimension(1, 100, True, 'count')
constant_id, success = model.AddConstantDimension(1, 100, True, "count")
self.assertTrue(success)
self.assertEqual(transit_idx + 1, constant_id)
count_dimension = model.GetDimensionOrDie('count')
count_dimension = model.GetDimensionOrDie("count")
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(90, assignment.ObjectiveValue())
# Inspect solution
node = model.Start(0)
count = 0
while not model.IsEnd(node):
self.assertEqual(count,
assignment.Value(count_dimension.CumulVar(node)))
self.assertEqual(count, assignment.Value(count_dimension.CumulVar(node)))
count += 1
node = assignment.Value(model.NextVar(node))
self.assertEqual(10, count)
@@ -427,23 +415,21 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add vector dimension
values = list(range(10))
unary_transit_idx, success = model.AddVectorDimension(
values,
100, # capacity
True, # fix_start_cumul_to_zero
'vector')
values, 100, True, "vector" # capacity # fix_start_cumul_to_zero
)
self.assertTrue(success)
self.assertEqual(transit_idx + 1, unary_transit_idx)
vector_dimension = model.GetDimensionOrDie('vector')
vector_dimension = model.GetDimensionOrDie("vector")
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
self.assertEqual(model.ROUTING_NOT_SOLVED, model.status())
assignment = model.SolveWithParameters(search_parameters)
self.assertIsNotNone(assignment)
@@ -453,8 +439,7 @@ class TestRoutingModel(unittest.TestCase):
node = model.Start(0)
cumul = 0
while not model.IsEnd(node):
self.assertEqual(cumul,
assignment.Value(vector_dimension.CumulVar(node)))
self.assertEqual(cumul, assignment.Value(vector_dimension.CumulVar(node)))
cumul += values[node]
node = assignment.Value(model.NextVar(node))
@@ -469,17 +454,16 @@ class TestRoutingModel(unittest.TestCase):
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add matrix dimension
matrix_transit_idx, success = model.AddMatrixDimension(
matrix,
100, # capacity
True, # fix_start_cumul_to_zero
'matrix')
matrix, 100, True, "matrix" # capacity # fix_start_cumul_to_zero
)
self.assertTrue(success)
self.assertEqual(transit_idx + 1, matrix_transit_idx)
dimension = model.GetDimensionOrDie('matrix')
dimension = model.GetDimensionOrDie("matrix")
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
self.assertEqual(model.ROUTING_NOT_SOLVED, model.status())
assignment = model.SolveWithParameters(search_parameters)
self.assertIsNotNone(assignment)
@@ -492,8 +476,7 @@ class TestRoutingModel(unittest.TestCase):
self.assertEqual(cumul, assignment.Value(dimension.CumulVar(index)))
prev_index = index
index = assignment.Value(model.NextVar(index))
cumul += matrix[manager.IndexToNode(prev_index)][
manager.IndexToNode(index)]
cumul += matrix[manager.IndexToNode(prev_index)][manager.IndexToNode(index)]
def testMatrixDimensionVRP(self):
manager = pywrapcp.RoutingIndexManager(5, 2, 0)
@@ -506,17 +489,16 @@ class TestRoutingModel(unittest.TestCase):
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add matrix dimension
matrix_transit_idx, success = model.AddMatrixDimension(
matrix,
10, # capacity
True, # fix_start_cumul_to_zero
'matrix')
matrix, 10, True, "matrix" # capacity # fix_start_cumul_to_zero
)
self.assertTrue(success)
self.assertEqual(transit_idx + 1, matrix_transit_idx)
dimension = model.GetDimensionOrDie('matrix')
dimension = model.GetDimensionOrDie("matrix")
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
self.assertEqual(model.ROUTING_NOT_SOLVED, model.status())
assignment = model.SolveWithParameters(search_parameters)
self.assertIsNotNone(assignment)
@@ -527,12 +509,12 @@ class TestRoutingModel(unittest.TestCase):
index = model.Start(v)
cumul = 0
while not model.IsEnd(index):
self.assertEqual(cumul,
assignment.Value(dimension.CumulVar(index)))
self.assertEqual(cumul, assignment.Value(dimension.CumulVar(index)))
prev_index = index
index = assignment.Value(model.NextVar(index))
cumul += matrix[manager.IndexToNode(prev_index)][
manager.IndexToNode(index)]
manager.IndexToNode(index)
]
def testDisjunctionTSP(self):
manager = pywrapcp.RoutingIndexManager(10, 1, 0)
@@ -540,21 +522,26 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add disjunctions
disjunctions = [[manager.NodeToIndex(1),
manager.NodeToIndex(2)], [manager.NodeToIndex(3)],
[manager.NodeToIndex(4)], [manager.NodeToIndex(5)],
[manager.NodeToIndex(6)], [manager.NodeToIndex(7)],
[manager.NodeToIndex(8)], [manager.NodeToIndex(9)]]
disjunctions = [
[manager.NodeToIndex(1), manager.NodeToIndex(2)],
[manager.NodeToIndex(3)],
[manager.NodeToIndex(4)],
[manager.NodeToIndex(5)],
[manager.NodeToIndex(6)],
[manager.NodeToIndex(7)],
[manager.NodeToIndex(8)],
[manager.NodeToIndex(9)],
]
for disjunction in disjunctions:
model.AddDisjunction(disjunction)
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(86, assignment.ObjectiveValue())
# Inspect solution
@@ -571,25 +558,26 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Add disjunctions
disjunctions = [([manager.NodeToIndex(1),
manager.NodeToIndex(2)], 1000),
([manager.NodeToIndex(3)], 1000),
([manager.NodeToIndex(4)], 1000),
([manager.NodeToIndex(5)], 1000),
([manager.NodeToIndex(6)], 1000),
([manager.NodeToIndex(7)], 1000),
([manager.NodeToIndex(8)], 1000),
([manager.NodeToIndex(9)], 0)]
disjunctions = [
([manager.NodeToIndex(1), manager.NodeToIndex(2)], 1000),
([manager.NodeToIndex(3)], 1000),
([manager.NodeToIndex(4)], 1000),
([manager.NodeToIndex(5)], 1000),
([manager.NodeToIndex(6)], 1000),
([manager.NodeToIndex(7)], 1000),
([manager.NodeToIndex(8)], 1000),
([manager.NodeToIndex(9)], 0),
]
for disjunction, penalty in disjunctions:
model.AddDisjunction(disjunction, penalty)
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE)
routing_enums_pb2.FirstSolutionStrategy.FIRST_UNBOUND_MIN_VALUE
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(68, assignment.ObjectiveValue())
# Inspect solution
@@ -602,8 +590,7 @@ class TestRoutingModel(unittest.TestCase):
def testRoutingModelParameters(self):
parameters = pywrapcp.DefaultRoutingModelParameters()
parameters.solver_parameters.CopyFrom(
pywrapcp.Solver.DefaultSolverParameters())
parameters.solver_parameters.CopyFrom(pywrapcp.Solver.DefaultSolverParameters())
parameters.solver_parameters.trace_propagation = True
manager = pywrapcp.RoutingIndexManager(10, 1, 0)
self.assertIsNotNone(manager)
@@ -631,49 +618,49 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Close with parameters
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.SAVINGS)
routing_enums_pb2.FirstSolutionStrategy.SAVINGS
)
search_parameters.local_search_metaheuristic = (
routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
search_parameters.local_search_operators.use_two_opt = (
pywrapcp.BOOL_FALSE)
routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
)
search_parameters.local_search_operators.use_two_opt = pywrapcp.BOOL_FALSE
search_parameters.solution_limit = 20
model.CloseModelWithParameters(search_parameters)
# Solve with parameters
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(
11, model.GetNumberOfDecisionsInFirstSolution(search_parameters))
self.assertEqual(
0, model.GetNumberOfRejectsInFirstSolution(search_parameters))
11, model.GetNumberOfDecisionsInFirstSolution(search_parameters)
)
self.assertEqual(0, model.GetNumberOfRejectsInFirstSolution(search_parameters))
self.assertEqual(90, assignment.ObjectiveValue())
assignment = model.SolveFromAssignmentWithParameters(
assignment, search_parameters)
assignment, search_parameters
)
self.assertEqual(90, assignment.ObjectiveValue())
def testFindErrorInRoutingSearchParameters(self):
params = pywrapcp.DefaultRoutingSearchParameters()
params.local_search_operators.use_cross = pywrapcp.BOOL_UNSPECIFIED
self.assertIn('cross',
pywrapcp.FindErrorInRoutingSearchParameters(params))
self.assertIn("cross", pywrapcp.FindErrorInRoutingSearchParameters(params))
def testCallback(self):
manager = pywrapcp.RoutingIndexManager(10, 1, 0)
self.assertIsNotNone(manager)
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
callback = Callback(model)
model.AddAtSolutionCallback(callback)
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.first_solution_strategy = (
routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)
routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
)
assignment = model.SolveWithParameters(search_parameters)
self.assertEqual(90, assignment.ObjectiveValue())
self.assertEqual(len(callback.costs), 1)
@@ -685,8 +672,7 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# TODO(user): porting this segfaults the tests.
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
routes = [
[
@@ -695,19 +681,16 @@ class TestRoutingModel(unittest.TestCase):
manager.NodeToIndex(5),
manager.NodeToIndex(4),
manager.NodeToIndex(2),
manager.NodeToIndex(6)
],
[
manager.NodeToIndex(7),
manager.NodeToIndex(9),
manager.NodeToIndex(8)
manager.NodeToIndex(6),
],
[manager.NodeToIndex(7), manager.NodeToIndex(9), manager.NodeToIndex(8)],
]
assignment = model.ReadAssignmentFromRoutes(routes, False)
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
search_parameters.solution_limit = 1
solution = model.SolveFromAssignmentWithParameters(
assignment, search_parameters)
assignment, search_parameters
)
self.assertEqual(90, solution.ObjectiveValue())
for vehicle in range(0, model.vehicles()):
node = model.Start(vehicle)
@@ -715,8 +698,7 @@ class TestRoutingModel(unittest.TestCase):
while not model.IsEnd(node):
node = solution.Value(model.NextVar(node))
if not model.IsEnd(node):
self.assertEqual(routes[vehicle][count],
manager.IndexToNode(node))
self.assertEqual(routes[vehicle][count], manager.IndexToNode(node))
count += 1
def testAutomaticFirstSolutionStrategy_simple(self):
@@ -725,15 +707,15 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
self.assertIsNotNone(model.SolveWithParameters(search_parameters))
self.assertEqual(
routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC,
model.GetAutomaticFirstSolutionStrategy())
model.GetAutomaticFirstSolutionStrategy(),
)
def testAutomaticFirstSolutionStrategy_pd(self):
manager = pywrapcp.RoutingIndexManager(31, 7, 0)
@@ -741,12 +723,10 @@ class TestRoutingModel(unittest.TestCase):
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
# Add cost function
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
model.SetArcCostEvaluatorOfAllVehicles(transit_idx)
self.assertTrue(
model.AddDimension(transit_idx, 0, 1000, True, 'distance'))
dst_dimension = model.GetDimensionOrDie('distance')
self.assertTrue(model.AddDimension(transit_idx, 0, 1000, True, "distance"))
dst_dimension = model.GetDimensionOrDie("distance")
# Add few Pickup and Delivery
for request in [[2 * i, 2 * i + 1] for i in range(1, 15)]:
print(request)
@@ -754,21 +734,22 @@ class TestRoutingModel(unittest.TestCase):
delivery_index = manager.NodeToIndex(request[1])
model.AddPickupAndDelivery(pickup_index, delivery_index)
model.solver().Add(
model.VehicleVar(pickup_index) == model.VehicleVar(
delivery_index))
model.VehicleVar(pickup_index) == model.VehicleVar(delivery_index)
)
model.solver().Add(
dst_dimension.CumulVar(pickup_index) <= dst_dimension.CumulVar(
delivery_index))
dst_dimension.CumulVar(pickup_index)
<= dst_dimension.CumulVar(delivery_index)
)
# Solve
search_parameters = pywrapcp.DefaultRoutingSearchParameters()
self.assertIsNotNone(model.SolveWithParameters(search_parameters))
self.assertEqual(
routing_enums_pb2.FirstSolutionStrategy.PARALLEL_CHEAPEST_INSERTION,
model.GetAutomaticFirstSolutionStrategy())
model.GetAutomaticFirstSolutionStrategy(),
)
class TestBoundCost(unittest.TestCase):
def testCtor(self):
bound_cost = pywrapcp.BoundCost()
self.assertIsNotNone(bound_cost)
@@ -782,28 +763,23 @@ class TestBoundCost(unittest.TestCase):
class TestRoutingDimension(unittest.TestCase):
def testCtor(self):
manager = pywrapcp.RoutingIndexManager(31, 7, 3)
self.assertIsNotNone(manager)
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
self.assertTrue(
model.AddDimension(transit_idx, 90, 90, True, 'distance'))
model.GetDimensionOrDie('distance')
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
self.assertTrue(model.AddDimension(transit_idx, 90, 90, True, "distance"))
model.GetDimensionOrDie("distance")
def testSoftSpanUpperBound(self):
manager = pywrapcp.RoutingIndexManager(31, 7, 3)
self.assertIsNotNone(manager)
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
self.assertTrue(
model.AddDimension(transit_idx, 100, 100, True, 'distance'))
dimension = model.GetDimensionOrDie('distance')
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
self.assertTrue(model.AddDimension(transit_idx, 100, 100, True, "distance"))
dimension = model.GetDimensionOrDie("distance")
bound_cost = pywrapcp.BoundCost(97, 43)
self.assertIsNotNone(bound_cost)
@@ -821,18 +797,15 @@ class TestRoutingDimension(unittest.TestCase):
self.assertIsNotNone(manager)
model = pywrapcp.RoutingModel(manager)
self.assertIsNotNone(model)
transit_idx = model.RegisterTransitCallback(
partial(TransitDistance, manager))
self.assertTrue(
model.AddDimension(transit_idx, 100, 100, True, 'distance'))
dimension = model.GetDimensionOrDie('distance')
transit_idx = model.RegisterTransitCallback(partial(TransitDistance, manager))
self.assertTrue(model.AddDimension(transit_idx, 100, 100, True, "distance"))
dimension = model.GetDimensionOrDie("distance")
bound_cost = pywrapcp.BoundCost(97, 43)
self.assertIsNotNone(bound_cost)
self.assertFalse(dimension.HasQuadraticCostSoftSpanUpperBounds())
for v in range(manager.GetNumberOfVehicles()):
dimension.SetQuadraticCostSoftSpanUpperBoundForVehicle(
bound_cost, v)
dimension.SetQuadraticCostSoftSpanUpperBoundForVehicle(bound_cost, v)
bc = dimension.GetQuadraticCostSoftSpanUpperBoundForVehicle(v)
self.assertIsNotNone(bc)
self.assertEqual(97, bc.bound)
@@ -840,5 +813,5 @@ class TestRoutingDimension(unittest.TestCase):
self.assertTrue(dimension.HasQuadraticCostSoftSpanUpperBounds())
if __name__ == '__main__':
if __name__ == "__main__":
unittest.main(verbosity=2)