Type examples/ (coin-or#819)

* initial pass

* black + isort

* add ignores in pulp.py and pulp/__init__.py

* start fixing mypy errors

* fix some mypy

* mypy passes

* move Pattern class definition to be before use

Author: frrad

examples/BeerDistributionProblem.py

@@ -33,7 +33,7 @@
 ]
 
 # The cost data is made into a dictionary
-costs = makeDict([Warehouses, Bars], costs, 0)
+costs_dict = makeDict([Warehouses, Bars], costs, 0)
 
 # Creates the 'prob' variable to contain the problem data
 prob = LpProblem("Beer Distribution Problem", LpMinimize)
@@ -46,7 +46,7 @@
 
 # The objective function is added to 'prob' first
 prob += (
-    lpSum([vars[w][b] * costs[w][b] for (w, b) in Routes]),
+    lpSum([vars[w][b] * costs_dict[w][b] for (w, b) in Routes]),
     "Sum_of_Transporting_Costs",
 )
 

examples/BeerDistributionProblemCompetitorExtension.py

@@ -32,7 +32,7 @@
 ]
 
 # The cost data is made into a dictionary
-costs = makeDict([Warehouses, Bars], costs, 0)
+costs_dict = makeDict([Warehouses, Bars], costs, 0)
 
 # Creates the 'prob' variable to contain the problem data
 prob = LpProblem("Beer Distribution Problem", LpMinimize)
@@ -45,7 +45,7 @@
 
 # The objective function is added to 'prob' first
 prob += (
-    lpSum([vars[w][b] * costs[w][b] for (w, b) in Routes]),
+    lpSum([vars[w][b] * costs_dict[w][b] for (w, b) in Routes]),
     "Sum_of_Transporting_Costs",
 )
 

examples/BeerDistributionProblemWarehouseExtension.py

@@ -25,7 +25,7 @@
 ]
 
 # The cost data is made into a dictionary
-costs = makeDict([Warehouses, Bars], costs, 0)
+costs_dict = makeDict([Warehouses, Bars], costs, 0)
 
 # Creates the 'prob' variable to contain the problem data
 prob = LpProblem("Beer Distribution Problem", LpMinimize)
@@ -38,7 +38,7 @@
 
 # The objective function is added to 'prob' first
 prob += (
-    lpSum([vars[w][b] * costs[w][b] for (w, b) in Routes]),
+    lpSum([vars[w][b] * costs_dict[w][b] for (w, b) in Routes]),
     "Sum_of_Transporting_Costs",
 )
 

examples/BeerDistributionProblem_resolve.py

@@ -34,7 +34,7 @@
 ]
 
 # The cost data is made into a dictionary
-costs = makeDict([Warehouses, Bars], costs, 0)
+costs_dict = makeDict([Warehouses, Bars], costs, 0)
 
 # Creates the 'prob' variable to contain the problem data
 prob = LpProblem("Beer Distribution Problem", LpMinimize)
@@ -47,7 +47,7 @@
 
 # The objective function is added to 'prob' first
 prob += (
-    lpSum([vars[w][b] * costs[w][b] for (w, b) in Routes]),
+    lpSum([vars[w][b] * costs_dict[w][b] for (w, b) in Routes]),
     "Sum_of_Transporting_Costs",
 )
 
@@ -68,10 +68,10 @@
 
 # The problem data is written to an .lp file
 prob.writeLP("BeerDistributionProblem.lp")
-for demand in range(500, 601, 10):
+for demand_value in range(500, 601, 10):
     # reoptimise the problem by increasing demand at bar '1'
     # note the constant is stored as the LHS constant not the RHS of the constraint
-    bar_demand_constraint["1"].constant = -demand
+    bar_demand_constraint["1"].constant = -demand_value
     # or alternatively,
     # prob.constraints["Sum_of_Products_into_Bar_1"].constant = - demand
 

examples/CG.py

@@ -4,6 +4,8 @@
 Authors: Antony Phillips,  Dr Stuart Mitchell  2008
 """
 
+from typing import Dict, List, Optional, Tuple, Union
+
 # Import PuLP modeler functions
 from pulp import *
 
@@ -18,20 +20,24 @@ class Pattern:
     totalRollLength = 20
     lenOpts = ["5", "7", "9"]
 
-    def __init__(self, name, lengths=None):
+    def __init__(self, name: str, lengths: List[int]) -> None:
         self.name = name
         self.lengthsdict = dict(zip(self.lenOpts, lengths))
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
-    def trim(self):
+    def trim(self) -> int:
         return Pattern.totalRollLength - sum(
             [int(i) * int(self.lengthsdict[i]) for i in self.lengthsdict]
         )
 
 
-def masterSolve(Patterns, rollData, relax=True):
+def masterSolve(
+    Patterns: List[Pattern],
+    rollData: Dict[str, List[Union[float, int]]],
+    relax: bool = True,
+) -> Union[Dict[str, float], Tuple[float, Dict[str, int]]]:
     # The rollData is made into separate dictionaries
     (rollDemand, surplusPrice) = splitDict(rollData)
 
@@ -85,13 +91,15 @@ def masterSolve(Patterns, rollData, relax=True):
             varsdict[v.name] = v.varValue
 
         # The number of rolls of each length in each pattern is printed
-        for i in Patterns:
-            print(i, " = %s" % [i.lengthsdict[j] for j in Pattern.lenOpts])
+        for p in Patterns:
+            print(p, " = %s" % [p.lengthsdict[j] for j in Pattern.lenOpts])
 
         return value(prob.objective), varsdict
 
 
-def subSolve(Patterns, duals):
+def subSolve(
+    Patterns: List[Pattern], duals: Dict[str, float]
+) -> Tuple[List[Pattern], bool]:
     # The variable 'prob' is created
     prob = LpProblem("SubProb", LpMinimize)
 

examples/CGcolumnwise.py

@@ -4,8 +4,11 @@
 Authors: Antony Phillips,  Dr Stuart Mitchell  2008
 """
 
+from typing import Any, Dict, List, Optional, Tuple, Union
+
 # Import PuLP modeler functions
 from pulp import *
+from pulp.pulp import LpConstraintVar, LpProblem
 
 
 class Pattern:
@@ -19,21 +22,21 @@ class Pattern:
     lenOpts = ["5", "7", "9"]
     numPatterns = 0
 
-    def __init__(self, name, lengths=None):
+    def __init__(self, name: str, lengths: List[int]) -> None:
         self.name = name
         self.lengthsdict = dict(zip(self.lenOpts, lengths))
         Pattern.numPatterns += 1
 
     def __str__(self):
         return self.name
 
-    def trim(self):
+    def trim(self) -> int:
         return Pattern.totalRollLength - sum(
             [int(i) * int(self.lengthsdict[i]) for i in self.lengthsdict]
         )
 
 
-def createMaster():
+def createMaster() -> Tuple[LpProblem, LpConstraintVar, Dict[str, LpConstraintVar]]:
     rollData = {  # Length Demand SalePrice
         "5": [150, 0.25],
         "7": [200, 0.33],
@@ -71,7 +74,11 @@ def createMaster():
     return prob, obj, constraints
 
 
-def addPatterns(obj, constraints, newPatterns):
+def addPatterns(
+    obj: LpConstraintVar,
+    constraints: Dict[str, LpConstraintVar],
+    newPatterns: List[List[int]],
+) -> None:
     # A list called Patterns is created to contain all the Pattern class
     # objects created in this function call
     Patterns = []
@@ -82,7 +89,7 @@ def addPatterns(obj, constraints, newPatterns):
         for j, k in zip(i, Pattern.lenOpts):
             lsum += j * int(k)
         if lsum > Pattern.totalRollLength:
-            raise ("Length Options too large for Roll")
+            raise Exception("Length Options too large for Roll")
 
         # The number of rolls of each length in each new pattern is printed
         print("P" + str(Pattern.numPatterns), "=", i)
@@ -92,20 +99,22 @@ def addPatterns(obj, constraints, newPatterns):
 
     # The pattern variables are created
     pattVars = []
-    for i in Patterns:
+    for p in Patterns:
         pattVars += [
             LpVariable(
-                "Pattern " + i.name,
+                "Pattern " + p.name,
                 0,
                 None,
                 LpContinuous,
-                (i.cost - Pattern.trimValue * i.trim()) * obj
-                + lpSum([constraints[l] * i.lengthsdict[l] for l in Pattern.lenOpts]),
+                (p.cost - Pattern.trimValue * p.trim()) * obj
+                + lpSum([constraints[l] * p.lengthsdict[l] for l in Pattern.lenOpts]),
             )
         ]
 
 
-def masterSolve(prob, relax=True):
+def masterSolve(
+    prob: LpProblem, relax: bool = True
+) -> Union[Tuple[float, Dict[str, int]], Dict[str, float]]:
     # Unrelaxes the Integer Constraint
     if not relax:
         for v in prob.variables():
@@ -130,7 +139,7 @@ def masterSolve(prob, relax=True):
         return value(prob.objective), varsdict
 
 
-def subSolve(duals):
+def subSolve(duals: Dict[str, float]) -> List[Union[Any, List[int]]]:
     # The variable 'prob' is created
     prob = LpProblem("SubProb", LpMinimize)
 

examples/ComputerPlantProblem.py

@@ -46,7 +46,7 @@
 (supply, fixedCost) = splitDict(supplyData)
 
 # The cost data is made into a dictionary
-costs = makeDict([Plants, Stores], costs, 0)
+costs_dict = makeDict([Plants, Stores], costs, 0)
 
 # Creates the problem variables of the Flow on the Arcs
 flow = LpVariable.dicts("Route", (Plants, Stores), 0, None, LpInteger)
@@ -59,7 +59,7 @@
 
 # The objective function is added to prob - The sum of the transportation costs and the building fixed costs
 prob += (
-    lpSum([flow[p][s] * costs[p][s] for (p, s) in Routes])
+    lpSum([flow[p][s] * costs_dict[p][s] for (p, s) in Routes])
     + lpSum([fixedCost[p] * build[p] for p in Plants]),
     "Total Costs",
 )

examples/SpongeRollProblem1.py

@@ -23,7 +23,7 @@
 cost = 1
 
 # The pattern data is made into a dictionary
-patterns = makeDict([LenOpts, PatternNames], patterns, 0)
+patterns_dict = makeDict([LenOpts, PatternNames], patterns, 0)
 
 # The problem variables of the number of each pattern to make are created
 vars = LpVariable.dicts("Patt", PatternNames, 0, None, LpInteger)
@@ -37,7 +37,7 @@
 # The demand minimum constraint is entered
 for i in LenOpts:
     prob += (
-        lpSum([vars[j] * patterns[i][j] for j in PatternNames]) >= rollDemand[i],
+        lpSum([vars[j] * patterns_dict[i][j] for j in PatternNames]) >= rollDemand[i],
         f"Ensuring enough {i} cm rolls",
     )
 

examples/SpongeRollProblem2.py

@@ -35,7 +35,7 @@
 (rollDemand, surplusPrice) = splitDict(rollData)
 
 # The pattern data is made into a dictionary
-patterns = makeDict([LenOpts, PatternNames], patterns, 0)
+patterns_dict = makeDict([LenOpts, PatternNames], patterns, 0)
 
 # The problem variables of the number of each pattern to make are created
 pattVars = LpVariable.dicts("Patt", PatternNames, 0, None, LpInteger)
@@ -58,7 +58,8 @@
 # The demand minimum constraint is entered
 for i in LenOpts:
     prob += (
-        lpSum([pattVars[j] * patterns[i][j] for j in PatternNames]) - surplusVars[i]
+        lpSum([pattVars[j] * patterns_dict[i][j] for j in PatternNames])
+        - surplusVars[i]
         >= rollDemand[i],
         f"Ensuring enough {i} cm rolls",
     )

examples/SpongeRollProblem3.py

@@ -4,8 +4,12 @@
 Authors: Antony Phillips, Dr Stuart Mitchell    2007
 """
 
+from typing import Any, Dict, List, Tuple, Union
 
-def calculatePatterns(totalRollLength, lenOpts, head):
+
+def calculatePatterns(
+    totalRollLength: int, lenOpts: List[Union[Any, int]], head: List[Union[Any, int]]
+) -> List[List[int]]:
     """
     Recursively calculates the list of options lists for a cutting stock problem. The input
     'tlist' is a pointer, and will be the output of the function call.
@@ -36,7 +40,9 @@ def calculatePatterns(totalRollLength, lenOpts, head):
     return patterns
 
 
-def makePatterns(totalRollLength, lenOpts):
+def makePatterns(
+    totalRollLength: int, lenOpts: List[int]
+) -> Tuple[List[str], List[List[int]], Dict[str, int]]:
     """
     Makes the different cutting patterns for a cutting stock problem.
 
@@ -105,7 +111,7 @@ def makePatterns(totalRollLength, lenOpts):
 
 # The pattern data  is made into a dictionary so it can be called by patterns["7"]["P3"] for example.
 # This will return the number of rolls of length "7" in pattern "P3"
-patterns = makeDict([PatternNames, LenOpts], patterns, 0)
+patterns_dict = makeDict([PatternNames, LenOpts], patterns, 0)
 
 # The variable 'prob' is created
 prob = LpProblem("Cutting Stock Problem", LpMinimize)
@@ -127,7 +133,8 @@ def makePatterns(totalRollLength, lenOpts):
 # The demand minimum constraint is entered
 for j in LenOpts:
     prob += (
-        lpSum([pattVars[i] * patterns[i][j] for i in PatternNames]) - surplusVars[j]
+        lpSum([pattVars[i] * patterns_dict[i][j] for i in PatternNames])
+        - surplusVars[j]
         >= rollDemand[j],
         f"Ensuring enough {j} cm rolls",
     )