The capacity based assignment model is a model of the form:
𝑚𝑖𝑛 𝑓𝑇𝑋 (73)
𝐴. 𝑋 ≤ 𝑏 (74)
𝐴𝑒𝑞. 𝑋 = 𝑏𝑒𝑞 (75)
𝑋 ∈ ℤ+ (76)
Where f is a vector of objective function coefficients, A and Aeq are arrays of coefficients corresponding to the left hand side of constraints, b and beq are the vectors corresponding to the right hand side values of constraints and X represents a vector of n decision variables.
Since the model was possible to represent in a standard form, the Matlab® intlinprog solver was used to solve it. This is the only commercial solver that was used in this research. All other algorithms were developed specifically for this research in the Matlab® program development environment.
75 | P a g e The intlinprog solver implements a Branch and Bound or Branch and Cut algorithm to solve integer and mixed integer programs. The Branch and Bound algorithm was originally developed by Land and Doig [86] and later extended by researchers such as Balas et al [87] to include cutting planes. The Branch and Bound algorithm with cutting planes (Branch and Cut) for minimization problems is described here briefly.
Branch and Bound With Cutting Planes //Initialisation
P=Ø; // Define an empty set of problems
po = InitialProblem; //Define the initial problem as the original ILP Zbest = ∞; //Define best objective function value
UpperBound=Zbest; // Define the upper bound on the problem BestSolution = null; // Define the best solution as null P=P+po; // Add the initial problem to the set of problems Repeat
p* = SelectProblem(P); // Select a problem from among active problems
[solution, feasible ] = SolveRelaxation(p*); //Solve the LP relaxation of the problem if feasible = True // If the solution is feasible
[F*] = ObjectiveValue(solution); // Determine the objective value of the solution if f<ZBest // If the objective value is lower than the best known solution
Integer= isinteger(solution); // Determine if the solution is integer if Integer = True // If the solution is integer
BestSolution=solution; // Set the solution as the best solution ZBest=F*; // Set the objective value as the best value found // Update the upper bound on the problem
UpperBound=ZBest;
else
//Add cutting planes to the LP relaxation p*= AddCuttingPlanes(p*,solution);
if CuttingPlanesFound(p*)
// Solve the LP relaxation again goto SolveRelaxation(p*);
end
76 | P a g e end
end end
[P] = Branch(P)// Branch on the existing problems to create new sub-problems // Identify active problems and establish a lower bound
[P, LowerBound]= ActiveProblems(P);
Until (P=Ø or UpperBound-LowerBound<ε) //Repeat until there are no active problems or the difference between upper and lower bounds is less than epsilon
At initialization a data structure P is defined to hold the set of problems. Traditionally the Branch and Bound algorithm is conducted with a tree type data structure where each node holds a candidate problem. A candidate problem is a problem with a feasible region that is more restricted relative to the original problem. Initially the best objective value and upper bound are set to infinity and the best solution is set to null. The intlinprog solver has the ability to apply heuristics to obtain an initial integer feasible solution and an upper bound, however, this option was not used. The upper bound on future solutions is the objective function value of the best integer feasible solution that has been found. The original problem po is added to the data structure P that contains all problems.
In each iteration of the algorithm a problem is selected from the list of active problems. The problem is then solved as a linear programming problem by relaxing the integer restriction on variables. The primal-simplex algorithm was the option used with the intlinprog solver for all linear programming relaxations. The explanation of the primal-simplex algorithm does not add any value to the objectives of this research; for a description of the primal-simplex algorithm see Vanderbei [88]. If the solution to the relaxed problem is feasible the objective function value is computed. If the variables of the feasible solution are all integer the solution is compared to the best known solution. If the objective value is lower than that of the best known solution it replaces the best solution and the upper bound is updated. If the solution is feasible but with variables that are not integer, cutting planes may be added to problem p* to create a new problem with a tighter lower bound. Cutting planes are added by introducing additional linear constraints to the problem.
If cutting planes have been found and added to p* then the problem is solved again as a linear programming relaxation. If no cutting planes are found the algorithm proceeds to the branch function.
The branch function creates two candidate problems from a selected parent problem by partitioning the feasible region. The list of active problems is then updated; problems that are fathomed are 'pruned' from the set of active problems P. A problem is considered to be fathomed
77 | P a g e if the outcome has been determined without solving it. If a problem has a lower bound that is higher than the established upper bound, this problem is considered to be fathomed and is pruned.
The lower bound on a problem is the objective value that was obtained by solving the linear programing relaxation of the parent problem from which the new problem was derived.
Note that the intlinprog solver is able to operate with or without the use of cutting planes. Cutting planes were only used in situations where solutions were not found in reasonable time. The intlinprog solver has multiple types of cutting planes that may be implemented. Types of cuts that were used to solve integer programming models in this research included Gomory cuts, developed by Gomory [89]; flow cover cuts, by Gu et al [90]; strong CG cuts, by Letchford and Lodi [91];
zero-half cuts, by Caprara and Fischetti [92] and clique cuts, by Atamtürk et al [93].