[python] Introduction to pulp

! sw_vers
ProductName: Mac OS X

Python -V

import pulp
import sys

# Declare the optimization (maximization)
prob = pulp.LpProblem('test', pulp.LpMaximize)

# Declare the variables
x = pulp.LpVariable("xx", 0, sys.maxsize, pulp.LpContinuous)
y = pulp.LpVariable("yy", 0, sys.maxsize, pulp.LpContinuous)

# Declare the objective function
prob += ( x + y, "Objective" )

# Declare a constraint
prob += ( 2 * x + y <= 2 , "Constraint_1" )
prob += ( x + 2 * y <= 2 , "Constraint_2" )

prob

result = prob.solve()

print("Result")
print("*" * 8)
print(f "Optimality = {pulp.LpStatus[result]}")
print(f "Objective function value = {pulp.value(prob.objective)}")
print(f "solution x = {pulp.value(x)}")
print(f" y = {pulp.value(y)}")
print("*" * 8)

import pulp
import time

# Set of workers (for convenience, we use a list)
I = ["Mr. A", "Mr. B", "Mr. C"].

print(f "Set of workers I = {I}")

# Set of tasks (for convenience, use a list)
J = ["Task A", "Task B", "Task C"].

print(f "Set of tasks J = {J}")

# Set of costs for assigning worker i to task j (temporary list)
cc = [.
    [ 1, 2, 3],
    [ 4, 6, 8],
    [10, 13, 16],
   ]

# Since cc is a list and the subscripts are numeric.
# Define a dictionary c so that, for example, cc[0][0] can be accessed by c["Mr. A", "Job I"].
c = {} # empty dictionary
for i in I:
  for j in J:
    c[i,j] = cc[I.index(i)][J.index(j)].

print("Cost c[i,j]: ")
for i in I:
  for j in J:
    print(f "c[{i},{j}] = {c[i,j]:2d}, ", end = "")
  print("")
print("")

# Declare mathematical optimization.
# pulp.LpMinimize => Minimize
# pulp.LpMaximize => maximize

prob = pulp.LpProblem('prob', pulp.LpMinimize)

# Dictionary for a set of variables
x = {} # empty dictionary
     # Read and write values in x[i,j] or x[(i,j)], using the tuple (i,j) as key

# Declare a 0-1 variable
for i in I:
  for j in J:
    x[i,j] = pulp.LpVariable(f "x({i},{j})", 0, 1, pulp.LpInteger)
    # Why does the variable label change to '_' when I put '[', ']' or '-'?
# If lowBound and upBound are not specified, they become -infinity and +infinity respectively.

# You can also use comprehension notation.
# x_suffixes = [(i,j) for i in I for j in J].
# LpVariable.dicts("x", x_suffixes, cat = pulp.LpBinary)

# LpContinuous : continuous variable
# LpInteger : Integer variable
# LpBinary : 0-1 variable

# Declare the objective function
prob += pulp.lpSum(c[i,j] * x[i,j] for i in I for j in J), "TotalCost"
# problem += sum(c[i,j] * x[i,j] for i in I for j in J)

# Declare constraints
for i in I:
  prob += sum(x[i,j] for j in J) <= 1, f "Constraint_leq_{i}"
  # If I put '[' or ']' or '-' in the constraint label, why does it change to '_'...?

# For each task j, there is exactly one worker to assign
for j in J:
  prob += sum(x[i,j] for i in I) == 1, f "Constraint_eq_{j}"

# Print the whole expression of the problem
print("Expression in question")
print(f"-" * 8)
print(prob)
print(f"-" * 8)
print("")

# Compute
# Solver specification
solver = pulp.PULP_CBC_CMD()
# pulp.PULP_CBC_CMD() : Coin-CBC that comes with PuLP
# pulp.GUROBI_CMD() : Start Gurobi from command line (.lp file is created temporarily)
# GUROBI() : Launch Gurobi from the library (need to specify the location of the library)

# Start time measurement
time_start = time.perf_counter()

result_status = prob.solve(solver)
# Solver can be specified in () of solve().
# If nothing is specified, pulp.PULP_CBC_CMD()

# End of time measurement
time_stop = time.perf_counter()

# Print the objective function value and solution (if the solution was obtained)
print("Calculation result")
print(f "*" * 8)
print(f "Optimality = {pulp.LpStatus[result_status]}, ", end="")
print(f "objective function value = {pulp.value(prob.objective)}, ", end="")
print(f "Computation time = {time_stop - time_start:.3f} (in seconds)")
print("Solution x[i,j]: ")
for i in I:
  for j in J:
    print(f"{x[i,j].name} = {x[i,j].value()}, ", end="")
  print("")
print(f "*" * 8)