88 | P a g e reflected in each site in each period k. The third and fourth constraints ensure the correct functioning of the first and second constraints. The fifth constraint ensures that all machines that have been made available to the cell are allocated to the positions available. The final constraint restricts all variables to zero-one values.
89 | P a g e variables. In a conventional Branch and Bound algorithm with integer variables, the integer restriction on variables is relaxed and candidate problems are solved as linear programs by the primal-simplex algorithm. In Implicit Enumeration the linear constraints are relaxed while the zero-one restriction is maintained. Variables are set using rules in order to solve the relaxed version of the problem.
An Implicit Enumeration solver for zero-one quadratic programs was developed specifically for this research in the Matlab® program development environment. The program code is available on the accompanying CD. The Implicit Enumeration algorithm for minimization is as follows:
Implicit Enumeration Algorithm P=Ø; // Define an empty set of problems
po = InitialProblem; //Define the initial problem as the original problem Zbest = ∞; //Define best objective function value
UpperBound=Zbest; // Define the upper bound on the problem
LowerBound=LowerBound(po); // Define the initial lower bound using equation 102 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 = SolveRelaxation(p*); //Solve the relaxation of the problem feasible= FeasibilityCheck(solution); //Determine if the solution is feasible 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
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;
end end
P = Branch(P); // Branch on the existing problems to create new problems
90 | P a g e // Identify active problems and establish a lower bound
[P, LowerBound]= ActiveProblems(P);
Until (P=Ø or UpperBound-LowerBound=0) //Terminate on condition
The initialization procedures for the Implicit Enumeration algorithm are similar to that of the Branch and Bound algorithm presented in section 6.3.3. The exception is that the lower bound (LB) on the original problem is established by the LowerBound() function. The LowerBound() function implements the following calculation:
𝐿𝐵 = ∑ 𝑚𝑖𝑛 {𝑐𝑖+1 2𝑞𝑖𝑖+1
2∑ 𝑚𝑖𝑛(𝑞𝑖𝑗, 0)
𝑗≠𝑖
, 0}
𝑛
𝑖=1
(102) Here, the negative contribution of each decision variable to the objective function, is added to LB (effectively xi = 1) and a positive contribution is omitted (effectively xi = 0). The nested summation considered that the contribution of a variable xi to the objective function also depends on the variable xj, since qijxixj = qij if both xi = 1 and xj = 1. The term qii is independent of any other decision variable and is separated from the nested summation.
New problems with a smaller feasible region are created in each iteration of the algorithm. The SelectProblem() function chooses the next problem to solve. The approach adopted here is that the most recent problem added to P is the one that is solved next. This is analogous to a Depth First Search (DFS) on a Branch and Bound tree.
In Implicit Enumeration the definitions of free variables and fixed variables are essential:
Fixed Variables: variables that have been fixed to either a zero or one value by branching.
Free Variables: variables that have not been fixed to hold a value
Variables are fixed by the Branch() function in order from x1,..,xn. A variable may be fixed to xi = 0 or xi = 1. Every branching procedure fixes one variable at a time to produce two new candidate problems with an additional xi that is fixed. In the implementation developed in this research every candidate problem has a set of fixed variables and the task is to determine the values of free variables.
Free variables are explored to develop trial solutions by the SolveRelaxation() function. The relaxed problem is generated by dropping the linear constraints and setting free variables in a manner that minimises the objective function value. Variable xi is set in a solution by first completing the following calculations:
91 | P a g e 𝑙𝑖= 𝑐𝑖+1
2𝑞𝑖𝑖+ ∑ 𝑚𝑖𝑛(0, 𝑞𝑖𝑗)
𝑗≠1 (103)
𝑢𝑖= 𝑐𝑖+1
2𝑞𝑖𝑖+ ∑ 𝑚𝑎𝑥(0, 𝑞𝑖𝑗)
𝑗≠1
(104) Here li and ui are the lowest and highest possible contributions of the variable xi to the objective function. The variable xi is set by the following rules: if li > 0 then xi = 0; if ui < 0 the xi = 1.
In Implicit Enumeration, the constraints of the model are temporarily dropped by the SolveRelaxation() function. The feasibility of a solution checked by the FeasibilityCheck() function after the relaxed problem is solved. The feasibility check is achieved by substituting the solution into the constraints listed as equations 99 and 100. If the solution does not violate the constraints it is feasible. The objective value is computed for all feasible solutions. If the objective value is less than that of the best solution, the current solution is set as the best known solution.
The Branch() function, which has already been discussed, is executed prior to punning the set of active problems. 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 relaxation of the parent problem from which the new problem was derived.
The Implicit Enumeration algorithm will continue as long as there a problems to be explored. The algorithm will terminate when the list of problems is empty or the difference between upper and lower bounds is zero.