An Iterated Local Search for the Job Sequencing
and Tool Switching Problem
An Iterated Local Search for the Job Sequencing
and Tool Switching Problem
Lama Abu Tir
s1822748
July 23, 2013
Abstract
Contents
List of Figures 3
List of Tables 4
1 Introduction 5
2 Literature Review 9
3 Notation and Problem Formulation 14
4 Heuristic Approach 17
4.1 Upper and Lower Bounds . . . 18
4.2 Initial Solution . . . 21
4.2.1 TAT Heuristic . . . 21
4.2.2 KTNS Policy . . . 24
4.3 Iterated Local Search . . . 25
4.3.1 2-OPT Approach . . . 26
4.3.2 Perturbation Criteria . . . 27
4.4 Complexity . . . 28
5 Computational Experiments and Results 30 5.1 Data Description . . . 30
5.2 Upper vs. Lower Bounds . . . 31
5.3 Heuristic Approaches Performance . . . 33
6 Conclusion 38
List of Figures
1 GLB: Undirected graph with lower bounds as edge weights . 21
2 GU B: Undirected graph with upper bounds as edge weights . 21
3 A MST for the graph GLB . . . 22
4 A MST for the graph GU B . . . 22
5 An Eulerian graph corresponding to GLB . . . 23
6 An Eulerian graph corresponding to GU B . . . 23
7 An initial HC for GLB . . . 23
8 An initial HC for GU B . . . 23
9 Optimal tool switches corresponding to the job sequence given in Figure 7 . . . 25
List of Tables
1 Example by Tang and Denardo (1988) . . . 6
2 A non-optimal job sequence vs. an optimal job sequence . . 7
3 Notation . . . 14
4 Refined example by Laporte et al. (2004) . . . 16
5 Upper and lower bounds for the example given in Table 4 . . 19
6 Data description . . . 30
7 TAT heuristic upper bounds vs. lower bounds . . . 32
8 TAT heuristic upper bounds vs. optimal solution . . . 33
9 First experiment results . . . 36
10 Second experiment results . . . 36
11 Third experiment results . . . 37
1
Introduction
The Job Sequencing and Tool Switching Problem (JS-TSP) occurs in cer-tain flexible manufacturing environments in which a set of jobs has to be processed on a flexible machine. In order to process each job, a specified set of tools needs to be present in the magazine of the machine. However, magazines have usually limited tool capacities. Hence, it is often necessary to change tools between two jobs in a sequence. The JS-TSP involves deter-mining an optimal job sequence and the corresponding tools that should be present in the magazine at each instant of time. This is done to minimize the total times a tool is loaded in an empty slot of the magazine as well as the number of times a tool is replaced with another tool, where we refer to both as a tool switch.
The importance of achieving a good solution for the JS-TSP is high-lighted when tool switches on flexible machines take a relatively longer pe-riod of time compared to the processing times of the jobs (Tang and Denardo (1988)). This is also the case when the need arises for several small patches of different jobs to process after each other.
Within the context of this paper, we examine the JS-TSP and deliver a metaheuristic approach by modeling the problem as a particular version of the Traveling Salesman Problem (TSP) (Garey and Johnson (1979)). Actually, as we will show later, the main difference between the JS-TSP and the TSP is that the edge weights of the TSP are fixed given numbers, however the edge weights of the JS-TSP can take different values depending on the job sequence considered. Edge weights here present the number of tool switches needed to process a pair of jobs after each other. We will see in the next sections how to set weights in order to model the JS-TSP as the TSP.
numerical example, first proposed by Tang and Denardo (1988). The data used in this example is given in Table 2. There, ten jobs are considered with a total of nine different tools. We have to schedule all jobs on one flexible machine with a magazine capacity of at most four tools. Our goal is to schedule the jobs with a specific order so that the total number of tool switches is minimal.
Jobs Tools required
1 1 4 8 9 2 1 3 5 3 2 6 7 8 4 7 5 6 6 3 7 1 5 7 9 8 3 5 8 9 5 7 10 1 2 4
Table 1: Example by Tang and Denardo (1988)
When choosing a random order of the jobs1, 21 job switches are required. However, Tang and Denardo (1988) show that a job sequence corresponding to the minimum number of tool switches is S = {1, 10, 3, 5, 8, 2, 6, 7, 9, 4}, which results in 11 tool switches. It is striking that the amount of tool switches is bisected. Especially when tool switches are expensive for compa-nies, minimizing the total number of tool switches reduces the costs drasti-cally. In the aforementioned example, costs due to tool switches are halved. This shows the important practical relevance of this problem.
Table 2 shows the present tools in the magazine at each time for the non-optimal sequence (LHS) as well as for the optimal sequence (RHS). The bold numbers are those tools that were not in the magazine in the previous time and in the magazine in the current time. Therefore, bold
numbers indicate tool switches. As pointed out before, the number of tool switches is significantly lower for the optimal sequence.
Time Jobs Tools in magazine Jobs Tools in magazine Non-optimal sequence Optimal sequence
0 - empty - empty 1 1 1 4 8 9 1 1 4 8 9 2 2 1 3 5 9 10 1 2 4 8 3 3 2 6 7 8 3 2 6 7 8 4 4 2 6 7 8 5 2 6 7 8 5 5 2 6 7 8 8 3 5 7 8 6 6 2 3 6 8 2 1 3 5 7 7 7 1 5 7 9 6 1 3 5 7 8 8 3 5 8 9 7 1 5 7 9 9 9 5 7 8 9 9 1 5 7 9 10 10 1 2 4 9 4 1 5 7 9
Table 2: A non-optimal job sequence vs. an optimal job sequence
In this paper we study the uniform JS-TSP, i.e., a version of the JS-TSP based on the following assumptions: we have to schedule all jobs on one flexible machine, each tool requires only one slot in the magazine of the machine, slots in the magazine are identical, tools never expire and jobs never require more tools than the magazine capacity.
We propose a metaheuristic approach similar to Tang and Denardo (1988) and Crama et al. (1994), by modeling the JS-TSP as a particular version of the TSP. With the first step, we apply the Twice Around the Tree (TAT) approach to find an initial solution (Christofides (1976), Rosenkrantz et al. (1977) and Garey and Johnson (1979)). The TAT heuristic involves finding a Minimum Spanning Tree (MST), duplicating the edges and making shortcuts to formulate an initial Hamiltonian Cycle (HC).
order to judge the performance of our heuristic approach, we use it to solve different instances of the JS-TSP and compare the results to the optimal solution for each instance.
2
Literature Review
In flexible manufacturing systems it is straight forward that tool manage-ment in its diversity has huge impacts on the overall operation of the man-ufacturing enterprise (EIMaraghy (1985), Gray et al. (1993), Blazewicz and Finke (1994), Sodhi et al. (1994), Crama (1997) and Frizelle (2001)).
The JS-TSP is one of the problems faced in flexible manufacturing sys-tems. This problem was studied from (as far as we know) the early eighties. Bard (1988) modeled the JS-TSP as a nonlinear mixed integer program. Afterwards, Tang and Denardo (1988) developed an Integer Linear Pro-gramming (ILP) formulation for the JS-TSP. However, the value of their linear relaxation always amounted to zero, yielding poor computational re-sults. Moreover, Tang and Denardo (1988) proved that given a job sequence, minimizing the number of tool switches can be solved in polynomial-time. This is achieved by using the so called Keep Tool Needed Soonest (KTNS) policy, which leads to optimality. Whenever a tool switch is needed, the KTNS policy suggests that the tool needed the soonest for a future job, should be removed the latest from the magazine.
(1988), it is only capable of solving a small number of instances.
Ghiani et al. (2010) cast the JS-TSP as a nonlinear least cost TSP. They developed a branch-and-cut algorithm which managed to solve more instances than the algorithm proposed by Laporte et al. (2004). Their al-gorithm managed to solve instances with up to 45 jobs and 30 tools. Only instances with less than 25 jobs and 30 tools could be solved to optimality within an hour.
It appears that none of the exact algorithms from the existing literature managed to solve the JS-TSP up to optimality with more than 45 jobs in reasonable time. However, in manufacturing systems, it is common that hundreds of jobs or more may need to schedule. Since the problem is NP-hard (Crama et al. (1994)), it is unpractical to seek an optimal solution for large instances. This fact highlights the importance of heuristic approaches. These approaches provide an advantage of fast performance and (given a sufficient plan) a rather good resulting job sequence.
Moreover, given this sequence, the current sets of tools found by the KTNS policy are optimal.
Crama et al. (1994) developed many heuristic approaches to solve the JS-TSP. The first group of their heuristics includes heuristic approaches based on modeling the JS-TSP as the TSP using lower bounds on the number of tool switches as edge weights such as the Shortest Edge heuristic, Nearest Neighbor heuristic and Farthest Insertion heuristic. Moreover, they consid-ered Block Minimization heuristics by modeling the JS-TSP with a directed graph using upper bounds on the number of tool switches as edge weights. There, they seek a short Hamiltonian path using both a Nearest Neighbor framework and a Farthest Insertion framework.
None of the above mentioned heuristics take the whole job sequence into account when estimating the number of tool switches between each pair of jobs. Hertz et al. (1998) introduced new lower and upper bounds that take this into account. They considered a Farthest Insertion heuristic and a GENI heuristic. Moreover, Alian et al. (1998) and Crama et al. (1994) suggested a Greedy heuristic which considers the current sub-sequence at each step. This heuristic is similar to the Nearest Neighbor heuristic starting with job 1 at each step the ‘nearest’ job is added to the current job sub-sequence. Job j is nearest to job i if given the current sub-sequence the number of tool switches using the KTNS policy is the smallest.
Their results show that the performance of each heuristic strongly de-pends on the value of the ratio R, i.e., the maximum number of tools needed for a job divided by the magazine capacity. They do not report exact com-puting times required by the various methods. Based on their results, the performance of the Greedy heuristic performs better compared to the rest of the heuristics both in terms of quality of the solution found and of the running time.
Hertz et al. (1998) suggested two types of heuristic approaches to solve the JS-TSP. The first by modeling the JS-TSP as the TSP and the sec-ond by using the objective function at each step. In both approaches they use Farthest Insertion, Nearest Neighbor, 2-OPT and generalized insertion methods (GENI and GENIUS). They find that the heuristics based on the TSP performs faster. However those heuristics based on using the objective function yielded better solutions.
Al-Fawzan and Al-Sultan (2002) proposed a tabu search based algorithm to solve the JS-TSP. They developed two versions of the algorithm that utilize both short and long term memory structures. They find that long term memory structures have significant effect on the performance of the algorithm. Furthermore, for their local search they use 2-OPT and random block insertion schemes. Based on their results, their algorithm performs better than a simple random search.
climbing, simulated annealing, tabu search approach and different types of memetic approaches. They also conducted genatic algorithm and memetic algorithms. Their experiments included the beam search methods described by Zhou et al. (2005). Their results indicate that metaheuristics are capable of improving the results obtained by beam search and that tabu search is the most effective local search technique due to its ability of escaping from local optima. Moreover, they find that hill climbing performs better than tabu search when combined with a memetic algorithm. They further provided an extension empirical evaluation that includes statistical comparison among 27 different algorithms.
3
Notation and Problem Formulation
We have to schedule a set of jobs on one flexible machine with limited magazine capacity. To process each job, a set of tools should be present in the magazine. These sets of tools are assumed to be fixed and given. In certain cases tool switches are needed between two consecutive jobs. A job sequence that avoids as much tool switches as possible is preferred and sought after.
In general, different tools might lead to different switching costs. For example, conducting a switch during evening hours might be more expen-sive than switching during morning hours. Moreover, tools might vary in characteristics which could lead to a variation in installation complexity. In our model we assume that switching costs are equal and fixed for all tools and at all-time instances. Given this assumption, we equivalently minimize total number of tool switches instead of minimizing total switching cost.
Furthermore, we assume that each tool requires exactly one slot in the magazine. A further assumption is that the magazine capacity is less than the total number of tools needed. Otherwise, all tools can be kept in the magazine and no tool switches would be necessary. We also assume that the total number of tools needed for each job is at least equal to a given constant cmin and at most equal to a given constant cmax. All notations
used along this paper are presented in Table 3.
N Total number of jobs to process in a given period. M Total number of tools needed to process all the jobs. J Set of jobs to process in a given period.
C Magazine capacity.
cmin Minimum number of tools needed for each job.
cmax Maximum number of tools needed for each job.
Tj Set of tools needed to process job i.
Under the above mentioned assumptions the JS-TSP can be represented with an undirected, complete and weighted graph G = (V, E, W ), where V , E and W represent the sets of nodes, the set of edges and the corresponding edge weights, respectively. The nodes represent the jobs that we have to schedule. A dummy node j0 is added to represent the starting and the
ending points of the machine, where no jobs are being scheduled. The edge weight wj,k ∈ W indicates the number of tool switches needed if job k is
scheduled right after job j. We assume that wj0,k = C and wk,j0 = 0, for all
k ∈ V \{j0}.
Given a sequence S = {j1, ..., ji, ji+1, ..., jN}, the value of the edge weight
wji,ji+1 depends on the set of tools that are present in the magazine at time
i. However, if |Tji| is less than C, knowing which job has been processed
at time i is not sufficient to know which tools are present in the magazine during this period. In fact, the set of tools that are present in the magazine at time i depends on the sub-sequence S0 = {j1, ..., ji}. This implies that the
weights wji,ji+1 can vary within a discrete set depending on the job sequence
considered.
Given the graph G, the JS-TSP is equivalent to finding a minimum HC starting and ending at the dummy job j0. In fact, if the number of tools
needed for each job is equal to the magazine capacity the problem becomes equivalent to the TSP with fixed edge weights.
To clarify the problem and explain the solution approach we will make use of the numerical example given in Section 1. In this example, we have to schedule all jobs have on one flexible machine with a magazine capacity of at most four tools. Our goal is to schedule the jobs with a specific order so that the total number of tool switches is minimum.
It is important to note that if for job i, Ti ⊆ Tk for some job k 6= i (job
necessary tools are already in the magazine. Using this fact, Laporte et al. (2004) refined this example by deleting such jobs since there is no need for tool switches to process them. In this specific example, jobs 4, 5, 6 and 9 are always scheduled after jobs 9, 3, 2 and 7, respectively, and are not explicitly included in the problem anymore. By doing this, the problem is then equivalent to the smaller problem presented in Table 4. Now, we only have six jobs left to schedule instead of ten.
Jobs Tools required
1 1 4 8 9 2 1 3 5 3 2 6 7 8 4 1 5 7 9 5 3 5 8 6 1 2 4
4
Heuristic Approach
If the weights of the JS-TSP are fixed, the problem becomes equivalent to the TSP. Under this setting it is possible to make use of well-known heuristic approaches of the TSP to solve the JS-TSP.
In this section, we continue with the example given in Table 4. We start by finding the upper and the lower bounds of the total possible tool switches between any consecutive jobs. Afterwards, we use these upper and lower bounds as edge weights to model the JS-TSP as the TSP. Then, we apply the TAT heuristic approach to find two initial solutions for the problem. The first is found by using the lower bounds as edge weights, and the second by using the upper bounds as edge weights. Given these two initial solutions, we use the KTNS policy to find the minimum total tool switches and the corresponding sets of tools that should be present in the magazine for each time instant. As a final step, we develop an ILS approach to seek better sequences by using two different 2-OPT frameworks as local search streams: First Improvement OPT and Complete Exploration 2-OPT. Finally in order to move from neighborhood to another we suggest some perturbation criteria. The main steps of our approach are:
Main approach
Step 1: Model the problem as the TSP by fixing the edge weights.
Step 2: Find an initial job sequence for the JS-TSP using the TAT heuris-tic.
Step 3: For this initial sequence, find the corresponding optimal number of tool switches using the KTNS policy.
Step 5: Use some perturbation criteria to move to other neighborhoods and go back to Step 3.
Each step of our main approach is considered separately and explained in depth throughout this section. To clarify the first three steps, we will revisit the example given in Table 4. This section concludes with commentary on the complexity of the problem.
4.1
Upper and Lower Bounds
In order to apply well known TSP heuristic approaches to achieve a solution for the JS-TSP, we need to fix the edge weights. In fact, these edge weights are bounded above and below. For two consecutive jobs ji and ji+1, the
upper and lower bounds are given by
wji,ji+1 ≤ |Tji+1| − |Tji ∩ Tji+1| = uji,ji+1 (1)
wji,ji+1 ≥ max{0, |Tji+1∪ Tji| − C} = lji,ji+1 (2)
In the case when |Tji| = C these bounds coincide. Actually, if Tj = C for
all j ∈ {1, ..., N } the problem is equivalent to the TSP and the edge weights are no longer dependent on the job sequence. The lower bounds given in (2) were used for the first time by Laporte et al. (2004). Our upper bounds given in (1) are equivalent to the upper bounds |Tji+1\Tji| which were used
by Crama et al. (1994). Other alternative upper and lower bounds are suggested by Tang and Denardo (1988), Crama et al. (1994) and Laporte et al. (2004). However, the upper and the lower bounds given in (1) and (2) are the tightest bounds that can be achieved for the general case.
Jobs 1 2 3 4 5 6 (lower bound, upper bound)
1 (2, 2) (3, 3) (2, 3) (2, 3) (1, 1) 2 (2, 3) (3, 4) (1, 2) (0, 1) (1, 2) 3 (3, 3) (3, 3) (3, 3) (2, 2) (2, 2) 4 (2, 2) (1, 1) (3, 3) (2, 2) (2, 2) 5 (2, 3) (0, 1) (2, 3) (2, 3) (2, 3) 6 (1, 2) (1, 2) (2, 3) (2, 3) (2, 3)
Table 5: Upper and lower bounds for the example given in Table 4
side are, respectively, the lower and the upper bounds for the tool switches needed if job j follows job i.
One property of the lower bounds is that wi,j = wj,i for all i 6= j ∈
{1, ..., N }. Given this property, using the lower bounds as edge weights, our problem is then equivalent to the TSP and can be presented in an undirected graph which we denote by GLB. However, this symmetry property does
not hold for the upper bounds. So, for two jobs i and j, instead of using the upper bounds ui,j and uj,i, we use as edge weights the values wi,j =
max{ui,j, uj,i}, which are still valid upper bounds. Now, same as with the
lower bounds, the problem is equivalent to the TSP and can be presented with an undirected graph denoted by GU B. The graphs GLB and GU B for
the example given in Table 4 are given in Figures 1 and 2, respectively. One important property of the edge weights of the graph GU B is that
they satisfy the triangular inequality as claimed in proposition 1. However, the edge weights of the graph GLB do not satisfy the triangular inequality.
The importance of this property will be revisited in the next section. Proposition 1 The edge weights of the graph GU B satisfy the triangular
inequality.
Proof of proposition 1 The edge weights of the graph GU B satisfy the
of any two edge weights is greater than the weight of the third edge. In mathematical terms, the edge weights of the graph GU B satisfy the triangular
inequality if and only if equation (3) holds true for all i, j, k ∈ J .
wi,k+ wk,j ≥ wi,j (3)
First, notice that for all nodes i, j ∈ J \{j0} and j0 the following holds.
wi,j+ wi,j0 ≥ wj,j0 (4)
Equation (4) holds since by construction wk,j0 = max{0, C} = C for all
k ∈ J \{j0} and wi,j ≥ 0 for all i, j ∈ J \{j0}. This implies that for any two
nodes i, j ∈ J \{j0} and the node j0 the triangular inequality holds.
Moreover, given the assumption that the edge weights are equal to the upper bounds, for i 6= j ∈ J \{j0} the edge weight wi,j is given by:
wi,j = max{|Ti|, |Tj|} − |Ti∩ Tj| (5)
Given (5), for i, j, k ∈ J \j0 we have:
wi,k+ wk,j = max{|Ti|, |Tk|} − |Ti∩ Tk| + max{|Tk|, |Tj|} − |Tk∩ Tj|
= max{|Ti|, |Tk|} + max{|Tk|, |Tj|} −| (Ti∩ Tk) ∪ (|Tk∩ Tj|) | − |Ti∩ Tj∩ Tk| (6) ≥ max{|Ti|, |Tk|} + max{|Tk|, |Tj|} − |Tk| − |Ti∩ Tj∩ Tk|(7) ≥ max{|Ti|, |Tj|} − |Ti∩ Tj∩ Tk| (8) ≥ max{|Ti|, |Tj|} − |Ti∩ Tj| (9) = wi,j
Furthermore, (8) follows since |Tk| ≤ min{max{|Ti|, |Tk|}, max{|Tk|, |Tj|}}.
Finally (9) follows since for any sets A, B and C we have that A ∩ B ∩ C ∈ A ∩ B. This completes the proof of Proposition 1.
Figure 1: GLB: Undirected graph with
lower bounds as edge weights
Figure 2: GU B: Undirected graph with
upper bounds as edge weights
4.2
Initial Solution
In this section we apply the TAT heuristic to find two initial job sequences of Example 4. The first using the graph GLB and the second using the graph
GU B. Afterwards, for each of these sequences we compute the optimal total
number of tool switches by using the KTNS policy.
4.2.1 TAT Heuristic
Given the graphs GU B and GLB in Figures 1 and 2, we want to find the
least cost way to visit each node exactly once and start and end at j0 i.e. a
HC. An initial HC can be found using the TAT heuristic. The TAT heuristic works in the following way2:
Step 1: Given an undirected graph G, find a MST.
Step 2: Duplicate the edges of this tree to formulate an Eulerian graph and a corresponding Eulerian Cycle (EC), i.e a cycle that visits each edge exactly once.
Step 3: Make shortcuts to formulate a HC.
In order to find a MST we use Kruskal’s Algorithm3. This algorithm
works as follows:
Step 1: Given an undirected graph G = (V, E), construct a spanning forest H = (V, F ) with F = Φ.
Step 2: Add the edge with the lowest weight e /∈ F to F so that H remains a forest.
Step 3: If H is a spanning tree, stop. Otherwise go to Step 2.
We apply Kruskal’s algorithm to find a MST for the graphs GLB and
GU B. These trees are given in Figures 3 and 4.
Figure 3: A MST for the graph GLB Figure 4: A MST for the graph GU B
Given these MST’s, we move on to Step 2 of the TAT heuristic. There, we duplicate the edges of the MST’s to formulate two corresponding Eulerian graphs. These graphs are reported in Figures 5 and 6.
Figure 5: An Eulerian graph corre-sponding to GLB
Figure 6: An Eulerian graph corre-sponding to GU B
A possible EC corresponding to the Eulerian graph in 5 is given by: ECl = {0 → 1 → 6 → 2 → 5 → 2 → 4 → 2 → 6 → 3 → 6 → 1 → 0}.
Similarly, an EC corresponding to the Eulerian graph in 6 is: ECu= {0 →
1 → 6 → 2 → 5 → 2 → 6 → 3 → 6 → 1 → 4 → 1 → 0}. By making shortcuts, we obtain two initial solutions, the first corresponding to GLB
and the second corresponding to GU B. These solutions are presented in
Figures 7 and 8.
Figure 7: An initial HC for GLB Figure 8: An initial HC for GU B
the value of the minimum HC corresponding to the same graph. However, this is not the case when using the lower bounds as edge weights. This occurs since these weights do not satisfy the triangular inequality.
Proposition 2 Any HC on the graph GU B found using the TAT heuristic
has a value of at most two times the value of the minimum HC corresponding to the same graph.
Proof of proposition 2 Given the graph GU B, denote the HC found using
the TAT heuristic by HT AT, the optimal HC by Hmin and V (T ) the value
of any tree T . We want to prove that V (HT AT) ≤ 2 × V (Hmin).
First, notice that V (HT AT) ≤ 2×V (TM ST), where TM ST is the minimum
spanning tree found in Step 1 of the TAT heuristic. This holds because of the triangular inequality.
Moreover, note also that deleting one edge from Hmin forms a spanning
tree. So, since TM ST is a minimum spanning tree it follows that V (TM ST) ≤
V (Hmin). Hence, indeed V (HT AT) ≤ 2 × V (Hmin), which completes the
proof of Proposition 2 (Garey and Johnson (1979)).
Proposition 2 signals that an initial sequence found by using the TAT heuristic with the upper bounds as edge weights is better than the initial sequence found with the lower bounds as edge weights.
However, due to the particular nature of the edge weights of the JS-TSP, a guaranteed solution for the TSP is not necessarily guaranteed for this problem. In Section 5, we show that using the upper bounds as edge weights gives a significantly better TAT initial solution than the initial solution found by using the lower bounds as edge weights.
4.2.2 KTNS Policy
solution. Applying this policy, whenever a tool switch is needed, the tool needed the soonest for a future job is removed the latest from the magazine. Given the initial job sequences in Figures 7 and 8, applying the KTNS policy we find the corresponding HC’s with minimum edge weights (Figures 9 and 10). This yields a total of 12 tool switches for the sequence obtained by using the lower bounds as edge weights and 13 tool switches for the sequence obtained by using the upper bounds as edge weights. For this example an optimal job sequence yields 11 tool switches.
Figure 9: Optimal tool switches corre-sponding to the job sequence given in Figure 7
Figure 10: Optimal tool switches corre-sponding to the job sequence given in Figure 8
4.3
Iterated Local Search
So far, we modeled the JS-TSP as a TSP by using the upper and the lower bounds for the possible tool switches as fixed edge weights. Afterwards, using the TAT heuristic and the KTNS policy we constructed an approach to find an initial sequence.
two different 2-OPT frameworks. Furthermore, we introduce two pertur-bation criteria to escape local optima and to avoid visiting already visited neighborhoods. This section starts by explaining both local search streams and ends by describing both perturbation criteria.
4.3.1 2-OPT Approach
Given an initial sequence at hand, we use local search techniques to achieve a better job sequence. In this paper the 2-OPT approach is used as the main local search stream.
The 2-OPT approach is a simple local search algorithm for the TSP. At each step of this approach, the job sequence is updated by making a 2-swap in order to seek better sequences.
Our approach includes two main 2-OPT frameworks: First Improvement (FI) 2-OPT and Complete Exploration (CE) 2-OPT. In the FI framework, if a better sequence is found, we directly move to its neighborhood. In the CE framework we visit every sequence in the neighborhood of the current solution and move to the neighborhood of the local optimal (the optimal sequence in the current neighborhood).
Here, a neighborhood of a given solution S, with respect to the 2-OPT approach, is the set of all neighbor solutions of S. A solution S0 is a neighbor solution of S if it can be achieved by applying a one step 2-swap on S. Given an initial solution S both 2-OPT frameworks are described as follows:
FI 2-OPT framework
Step 1: Let S be an empty set and add S to S.
Step 2: Construct a solution S0 ∈ S by applying a 2-swap on S and add S/ 0 to S.
CE 2-OPT framework
Step 1: Let S be an empty set and add S to S.
Step 2: Visit all neighbor solutions of S that are not in S and add them to S.
Step 3: Find S0: the neighbor solution of S with the least value (local optimal), update S = S0 and go back to Step 2.
4.3.2 Perturbation Criteria
In both 2-OPT frameworks, after sufficient steps, we might get trapped in a neighborhood. This happens if the current sequence at hand is the local optimal of its neighborhood (if V (S0) ≥ V (S) for all neighbors S0). We apply some perturbation techniques in order to escape local optima and to avoid going back to already visited neighborhoods. In this paper two main perturbation criteria are used.
To escape a 2-OPT neighborhood we apply a perturbation which we la-bel as the b-Steps to the Left (b-SL) perturbation. For instance, if the cur-rent local optimum is the job sequence S = {j1, j2, ..., jN −b, jN −b+1, ..., jN}
applying the b-SL shifts each job b steps to the left to generate the new sequence S0= {jN −b+1, ..., jN, j1, ..., jN −b}.
However, applying the b-SL perturbation many times might lead us to an already visited neighborhood. To prevent this to occur, after applying the b-SL sufficient times we perturb the current local optimal by cutting it in two sub-sequences and inversing each sub-sequence. We refer to this as the Two Sub-Inverse (TSI) perturbation. Suppose the current local minimum is S = {j1, .., jdN/2e, jdN/2+1e, ..., jN} applying the TSI on S gives the new sequence
S0 = {jdN/2e, ..., j1, jN, ..., jdN/2+1e}. Here, dxe refers to the smallest integer
bigger than x.
frame-works and both perturbation techniques, we propose two main settings to seek a better job sequence.
First ILS setting
Step 1: Apply the FI 2-OPT framework on S.
Step 2: If the current sequence S has not been updated the last (N +1)N/2 steps, update S by applying the b-SL perturbation.
Step 3: If the b-SL has been applied dN/be times, update the current se-quence by applying the TSI perturbation.
Second ILS setting
Step 1: Apply the CE 2-OPT framework on S.
Step 2: If the last two rounds returned the same local optimal S, update S by using the b-SL perturbation.
Step 3: If the b-SL has been applied dN/be times, update the current se-quence by applying the TSI perturbation.
For both settings, Step 2 makes sure that we do not get trapped in a local optima of a 2-OPT neighborhood. A 2-OPT neighborhood has (N + 1)N/2 job sequences, so if all these job sequences have been visited and the current job has not been updated a perturbation is needed to get out of the current neighborhood. In the worst case scenario applying the b-SL dN/be times might lead us to the neighborhood where we started. Step 3 prevents this from happening.
4.4
Complexity
Given, a fixed job sequence, the tooling problem considers determining the corresponding sets of tools that should be present in the magazine for each time instant to achieve the minimum number of tool switches.
5
Computational Experiments and Results
In order to judge the performance of the heuristic approaches described in Section 4, we use generated artificial data. This section starts by describing the data used. Afterwards, this section proceeds by discussing the upper and the lower bounds used to model the JS-TSP as the TSP. Then, we continue by testing the performance of the TAT heuristic. Thereafter, we use the heuristic approach built in Section 4 to solve each instance. Finally, this section ends by judging the performance of our approach based on the results of the experiments. All experiments are conducted using python 3.2.1 on a personal Aspire 5749 laptop with Intel(R) Core(TM) i3-2350M CPU @ 2.30GHz and 6.00 GB RAM.
5.1
Data Description
In this section we make use of 160 instances of the JS-TSP. These instances where also used by Crama et al. (1994). In total, we consider 16 instance types where each type is characterized by the values N , M , C, cmax and
cmin and has 10 different JS-TSP instances. Moreover, for all instances
there exist no jobs i, j ∈ J such that job i dominates job j. Table 6 reports summary of the data sets.
Data set obs. N M C cmax cmin Data obs. N M C cmax cmin
A1 10 10 10 4 2 4 C1 10 30 40 15 5 15 A2 10 10 10 5 2 4 C2 10 30 40 17 5 15 A3 10 10 10 6 2 4 C3 10 30 40 20 5 15 A4 10 10 10 7 2 4 C4 10 30 40 25 5 15 B1 10 15 20 6 2 6 D1 10 40 60 20 7 20 B2 10 15 20 8 2 6 D2 10 40 60 22 7 20 B3 10 15 20 10 2 6 D3 10 40 60 25 7 20 B4 10 15 20 12 2 6 D4 10 40 60 30 7 20
Table 6: Data description
each subset the same instances are considered with increasing tool capacity. For each of the ascending subsets from A to D, the number of jobs, tools, magazine capacity, the maximum and minimum numbers of tools possible for each job are increased.
5.2
Upper vs. Lower Bounds
For modeling the JS-TSP as the TSP, we need to fix the edge weights re-gardless of the job sequence. Given that the edge weights are bounded above and below, these upper and lower bounds can be used as fixed edge weights. One important observation regarding the upper bounds is that they sat-isfy the triangular inequality. Therefore, one might expect that the initial solution found by using the upper bounds as edge weights is superior to the one found by using the lower bounds as edge weights. The reasoning behind this expectation is that a TAT initial solution to a metric TSP is guaranteed to have a value of at most twice the optimal value.
We start by testing whether using the upper bounds has any advan-tages over using the lower bounds as edge weights for the JS-TSP. This is done by computing two initial solutions using the TAT heuristic for each instance. The first by using the upper bounds as edge weights and the sec-ond by using the lower bounds as edge weights. For each solution, we apply the KTNS policy to determine the corresponding optimal number of tool switches. From now on, we refer to these optimal values as the value of the solution. Moreover, in order to judge the performance of the TAT heuristic, we compare the value of the TAT initial solution to the value of a randomly picked solution.
Table 7 reports the results of the comparisons. There, the value of the initial sequence found using the TAT heuristic and the upper (lower) bounds as edge weights is denoted by VU B (VLB). Moreover, the value of
Data #VU B > VLB #VU B < VLB #VU B> VRS #VU B< VRS #VLB> VRS #VLB< VRS A1 1 4 0 10 1 8 A2 3 6 2 7 4 6 A3 2 6 3 6 4 4 A4 2 6 2 6 2 3 B1 0 9 0 10 1 9 B2 0 10 0 10 1 5 B3 0 10 0 9 6 4 B4 0 9 0 9 5 4 C1 0 10 0 10 3 7 C2 0 10 0 10 2 7 C3 0 10 0 10 4 6 C4 1 8 1 9 4 5 D1 0 10 0 10 2 8 D2 0 10 0 10 2 7 D3 0 10 0 10 3 7 D4 0 10 0 10 4 6
Table 7: TAT heuristic upper bounds vs. lower bounds
Table 7 Column 1 (2) reports the number of times that the initial value obtained using the upper bounds is worse (better) than the value obtained using the lower bounds for each instance. Column 3 (4) contains the number of times that the initial value obtained using the upper bounds is worse (better) than the value derived using random search. Finally, Column 5 (6) contains the total number of times that the lower bounds yield to a worse (better) solution than the solution obtained using random search.
For more or less all instances the values VU B are less than the values
VLB as well as the values VRS. Therefore, it is most advantageous to use
the upper bounds as edge weights. Consequently, all instances are modeled as the TSP using the upper bounds as edge weights.
JS-TSP as well. To investigate our expectation, we measure the performance of the TAT heuristic on each instance in terms of the ratio R = VU B/Vopt,
where Vobt denotes the optimal value.
The ratio R is computed for all instances and the results can be reviewed in Table 8. One can observe that R never exceeds the value 1.5. This means that for these instances the TAT heuristic always yields an initial sequence with a maximum value of 1.5 the optimal value, which is in line with our expectation. However, we cannot generalize this result.
data #VU B= Vopt max(R) min(R) avg(R) SD(R)
A1 0 1.33 1.14 1.22 0.06 A2 0 1.36 1.09 1.2 0.1 A3 2 1.4 1.0 1.16 0.12 A4 3 1.3 1.0 1.12 0.1 B1 0 1.3 1.16 1.24 0.05 B2 0 1.48 1.09 1.26 0.11 B3 0 1.47 1.05 1.23 0.11 B4 1 1.32 1.0 1.16 0.09 C1 0 1.35 1.25 1.29 0.03 C2 0 1.38 1.24 1.32 0.04 C3 0 1.44 1.28 1.36 0.06 C4 0 1.44 1.24 1.34 0.06 D1 0 1.29 1.17 1.22 0.04 D2 0 1.34 1.19 1.24 0.05 D3 0 1.36 1.2 1.27 0.05 D4 0 1.37 1.2 1.29 0.06
Table 8: TAT heuristic upper bounds vs. optimal solution
5.3
Heuristic Approaches Performance
In order to judge the performance of our heuristic approaches, we suggest the following experiments for all instances:
Experiment 4: Solve each instance using the second ILS setting with b=3. We judge the performance of each setting of our heuristic approach by using the percentage above the optimal solution. For heuristic Hi and a
fixed instance this percentage is given by:
δHi =
VHi− Vopt
Vopt
× 100,
where for each instance Vopt denote the optimal value and VHi denote the
value of the solution obtained using heuristic Hi. For each instance type, we
run each experiment for a fixed number of seconds. In addition, more time is given for larger instances. Furthermore, for each instance type and each experiment we calculate the number of times the solution obtained using the heuristic approach equals the optimal solution. We further determine the number of times this heuristic approach yields a better solution than the one obtained by a random search. Moreover, the number of times that the solution derived using the heuristic is worse than that found using a random search is also derived. The maximum, minimum, average and standard deviation are computed for δHi.
For all experiments we report the results in Tables 9, 10, 11 and 12, respectively. In Tables 9 and 10 the first setting of the ILS heuristic approach is denoted by H1. Moreover, in Tables 11 and 12 the second setting of the
heuristic approach is denoted by H2. In addition, the value of the solution
obtained for a given instance using random search is denoted by VRS.
avg(δH1) for the first experiment are slightly lower than those for the second
experiment for most instances. Consequently, using the first ILS setting with b = 1 performs slightly better than the case when b = 3.
When applying the second heuristic setting in the third experiment, we achieved the optimal value for 47 instances. In the fourth experiment, the optimal value was achieved for 48 instances. For both experiments, the values max(δH2) are very close, same holds for the values min(δH2).
However, avg(δH2) are slightly lower for the third experiment compared to
those values of the fourth experiment.
Furthermore, in the third and fourth experiments the standard devia-tions of δH2 are significantly higher than the standard deviations of δH1
in the first and second experiments. This means that the values of the solutions obtained in the third and fourth experiments vary considerably. However, those values obtained in the first two experiments are more pre-dictable. Moreover, for both approaches choosing b = 1 results in a better performance than using b = 3.
Given the results of the experiments, we observe that the FI 2-OPT framework performs better than the CE 2-OPT framework. A possible explanation might be that the FI 2-OPT forces a move to a solution with a lower value in a faster rate than the CE 2-OPT framework. Even though the CE 2-OPT framework forces a move to a lower value as well, it might take too much time to find a local optimal solution for each neighborhood. Moreover, in some cases a local optimum might be very far from the optimal solution. This also explains the high standard deviation of δH2 in the third and the
Data time VH1= Vopt VH1 < VRS VH1 > VRS max(δH1) min(δH1) avg(δH1) SD(δH1) A1 60 10 2 0 0.0 0.0 0.0 0.0 A2 60 10 1 0 0.0 0.0 0.0 0.0 A3 60 10 0 0 0.0 0.0 0.0 0.0 A4 60 10 0 0 0.0 0.0 0.0 0.0 B1 120 8 10 0 7.41 0.0 1.14 2.41 B2 120 9 10 0 4.35 0.0 0.43 1.3 B3 120 8 7 0 5.26 0.0 1.0 2.01 B4 120 10 1 0 0.0 0.0 0.0 0.0 C1 240 0 10 0 13.59 4.85 9.29 2.51 C2 240 0 10 0 17.81 5.75 12.19 2.97 C3 240 0 10 0 13.24 4.76 9.73 2.66 C4 240 0 10 0 14.81 3.7 9.61 3.4 D1 480 0 10 0 16.94 5.24 10.11 3.22 D2 480 0 10 0 12.94 7.03 11.02 1.58 D3 480 0 10 0 15.71 8.09 12.04 2.11 D4 480 0 10 0 15.89 9.23 12.73 1.98
Table 9: First experiment results
Data time VH1= Vopt VH1 < VRS VH1 > VRS max(δH1) min(δH1) avg(δH1) SD(δH1)
A1 60 10 1 0 0.0 0.0 0.0 0.0 A2 60 10 0 0 0.0 0.0 0.0 0.0 A3 60 10 0 0 0.0 0.0 0.0 0.0 A4 60 10 0 0 0.0 0.0 0.0 0.0 B1 120 8 10 0 7.41 0.0 1.05 2.31 B2 120 7 10 0 4.76 0.0 1.35 2.06 B3 120 8 7 0 5.56 0.0 1.08 2.16 B4 120 10 0 0 0.0 0.0 0.0 0.0 C1 240 0 10 0 14.29 8.0 10.61 1.63 C2 240 0 10 0 16.44 3.45 11.58 3.39 C3 240 0 10 0 15.87 8.57 12.02 2.76 C4 240 0 10 0 16.0 4.08 9.9 3.49 D1 480 0 10 0 15.5 6.67 11.58 2.49 D2 480 0 10 0 18.63 7.57 12.65 2.77 D3 480 0 10 0 15.98 6.62 13.05 2.71 D4 480 0 10 0 17.76 11.48 14.47 1.98
Data time VH2= Vopt VH2 < VRS VH2 > VRS max(δH2) min(δH2) avg(δH2) SD(δH2) A1 60 6 0 3 18.18 0.0 4.19 5.85 A2 60 9 0 1 9.09 0.0 0.91 2.73 A3 60 8 0 2 10.0 0.0 2.0 4.0 A4 60 10 0 0 0.0 0.0 0.0 0.0 B1 120 2 8 0 18.52 0.0 7.27 5.82 B2 120 3 9 0 9.52 0.0 4.52 3.59 B3 120 2 1 2 15.79 0.0 5.11 4.08 B4 120 7 2 2 5.26 0.0 1.55 2.37 C1 240 0 10 0 16.51 9.43 13.55 2.62 C2 240 0 10 0 19.18 5.88 14.5 4.19 C3 240 0 10 0 17.65 8.7 14.57 2.71 C4 240 0 10 0 22.0 10.71 14.48 3.92 D1 480 0 10 0 21.35 9.52 14.69 3.59 D2 480 0 10 0 22.98 11.35 15.4 3.12 D3 480 0 10 0 20.0 10.29 15.33 2.72 D4 480 0 10 0 21.93 12.31 17.0 3.16
Table 11: Third experiment results
Data time VH2= Vopt VH2 < VRS VH2 > VRS max(δH2) min(δH2) avg(δH2) SD(δH2)
A1 60 4 1 4 18.18 0.0 5.62 5.52 A2 60 9 0 1 9.09 0.0 0.91 2.73 A3 60 7 0 3 10.0 0.0 3.0 4.58 A4 60 10 0 0 0.0 0.0 0.0 0.0 B1 120 4 9 0 18.52 0.0 5.2 5.79 B2 120 0 7 0 8.7 4.0 5.01 1.29 B3 120 5 4 1 10.53 0.0 3.62 4.09 B4 120 9 3 1 5.26 0.0 0.53 1.58 C1 240 0 10 0 17.48 7.55 12.98 3.02 C2 240 0 10 0 19.18 9.2 14.6 3.07 C3 240 0 10 0 21.62 8.7 14.87 4.32 C4 240 0 10 0 22.0 7.14 15.01 4.8 D1 480 0 10 0 21.31 10.95 14.7 3.2 D2 480 0 10 0 25.47 10.81 16.08 3.89 D3 480 0 10 0 26.43 13.24 17.16 3.72 D4 480 0 10 0 21.97 13.85 17.8 3.05
6
Conclusion
In this paper we investigated the Job Sequencing and Tool Switching Problem (JS-TSP). This problem involves determining a job sequence on a flexible machine such that the total number of tool switches is minimized.
By observing that the JS-TSP can be modeled as a specific version of the Traveling Salesman Problem (TSP), we adapted well-known heuristic approaches for the TSP to solve the JS-TSP.
We modeled the JS-TSP as the TSP by fixing the edge weights to equal to the upper and the lower bounds of the total number of tool switches. Afterwards, using the Travel Around the Tree (TAT) approach an initial solution for the JS-TSP was derived.
In this paper, the TAT heuristic was applied for the first time to achieve an initial solution for the JS-TSP. The advantage of this approach is that it yields a guaranteed solution for the metric TSP. Given that the upper bounds follow the triangular inequality and the close similarities between the JS-TSP and the TSP, we expected the TAT heuristic to work well for the JS-TSP as well. However, due to the nature of the edge weights of the JS-TSP we could not prove that the TAT heuristic yields a guaranteed solution for the JS-TSP as well. Nevertheless, based on our results, the TAT heuristic seems to yield to a very good solution for all considered instances. In fact, the value of the TAT initial solution using the upper bounds as edge weights is at most 1.5 the optimal value for all considered instances.
criteria: b-Steps to the Left (b-SL) perturbation and Two Sub-Inverse (TSI) perturbation. The former was used to avoid getting trapped in one neighbor-hood and the latter to avoid going back to an already visited neighborneighbor-hood. To evaluate the performance of our approach, we considered 160 different JS-TSP instances. The performance of the approach was judged based on the results of four different experiments. The first two using the first ILS setting with FI 2-OPT framework with b = 1 and b = 3, respectively. The latter ones used the second ILS setting with CE 2-OPT framework with b = 1 and b = 3, respectively.
We found that using the FI 2-OPT framework is more advantageous than using the CE 2-OPT framework. This might be due to the fact that the FI 2-OPT forces the value to decrease by moving to another neighborhood each time a better solution is found. Even though the CE 2-OPT forces the value to decrease by moving to the optimal local minimum, seeking the optimal local minimum might take too much time and sometimes this local minimum might be very far from the optimal. Moreover, our approaches seem to work slightly better for b = 1 than b = 3.
To achieve a more realistic approach, future research should be threefold. First, a tighter upper bound could be used to model the JS-TSP as the TSP. Then, theory about finding a minimum cost Hamiltonian path for directed graphs can be used. Second, the model can be adjusted so that each tool requires different number of slots in the magazine. Third, it might be realistic to consider the case with some restrictions on the placement of tools in the magazine. For instance, in reality some tools might not be allowed to be placed next to each other.
7
Bibliography
Al-Fawzan, M.A. and K.S. Al-Sultan (2002). A tabu search based algo-rithm for minimizing the number of tool switches on a flexible machine. Computers & Industrial Engineering 44, 35 – 47.
Amaya, Jhon Edgar, Carlos Cotta, and Antonio J. Fernandez (2008). A memetic algorithm for the tool switching problem. Hybrid Metaheuristics 5296, 190 – 202.
Amaya, Jhon Edgar, Carlos Cotta, and Antonio J. Fernandez-Leiva (2012). Solving the tool switching problem with memetic algorithms. Artificial Intelligence for Engineering Design, Analysis and Manufacturing 26, 221 – 235.
Avci, Selcuk and M. Selim Akturk (1996). Tool magazine arrangement and operations sequencing on cnc machines. Computers and Operations Research 23, 1069 – 1081.
Balakrishnam, N. and AK. Charkravarty (2001). Opportunitic retooling of a flexible machine subject to failure. Naval Research Logistics 48 (1), 79 – 97.
Bard, Jonathan F. (1988). A heuristic for minimizing the number of tool switches on a flexible machine. IIE Transactions 20 (4), 382–391.
Blazewicz, Jacek and Gerd Finke (1994). Scheduling with resource man-agement in manufacturing systems. European Journal of Operational Re-search 76, 1 – 14.
Cook, William J., William H. Cunningham, William R. Pulleyblank, and Alexander Schrijver (1998). Combinatorial optimization. John Wiley & Sons Inc. , Hoboken, New Jersey, USA.
Crama, Yves (1997). Combinatorial optimization models for production scheduling in automated manufacturing systems. European Journal of Operational Research 99, 136 – 153.
Crama, Yves, Antoon W.J. Kolen, and Alwin G. Oerlemans (1994). Mini-mizing the number of tool switches on a flexible machine. The Interna-tional Journal of Flexible Manufacturing Systems 6, 33 – 54.
Crama, Yves, Linda S. Moonen, Frits C.R. Spieksma, and Ellen Talloen (2007). The tool switching problem revisited. European Journal of Oper-ational Research 182, 952 – 957.
EIMaraghy, Hoda A. (1985). Automated tool management in flexible man-ufacturing. Journal of Manufacturing Systems 4 (1), 1 – 13.
Finke, C. PriC. Privault. (2000). K-server problems with bulk requests: an application to tool switching in manufacturing. Annals of Operations Research 96, 255 – 269.
Frizelle, Rabia Shirazi & G. D. M. (2001). Minimizing the number of tool switches on a flexible machine: An empirical study. International Journal of Production Research 39 (15), 3547 – 3560.
Garey, Michael R. and David S. Johnson (1979). Computers and intractabil-ity: A guide to the theory of NP-completeness. W. H. Freeman and Com-pany, New York, NY, USA.
Gray, Ann E., Abraham Seidmann, and Kathryn E. Stecke (1993). A synthe-sis of decision models for tool management in automated manufacturing. Management Science 39 (5), 549 – 567.
Hertz, Alain, Gilbert Laporte, Michel Mittaz, and Kathryn E. Stecke (1998). Heuristics for minimizing tool switches when scheduling part types on a flexible machine. IIE Transactions 30, 689 – 694.
Hertz, Alain and Marino Widmer (1996). An improved tabu search approach for solving the job shop scheduling problem with tooling constraints. Dis-crete Applied Mathematics 65, 319 – 345.
Hop, Nguyen Van (2005). The tool-switching problem with magazine ca-pacity and tool size constraints. Systems, Man and Cybernetics, Part A: Systems and Humans, IEEE Transactions on 35, 617 – 628.
Keung, K. W., W. H. Ip, and T. C. Lee (2001). A genetic algorithm approach to the multiple machine tool selection problem. Journal of Intelligent Manufacturing 12, 331 – 342.
Laporte, Gilbert, Juan Jose Salazar-Gonzalez, and Frederic Semet (2004). Exact algorithms for the job sequencing and tool switching problem. IIE Transactions 36, 37 – 45.
McGeoch, L. A. and D.D Sleater (1991). A strongly competitive randomized paging algorithm. Algorithmica 6, 816 – 825.
Privault, Caroline and Gerd Finke (1995). Modelling a tool switching prob-lem on a single nc-machine. Journal of Intelligent Manufacturing 6, 87 – 94.
Sodhi, M. S., R. G. Askin, and S. Sen (1994). Multiperiod tool and produc-tion assignment in flexible manufacturing systems. Internaproduc-tional Journal of Production Research 32 (6), 1281 – 1294.
Tang, Christopher S. and Eric V. Denardo (1988). Models arising from a flexible manufacturing machine, part i: Minimization of the number of tool switches. Operations Research 36, 767 – 777.
Tzur, Michal and Avri Altman (2004). Minimization of tool switches for a flexible manufacturing machine with slot assignment of different tool sizes. IIE Transactions 36, 95 – 110.
