30
Int. J. Metaheuristics, Vol. 1, No. 1, 2010
Genetic algorithms with different representation schemes for complex hybrid flexible flow line problems Thijs Urlings* and Rubén Ruiz Grupo de Sistemas de Optimización Aplicada, Instituto Tecnológico de Informática, Universidad Politécnica de Valencia, Camino de Vera s/n, Valencia 46022, Spain Fax: +34-963-877-239 E-mail:
[email protected], E-mail:
[email protected] *Corresponding author
Funda Sivrikaya Şerifoğlu Düzce University, Konuralp Yerleskesi, Düzce, 81620 Turkey E-mail:
[email protected] Abstract: This paper introduces some advanced genetic algorithms for a complex hybrid flexible flow line problem with a makespan objective that was recently formulated. General precedence constraints among jobs are taken into account, as are machine release dates, time lags and sequence dependent set-up times; both anticipatory and non-anticipatory. This combination of constraints captures many real world industrial problems; among those is the ceramic tile production that served as our inspiration. The introduced algorithms employ solution representation schemes with different degrees of directness. Several new machine assignment rules are introduced and implemented in some proposed genetic algorithms. The different genetic algorithms are compared among each other and to some heuristics as well. The results indicate that simple solution representation schemes result in the best performance, even for complex scheduling problems and that the genetic algorithms lead to a better solution quality than all tested heuristics. Keywords: hybrid flexible flow line; HFFL; realistic scheduling; genetic algorithms; GAs; precedence constraints; set-up times; time lags. Reference to this paper should be made as follows: Urlings, T., Ruiz, R. and Şerifoğlu, F.S. (2010) ‘Genetic algorithms with different representation schemes for complex hybrid flexible flow line problems’, Int. J. Metaheuristics, Vol. 1, No. 1, pp.30–54. Biographical notes: Thijs Urlings is a Researcher in the Applied Optimisation Systems Group at the Instituto Tecnológico de Informática. He received his MSc in Econometrics and Operational Research from Maastricht University, The Netherlands and he is currently in the thesis process of his PhD at the
Copyright © 2010 Inderscience Enterprises Ltd.
Genetic algorithms with different representation schemes
31
Polytechnical University of Valencia, Spain. Within the Applied Optimisation Systems Group, he is occupied with the development of software solutions for both forecasting and machine scheduling problems. Furthermore, he cooperates in technology transfer projects with industrial companies. Rubén Ruiz is an Associate Professor in the Applied Statistics and Operations Research and Quality Department at the Polytechnic University of Valencia. He received his BS, MSc and PhD from the same university. His MSc dissertation received the Bancaja prize and his PhD thesis received the UPV best dissertation award. He has given more than 100 presentations at national as well as international meetings and workshops and has published over 25 research papers at international journals. He is the Editor of the European Journal of Industrial Engineering and the Associate Editor of Applied Mathematics and Computation Journal. Funda Sivrikaya Şerifoğlu is currently working as the Rector of Düzce University, Turkey. She got her BS in Industrial Engineering from Bogaziçi University, Turkey, her MS in Engineering Economic Systems from Stanford University, USA and her PhD in Industrial Engineering from Bogaziçi University. Her areas of research interest are project and machine scheduling and application of metaheuristic techniques to combinatorial optimisation problems. She is also interested in sustainable development and takes actively part in several NGO- and social responsibility projects.
1
Introduction
We address a complex hybrid flexible flow line (HFFL) scheduling problem using a genetic algorithm (GA) approach. Since the first studies on scheduling by Salveson (1952) and Johnson (1954), a rich body of literature has been published including a wide range of problems with various characteristics. Yet, many researchers have noted in their papers that there has always been a so-called gap between the theory and practice of scheduling. Reisman et al. (1997) provide a statistical review on flowshop sequencing/scheduling research between years 1952–1994. They discuss the exponentially growing body of literature on this subject and conclude that from a total of 170 reviewed papers, only five (i.e., 3%) dealt with true applications. According to Schutten (1998), high level algorithms are developed in the operations research literature, but side constraints that occur in practice are seldom considered. The paper illustrates how the shifting bottleneck procedure for the classical job shop can be extended to deal with practical features such as transportation times, set-ups, downtimes, multiple resources and convergent job routings. Allaoui and Artiba (2004) also conjecture that there is a large gap between the literature of scheduling and the real life industry. The paper deals with a practical and stochastic hybrid flow shop scheduling problem with set-up, cleaning and transportation times and maintenance constraints to optimise several objectives based on flow time and due dates. Another paper involving realistic considerations is provided by Low (2005) who considers a flowshop with multiple unrelated machines, independent set-up and dependent removal times. A simulated annealing-based heuristic is proposed to optimise the total flow time in the system.
32
T. Urlings et al.
Although there is a recent trend towards a more realistic formulation of scheduling problems such as the ones reviewed above, there are still not many research efforts to jointly consider realistic constraints prevailing in the real world manufacturing environments. In this study, we consider a complex production process that can be found in many industries due to its generality. The ceramic tile production is a good example. Each of the stages in the production of ceramic tiles typically contains various parallel machines that have different processing speeds and other important characteristics. Special moulding machines, for example, are only able to process tiles of a given size. For composite ceramic products, some batches of ceramic tiles have to be finished before other batches can be started since they are used as raw materials. Mosaics, stair steps and tile edges are a few examples. A job, defined as a batch of tiles, does not need to be finished entirely at the glazing line in order to start processing at the kiln firing stage. When a sufficient quantity of tiles has been glazed, these can enter in the kiln, while the remaining ones are still being glazed. Therefore, overlapping occurs. After the kiln firing stage, the tiles have to cool down and positive time lags or waiting times appear. Large set-ups are needed if a batch of tiles is processed after another batch of different size at a multiformat moulding machine. The set-ups in the ceramic tile industry are usually anticipatory. Client orders typically arrive while working on previous orders. Machines are therefore only released when they finish working on prior orders. Another example is the process of furniture manufacturing, where the same problem characteristics arise. Some of the jobs can only be done on specialised machines. Production lines are seldom encountered empty, so machine availability from the start cannot be assumed. A drying time has to be taken into account after the painting stage. This can be modelled as a positive time lag. Attaching pieces of wood to the machines are non-anticipatory set-ups. Anticipatory set-ups occur as well, if the paint colour has to be changed, for example. One important drawback of such complex problems as encountered in tile and furniture manufacturing industries is that optimum solutions are rather difficult to obtain. Although exact algorithms can be applied for small problem instances, for common size and large instances, heuristic and metaheuristic approaches are needed to obtain good solutions in reasonable computational times. Yet, a wealth of such solution approaches may be developed with different degrees of ‘blindness’ to problem specific knowledge representing interesting trade-offs. This study aims to investigate such trade-offs by making use of GA approaches for a complex hybrid flexible flowshop problem. Different representation schemes with varying degrees of verboseness are employed and the effects on solution quality and computation times are explored. The results are compared to the ones obtained by several heuristics and by a mixed integer programming (MIP) model of the same problem on an extensive set of benchmark instances from Ruiz et al. (2008). In real production situations, a frequent goal is to finish a certain client order as early as possible. Our objective is therefore to minimise the maximum completion time, which is well-known in the literature as makespan. The rest of the paper is structured as follows: Section 2 contains a brief literature review on realistic scheduling problems and GA applications. We give a formalisation of the considered problem in Section 3. Different machine assignment rules are introduced in Section 4. The proposed methods are detailed in Section 5. Section 6 provides the computational and statistical evaluation of the results and of the comparison with other solution methods. Finally, conclusions are given in Section 7.
Genetic algorithms with different representation schemes
2
33
Literature review
2.1 GA applications in realistic scheduling GAs are popular tools used for solving a range of optimisation problems including realistic scheduling problems. Oduguwa et al. (2005) provide a survey on evolutionary computation applications to real world problems. The survey is on the applications of the core methodologies of evolutionary computation. The results show that the majority of papers reviewed employ standard GAs, rather than genetic programming, evolutionary programming and evolution strategies. More recently, Allahverdi et al. (2008) review the rapidly growing amount of literature on scheduling problems with set-up times or costs. They also point out that the most common technique is the GA approach. Gilkinson et al. (1995) present a GA application to solve the multi-objective real world scheduling problem of a company that produces laminated paper and foil products. The manufacturing system is composed of workcell groups. Jobs may skip some stages. For certain products, it is possible to process multiple jobs on a single machine. Lohl et al. (1998) present an application of a GA to a highly constrained real world scheduling problem in the polymer industry. The quality of the results and the numerical performance is discussed in comparison with a mathematical programming algorithm. An industrial application is given by Bertel and Billaut (2004) on a three-stage hybrid flowshop scheduling problem with recirculation. The problem is to perform jobs between a release date and a due date, in order to minimise the weighted number of tardy jobs. An integer linear programming formulation of the problem and a lower bound are proposed. A greedy algorithm and a GA are presented as approximate methods and evaluated on randomly generated instances, with similar properties to industrial ones. In another application, Tanev et al. (2004) hybridise priority/dispatching rules and GAs by incorporating several such rules in the chromosome representation of a GA designed to solve a multi-objective, real world, flexible job shop scheduling problem. Ruiz and Maroto (2006) propose the adaptation of a GA from an earlier study to a more realistic problem with sequence dependent set-up times, several production stages with unrelated parallel machines at each stage and machine eligibility. The proposed algorithm is benchmarked against several adaptations of other well-known metaheuristics. A statistical analysis shows that the proposed algorithm is between 53% and 135% more effective than the second best method, the GA by Reeves (1995).
2.2 Representation schemes for GA applications in scheduling The choice of a representation scheme is an important decision in the design of a GA which affects the size and shape of the search space and other design choices like the crossover and mutation operators. Eventually, it determines the performance of the algorithm. In fact, an inappropriate representation may lead to the failure of the algorithm itself. There are many representation schemes used in the GA approaches to scheduling problems. Simple permutations of tasks (jobs, operations) are the most common. Chromosomes representing priority values, execution times and machine assignments for tasks are also used. The design decisions become more important for applications where the problem involves precedence constraints. Usually, topological ordering of tasks is used in the chromosomes. Kwok and Ahmad (1997) schedule arbitrary parallel programmes onto
34
T. Urlings et al.
multiprocessors. The tasks are topologically ordered in the chromosome and they are assigned to the processors to minimise the overall execution time of the programme. Ramachandra and Elmaghraby (2006) try to minimise weighted completion time for a set of precedence-related jobs on two parallel identical machines. The chromosome representation is based on topological orderings of jobs and schedules are obtained by using the first available machine rule for machine assignments. Another compound type of representation scheme involves priority listings for tasks. Wang et al. (1997) use a chromosome of two parts in their application to the matching and scheduling of interdependent subtasks of an application task in a heterogeneous computing environment. The matching string represents the subtask-to-machine assignments and the scheduling string gives the execution ordering of the subtasks assigned to the same machine. Ghedjati (1999) also uses priority information in the chromosome structure, this time, in a two-dimensional representation scheme. She addresses job shop scheduling problems with unrelated parallel machines and precedence constraints between the operations of the jobs. A chromosome consists of two parts. The first part contains indices of priority rules for operation assignment, the second part indices corresponding to one of the seven machine assignment rules. Cavory et al. (2004) consider the cyclic job shop scheduling problem with linear precedence constraints. The chromosome representation of the GA contains a preference list for each machine, corresponding to a priority order for the processing of the tasks on the associate machine. Representation schemes other than task orderings and priority listings are also used, although not as often. Nossal (1998), for example, presents a GA for multiprocessor scheduling of dependent, periodic tasks. The scheduling problem is encoded by deriving execution intervals for the tasks, which determine the temporal boundaries for the execution points in time. The GA selects the actual start time for each task from within the corresponding interval. The scheduler builds and then assesses the associated schedule with regard to the fulfilment of the deadlines of the tasks and the intertask relations. In this paper, different representation schemes of varying degrees of directness are employed in GAs to address the complex HFFL problem defined in the following section.
3
Problem description
In Section 1, we have given an application of the problem that we address in this paper. In this section, we will give a more formal definition of this problem.
3.1 Formal problem definition The HFFL problem can be described as follows: given is a set of jobs N = {1,… , n} to be processed on a production line, consisting of a set of stages M = {1,… , m} . Each stage i, i ∈ M contains a set of unrelated parallel machines M i = {1,… , mi } . The flexibility of the problem implicates that jobs might skip stages. Each job j, j ∈ N visits a subset of stages Fj ⊆ M ( Fj ≠ ∅ ) . The processing time for job j on machine l at
stage i is denoted pilj . These times depend on the job and the machine, as machines are
35
Genetic algorithms with different representation schemes
unrelated and are zero for all the machines at stages that the job does not visit
(i.e., p
ilj
= 0, ∀l ∈ M i
∧ ∀i ∉ F ) . j
For this HFFL, we consider the following additional characteristics: •
Eij ⊆ M i is the set of eligible machines for job j in stage i. This means that not all machines at a given stage might process job j . Consider for example a stage with a small and a large machine. Small products can be processed on either of the two machines, whereas large products can only be processed on the large one. Note that pilj = 0 if l ∉ Eij . Also, Eij ≠ ∅ if i ∈ Fj .
•
rmil expresses the release date for machine l in stage i. No operation can be started at machine l before rmil . This allows us to model machines that have not finished previous work yet.
•
Pj ⊂ {N \ j } gives the set of predecessors of job j . Job j cannot start until all jobs
in Pj have finished. This is the case if auxiliary products are needed to start the processing of a final product. •
lagilj models the time lag for job j between stage i and the next stage to be visited, when job j is processed on machine l at stage i. A job in reality often consists of a large quantity of products with the same specifications. If so, the first products can in many cases be processed at the next stage before finishing the whole job. In other cases, the start at a next stage might be delayed because of products that have to dry or cool down. Negative time lags model the former cases, whereas positive time lags model the latter ones. In case of negative time lags, lagilj is never greater than pilj , nor than any of the processing times in the next visited stage.
•
Siljk denotes the set-up time between the processing of job j and job k on machine l inside stage i. We treat sequence dependent set-up times, as the set-up time when changing from job A to B might be different from the time when changing from B to A. These set-up times are assumed separable from the processing time.
•
Ailjk is a binary parameter that indicates whether the corresponding set-up is anticipatory (1) or not (0). Most machine set-ups can be performed before the product enters the stage, but in some cases (when it is necessary to attach the product to the machine, for example), set-up has to be postponed until the product arrives at the machine.
This exact set of constraints is also treated in Ruiz et al. (2008), where the importance of each single one for the hardness of the problem is investigated. If we denote by Cij as the completion time of job j at stage i and LS j = max i , the last i∈Fj
stage visited by job j, we can define the makespan as C max = max C LS j , j . Using the three j ∈N
field notation by Vignier et al. (1999), we can denote this HFFL problem as:
36
T. Urlings et al.
(
)
m ⎛ i ( )⎞ HFFLm , ⎜ RM ( ) ⎟ i =1 ⎠ ⎝
M j , rm , prec , Sijk , lag
C max
The first field, before the bars, describes the way the machines are ordered. There are m stages in series and at each stage i , a number of unrelated parallel machines ( RM ) is available. The second field, between the bars, shows the restrictions of the problem. Machine eligibility ( M j ) , machine release dates (rm ) , precedence constraints ( prec ) ,
(Sijk )
sequence dependent set-up times
and time lags (lag ) are considered in the
problem. The third field, after the bars, indicates the objective; makespan in this case. Although the number of feasible solutions is reduced by machine eligibility, stage skipping and precedence constraints, many special cases of this problem have been proven to be NP-Hard. Lee and Vairaktarakis (1994) showed NP-Hardness of hybrid flow shop problems in general. That precedence relationships do not simplify the problem which can be concluded from Ullman (1975), who proved that the two parallel machine problem with precedence constraints is already NP-Hard.
3.2 Example problem In the following, we give an example problem for a better understanding of all the restrictions. This instance consists of five jobs, three stages and five machines. Job 2 skips the first stage, both job 3 and job 5 skip the last stage and job 4 skips the second stage. In Table 1, the machines that can process each of the jobs are given. Job 5 is a predecessor of job 2 and job 4 is a predecessor of job 3. The machine release dates are respectively 1, 11, 3, 8 and 16 for machines 1 to 5. Tables 2 to 4 give the processing times, time lags and set-up times. Figure 1
Example of a feasible schedule for the HFFL problem studied in this paper (see online version for colours) rm
Setup
il
1
Stage 1
Machine 1
5
Job 1
7
Job 2
Job 3
12 14 16
1
22 23
4
27
21
29 31
34
3
Machine 2 Stage 2
Job 5
5
3 11
Job 4
3
5
15
29 31
1
Machine 3 8
14 15
17
4
Stage 3
34
5
11
Machine 4
38
2
24
1 16
35
39
2
Machine 5 5
10
15
20
25
30
35
Time
37
Genetic algorithms with different representation schemes
In Figure 1, one possible solution for the considered instance is shown. This solution with makespan 39 is actually within the set of optimal solutions. Note the jobs skipping stages, the precedence relationships (arrows upwards), the time lags (arrows downwards), and the anticipatory and non-anticipatory set-ups (both in black). Table 1
Eligibility of machines by the jobs ( Eij ) (example problem) 1
2
3
1
{1}
{2, 3}
{4}
2
-
{2}
{4, 5}
3
{1}
{2, 3}
-
4
{1}
-
{4, 5}
5
{1}
{2, 3}
-
i j
Table 2
Processing times ( pilj ) (example problem)
i
1
2
3
l
1
2
3
4
5
4
8
10
7
-
2
-
4
-
2
4
3
6
8
5
-
-
4
5
-
-
3
4
5
4
5
3
-
-
j 1
Table 3
Time lags (lagilj ) (example problem)
i
1
2
l
1
2
3
j 1
0
8
2
2
-
–3
-
3
–1
-
-
4
–1
-
-
5
2
-
-
38 Table 4
T. Urlings et al. Set-up times and if these are anticipatory or not (Siljk and Ailjk ) (example problem)
i
1
l
1
k
1
2
3
4
5
1
-
-
6(0)
2(1)
4(0)
2
-
-
-
-
-
3
4(0)
-
-
-
1(0)
4
8(1)
-
2(0)
-
9(0)
5
4(1)
-
7(1)
5(1)
-
i
2
l
2
k
1
2
3
4
5
1
-
3(0)
5(1)
-
3(0)
2
1(1)
-
5(0)
-
7(1)
3
4(1)
2(1)
-
-
3(1)
4
-
-
-
-
-
5
7(0)
5(1)
5(1)
-
-
j
j
i l
3
k
1
2
3
4
5
-
-
5(0)
-
2(0)
j 1 2
-
-
-
-
-
3
4(0)
-
-
-
6(1)
4
-
-
-
-
-
5
2(1)
-
4(0)
-
-
39
Genetic algorithms with different representation schemes Table 4
Set-up times and if these are anticipatory or not (Siljk and Ailjk ) (example problem) (continued)
i
3
l
4
k
1
2
3
4
5
1
-
2(0)
-
3(1)
-
2
3(0)
-
-
1(1)
-
j
3
-
-
-
-
-
4
1(1)
6(1)
-
-
-
5
-
-
-
-
-
2
3
4
5
i l
5
k
1
j 1
-
-
-
-
-
2
-
-
2(1)
-
-
3
-
-
-
-
-
4
-
4(0)
-
-
-
5
-
-
-
-
-
4
Machine assignment rules
As has been introduced in Section 2.2, there are many possible solution presentations for the HFFL problem. Representations as simple as job permutations are possible, as well as more complex structures, such as a list of jobs to be processed for each machine. The search space when using a permutation representation is of size n!, if we ignore the existence of infeasible solutions due to precedence constraints for the moment. When using a list of jobs for each machine, the search space is much larger, as the job order can differ from one stage to the other. Besides, jobs have to be assigned to an eligible machine at each visited stage. Therefore, we implemented some existing and some new machine assignment rules, to be used in permutation representations. Given a certain job permutation, we iteratively take the first unscheduled job and assign it in each stage that is visited by the job, to the machine that is indicated by the machine assignment rule. When all jobs are assigned to machines at all visited stages, a complete schedule is obtained.
40
T. Urlings et al.
Initially, nine machine assignment rules were implemented. A range of tests for the machine assignment rules shows that earliest completion time (ECT), earliest preparation next stage (EPNS), earliest completion next stage (ECNS) and next job same machine (NJSM) yield better results on average than the other remaining rules, e.g., first available machine and earliest starting time. Therefore, only these four rules are used in the algorithms and described in this section. To describe the machine assignment rules, some additional notation needs to be defined. The machine assigned to job j at stage i is denoted by Tij or by l for short. The previous job that was processed at machine l is denoted by k (l ). Let stage i – 1 be the last stage visited by job j before stage i , stage i + 1 be the next stage to be visited and stages FS j and LS j be the first and last stages job j visits, respectively. Let furthermore Ai ,l ,k (l ), j = Si ,l ,k (l ), j = 0
for i ∉ Fj
or i ∈ Fj ,
but 1∉ Eij
and
Ai ,l ,k (l ), j = Si ,l ,k (l ), j = C i ,k (l ) = 0 when no preceding job k (l ) exists. Completion times for
job j at all visited stages can now be calculated with the following expressions: ⎧ ⎫ C FS j , j = max ⎨rmFS j ,l ; maxC LS p , p ; C FS j ,k (l ) + AFS j ,l ,k (l ), j ⋅ SFS j ,l ,k (l ), j ⎬ ∈ p P j ⎩ ⎭
( ) = max {rm ; C ( ) + A + (1 − A ( ) ) ⋅ S ( )
+ 1 − AFS j ,l ,k (l ), j ⋅ SFS j ,l ,k (l ), j + pFS j ,l , j ,
C ij
il
i ,k l
i ,l ,k l , j
i ,l ,k (l ), j
i ,l ,k l , j
j ∈N
⋅ Si ,l ,k (l ), j ; C i −1, j + lagi −1,Ti −1,j , j
+ pilj ,
(1)
}
j ∈ N , i > FS j
(2)
The calculations should be made job-by-job to obtain the completion times of all tasks. For each job, the completion time for the first stage is calculated with equation (1), considering availability of the machine, completion times of the predecessors, set-ups and its own processing time. For the other stages, equation (2) is applied, considering availability of the machine, availability of the job (including lag), set-ups and its processing time. If job j is assigned to machine l inside stage i , the time at which machine l completes job j is denoted as Lilj . Following our notation, Lilj = C ij given Tij = l . Furthermore, we refer to the job visiting stage i after job j as job q and to an eligible machine at the next stage for job j as l ′ ∈ Ei +1, j . Suppose now that we are scheduling job j in stage i , i ∈ Fj . We have to consider all machines l ∈ Eij for assignment. Considering all previous notation, the proposed assignment rules are the following: 1
ECT: Takes the eligible machine capable of completing job j at the earliest possible time. Recall that processing times differ among machines. Job j is assigned to machine l such that min Lilj . In Algorithm 1, the pseudocode for this rule is given. l ∈Eij
For the sake of brevity, we omit the pseudocode for the other assignment rules.
41
Genetic algorithms with different representation schemes Algorithm 1 ECT machine assignment rule
2
EPNS: The machine able to prepare the job at the earliest time for the next stage to be visited is chosen. Therefore, time lags between the current and the next stage are taken into account by assigning job j to machine l with min {Lilj + lagilj } . This l ∈Eij
rule uses more information about the continuation of the job than the previous rule, without directly focusing on the machines in the next stage. If i = LS j , this rule reduces to ECT. 3
ECNS: The availability of machines in the next stage to be visited and the corresponding processing times are considered as well. Note that we are assigning only to stage i. Then, machine l with
min
l ∈Eij ,l ′∈Ei +1, j
{L
i +1,l ′, j
}
Tij = l is assigned to
job j . The rule reduces to ECT if no single minimum is found or if i = LS j . 4
NJSM: The assumption is made that job q is assigned to the same machine as job j . Assigned machine Tij is chosen such that job q is finished earliest. So, machine l is chosen by optimising min Lilj + Siljq + pilq . Note that only job j is assigned. The l ∈Eij
rule is especially useful if set-ups are relatively large, as the foregoing rules do not take the set-up between job j and job q into account. This reduces to ECT if job j is the last at this stage. Especially for the first three assignment rules, the growing amount of information used represents a trade-off between the probability of obtaining good schedules on one hand and valuable computation time on the other hand. The last rule is designed for alternative assignments, concentrating on drawbacks of the earlier rules.
42
5
T. Urlings et al.
Genetic algorithms
We have implemented five GAs with different solution encodings, representing a trade-off: a representation that is too verbose results in an inefficient algorithm due to the large search space, while a representation that is too compact might exclude important solutions in the search process. To initialise the population, a number of individuals equal to the (fixed) population size has to be generated. An adaptation of the heuristic by Nawaz et al. (1983) (NEH) is implemented. The NEH heuristic is developed for the permutation flowshop problem, but when using a machine assignment rule, the adaptation for the HFFL problem is straightforward. For each of the four machine assignment rules, one individual is generated with this NEH adaptation. Of the remaining individuals that have to be generated, 25% are initialised by taking one of the existing NEH solutions and applying some random mutations. The rest of the individuals are random job permutations that are forced to respect the precedence constraints. After the generation of those random job permutations, one of the four machine assignment rule is assigned to each individual, to complete the population initialisation. The makespan of individual x , C max ( x ) determines the solution value of x . Three different selection types are implemented for the GAs. Random selection is straightforward. Tournament selection directly uses the makespan value. Five individuals are randomly selected for a tournament. The individual with the lowest makespan is subjected to crossover with another individual selected similarly. Roulette wheel selection assigns to each individual a fitness value Fx = max C max (y ) − C max (x ) + 1. An y∈Pop
individual x is chosen with probability Fx
∑ F . Pop is the population of solutions in y y
the GA. The implemented crossover operators are one-point order crossover (OP), two-point order crossover (TP) and uniform order crossover (UOX). The latter is a one-dimensional version of the multicomponent UOX by Sivrikaya Şerifoğlu (1997). These three operators maintain feasibility with respect to the precedence constraints. Position mutation (PM) interchanges the job with another randomly selected job and shift mutation (SM) places the job into another randomly selected position. PM and SM are adapted for precedence constraints, i.e., we use precedence-safe PM and SM operators: within both mutations, the minimum and maximum allowed position in the current sequence are determined for the associated job. The new position is randomly chosen within this range.
5.1 Basic genetic algorithm The solution representation of the basic genetic algorithm (BGA) is the most compact, consisting of a job sequence and the machine assignment rule used for all jobs. The chromosome size is n + 1, as stressed in Figure 2(a). Note that not all possible solutions are reachable with this representation. For example, the solution given in Figure 1 is not reachable since the jobs do not visit the machines in the same order (non-permutation solutions).
Genetic algorithms with different representation schemes Figure 2
43
An example of the different encodings used in the proposed GAs, (a) the representation scheme for BGA and SGA (b) the solution representation for SGAR (c) the representation of solutions in SGAM (d) the representation scheme for EGA
Assignment rule
8
Job permutation
1 4 3 5 2 (a)
Job permutation
1 4 3 5 2
Assignment rules
6 1 3 2 4 (b)
Job permutation Machine assignments
1 4 3 5 2 Stage 1 1 1 1 1 3 2 3 2 Stage 2 4 4 5 Stage 3 (c)
Stage Machine
Jobs
1
1
1 4 3 5
2
2 3
3 2 1 5
3
4 5
4 1 2 (d)
The basic functioning of the algorithm can be deducted from Algorithm 2. Note that an elitism approach, copying the two best solutions to the new population, is needed to assure maintaining the best solution generation after generation.
44
T. Urlings et al.
Algorithm 2 Basic genetic algorithm
5.2 Steady-state genetic algorithm The second proposed algorithm steady-state genetic algorithm (SGA) has the same representation scheme as in BGA, but a steady-state population management structure: new individuals substitute the worst individuals of the current population as they are generated, but only if their solution values are better than the worst values of the population and if the solution did not yet exist in the population. As the best individuals of a population are never replaced, no elitism is needed to maintain the best solutions. This approach has been applied with success in Ruiz and Maroto (2006) and Ruiz et al. (2006). Note that comparing the job sequence alone is not enough to check uniqueness because of the different machine assignment rules. We, therefore, compare both the job sequence and the makespan value. The solution representation and the operators remain the same as in BGA.
5.3 Steady-state genetic algorithm with changing assignment rule Allowing independent machine assignment rules for every job in the sequence yields our next algorithm, steady-state genetic algorithm with changing assignment rule (SGAR). This changes the solution representation as shown in Figure 2(b). Apart from the job sequence, an assignment rule for each job is stored in a second array of size n , which
Genetic algorithms with different representation schemes
45
increases the chromosome size to 2n . This algorithm uses the steady-state structure and all operators defined before in the BGA algorithm. In the crossover, the assignment rule of each job is copied along with the jobs from the parents. When mutation is applied, rules stick with the associated jobs. The assignment rule of each job is subjected to mutation in the assignment rule mutation phase, so that a different rule is assigned to the corresponding job.
5.4 Steady-state genetic algorithm with machine assignments A more verbose solution representation contains, for each job and each stage the job visits, the machine that the job is assigned to. This means that there is, apart from the job sequence, an m × n matrix with the machine assignments for each job and stage. These exact machine assignments replace the machine assignment rules in the chromosome. The chromosome of size (1 + m ) n for this algorithm is demonstrated in Figure 2(c). The proposed algorithm, steady-state genetic algorithm with machine assignments (SGAM), also uses the steady-state structure and all previously explained operators. The NEH solutions are generated equally as for the previous algorithms. Once those four schedules are obtained, they are represented as in Figure 2(c). The randomly initialised individuals are generated with random machine assignments, instead of assignments indicated by a rule. Obviously, only eligible machines are considered, in order to maintain feasibility. During crossover, assignments for a given job are taken over from the parent that passes the job, as in SGAR. Machine assignment mutation changes a single random machine assignment for each job.
5.5 Steady-state genetic algorithm with exact representation: EGA With the exact representation, used in algorithm EGA, also non-permutation solutions are reachable. For the makespan objective, one can represent any feasible solution, given the tasks processed at each machine in the order the machine will process them [see Figure 2(d)]. There is no reason to delay any tasks, so all tasks are started at the earliest possible moment, given by equations (1) and (2) in Section 4. The size of this Fj . representation is equal to the number of tasks, which is
∑
j ∈N
Most operators defined for the other representations cannot be used with this representation. Population initialisation is done in a similar way as for the other algorithms. The NEH solutions are generated with machine assignment rules and then converted to the representation used by the EGA algorithm. The randomly initialised individuals are generated in the following way: a list of the available tasks is maintained at each moment. A random task is taken from the list and scheduled, after which the list is updated and a new task is picked. When the list is empty, a complete schedule has been obtained. For crossover, two operators are proposed. Guaranteed feasibility crossover (GFX) maintains three lists: one list of all available tasks (tasks ready for scheduling) and, for each parent, a list of the first unscheduled task in each machine. The pseudocode for this crossover operator is given in Algorithm 3. Fast crossover (FX) is similar to GFX, but no list of available tasks is maintained. For both parents, a list is maintained only with the first unscheduled task in each machine. One of these tasks is scheduled at the same machine for the child. FX crossover is
46
T. Urlings et al.
much faster than GFX; however, feasibility of the offspring is not guaranteed. If a non-feasible solution is obtained, crossover is undone and the parents are copied directly to the offspring. Algorithm 3 Guaranteed feasibility crossover
Similarly, two mutations can be applied to the machine assignment arrays in the chromosomes. Both place a task at a new position in any of the eligible machines in the same stage. Fast mutation (FM) checks the precedence relationships within the new machine. The new position is chosen randomly between the minimum and maximum position, according to the direct precedence relations. This, however, does not guarantee global feasibility. We use Figure 1 as an example. If we apply mutation on job 2 in stage 3, direct precedence constraints do not impose any position in machine 4 or 5. The only predecessor is job 5, which does not visit stage 3. However, placing this task before job 4 in machine 4 leads to an infeasible solution. Guaranteed feasibility mutation (GFM) assures that the new schedule is feasible. In case of precedence constraints, this implies not only direct predecessors and successors, but also needs a recursive search for their anterior and posterior jobs in other stages respectively. Obviously, this implies a larger cost in running time, but no solutions have to be discarded.
47
Genetic algorithms with different representation schemes
6
Experimental evaluation
To test, compare and analyse the algorithms we use, a subset of the benchmark proposed by Ruiz et al. (2008). The benchmark contains two datasets for the problem; a set of small and a set of large instances. The sets are based on ten factors with a large number of levels. Ruiz et al. (2008) show that various levels for the controlled factors do not have a significant influence on the hardness of the instances. Therefore, we eliminate those levels from the experiments. The levels we use for the two datasets are given in Table 5. For each level, there are three instances, resulting in a total of 768 instances. For instances with only one machine per stage, the machine assignments are trivial. We, therefore, separate the small instances with mi = 1 from the small instances with mi = 3. Table 5
Factors and levels used in the benchmark
Factor
Symbol
Small instances
Large instances
Number of jobs
n
5, 7, 9, 11, 13, 15
50, 100
Number of stages
m
2, 3
4, 8
Number of unrelated parallel machines per usage
mi
1, 3
2, 4
Distribution of the release dates for the machines
rmil
U [1, 200]
U [1, 200]
Probability for a job to skip a stage
PFj
0%, 50%
0%, 50%
Probability for a machine to be eligible
PEij
50%, 100%
50%, 100%
Distribution of the set-up times as a percentage of the processing times
DSiljk
U [ 75, 125]
U [ 75, 125]
Probability for the set-up time to be anticipatory
PAiljk
U [50, 100] %
U [50, 100] %
Distribution of the lag times
Dlagilj
U [ −99, 99]
U [ −99, 99]
NPj
0,U [1, 3]
0,U [1, 5]
Number of preceding jobs
The stopping criterion for the GA runs is given by a time limit depending on the size of the instance, which is also used by Armentano and Ronconi (1999), for example. The algorithms are stopped after a CPU running time of n mi ⋅ t milliseconds, where t is
∑
i
an input parameter.
6.1 Calibration of the parameters of proposed GAs Before calibration, the algorithms are subjected to some preliminary tests to reduce the number of levels of the parameters to be tested in the fine-tuning process. SM performed clearly better than PM in preliminary experiments. As TP is in some cases better and in none of the cases worse than OP and UOX, we fix the TP as crossover operator for all algorithms. The FX operator for EGA yields worse results than GFX. This fixes the mutation and crossover operators for the GAs. The probability of the mutation changing the machine assignment rule is fixed at 5% per individual for BGA and SGA and at 1% for SGAM; 1% per job for SGAR.
48
T. Urlings et al.
Table 6 Algorithm
BGA
Final values for the algorithm parameters after calibration mi = 1
mi = 3
Large
Roulette selection
Random selection
Tournament selection
Pop. size = 200
Pop. size = 2001
Pop. size = 200
Pc = 60%1
Pc = 60%1
Pc = 60%
Pmut = 2%
Pmut = 2%
Pmut = 2%
1
SGA
4 rules
4 rules1
Random selection
Random selection
Random selection
Pop. size = 200
Pop. size = 200
Pop. size = 200
1
Pc = 60%
Pc = 60%
Pc = 60%
Pmut = 2%
Pmut = 2%1
Pmut = 2% 2
4 rules1
4 rules1
1
1
Random selection
SGAR
1
Pop. size = 200
Pc = 60%
Pmut = 2%1
Pmut = 2%
4 rules
4 rules1
Random selection
Roulette selection
Pop. size = 200
Pop. size = 80
1
EGA
Pop. size = 200
Pc = 60%
1
SGAM
Random selection
Pc = 60%
Pc = 60%1
Pmut = 2%1
Pmut = 2%
4 rules
4 rules
Random selection
Random selection
Roulette selection
Pop. size = 200
Pop. size = 200
Pop. size = 80
Pc = 40%
Pc = 40%
Pc = 40%
Pmut = 5%
Pmut = 5%
GF mutation
GF mutation2
Pmut = 5% 1
GF mutation
Notes: 1not significant in ANOVA and 2strong interaction with t
For all GAs, crossover probabilities ( Pc ) of 40% and 60% are tested. Job mutation probabilities ( Pmut ) are either 1% or 2% per job for BGA, SGA, SGAR and SGAM, and either 1% or 5% per machine for EGA. To test the necessity of various machine assignment rules, a level is added into the calibration process where only EPNS is applied, which implies that the assignment rule mutation probability is zero. For all algorithms, population sizes of 50, 80 and 200 are compared as are all three selection methods.
49
Genetic algorithms with different representation schemes
The aforementioned setting results in a total number of parameter combinations of 72. Each algorithm is tested five independent times on each given parameter setting and instance. As for t in the stopping time formula, we test t = 5 and t = 25 milliseconds. As a measure for the results, we calculate the relative deviation from the best-known solution value in percent and take the average over the considered set of instances. By means of a multifactor ANOVA, we compare the various levels of the parameters. Because of the high quantity of results, the three ANOVA hypotheses of normality, homoscedasticity and independence of residuals are easily fulfilled. In all comparisons, we use Tukey confidence intervals of 99.9%. The final parameters for all GAs for all instance sets are listed in Table 6. Note that SGAR and SGAM are not calibrated for instances with a single machine per stage, as the algorithms only differ from SGA in machine assignment decisions. Machine assignments are trivial for these instances. Considering the algorithm parameters, the instance characteristics and the time limit, the algorithm parameters appear least important. This indicates that the algorithms are robust as regards instance characteristics and CPU time.
6.2 Comparison between GAs For the final results, we run the calibrated algorithms five independent times for t equal to 5, 25 and 125 milliseconds on the problem set. We used a Pentium IV computer with 3.0 GHz processor and 1 GB of RAM memory for all tests. As the performance measure, we compute the average percent deviations from optimum solutions for those small instances, for which optimum solutions are reported in Ruiz et al. (2008). For larger instances, average percent deviations from best-known solution values are computed. Table 7
Results for GAs
t Algorithm
BGA
SGA
SGAR SGAM EGA
Set
5
25
125
Average
mi = 1
0.255
0.234
0.231
0.255
mi = 3
2.222
2.119
2.187
2.222
Large
10.683
8.386
7.348
8.806
mi = 1
0.236
0.229
0.234
0.236
mi = 3
2.106
2.092
2.085
2.106
Large
9.030
5.915
5.019
6.655
mi = 3
2.533
2.615
2.830
2.533
Large
9.448
6.310
5.232
6.996
mi = 3
3.799
1.794
1.254
3.799
Large
17.445
12.564
11.000
13.670
mi = 1
0.643
0.481
0.441
0.643
mi = 3
1.435
1.226
1.109
1.435
Large
22.709
18.361
14.931
18.667
Note: Average percentage deviation over optimum for small instances; over best-known solution for large instances.
50
T. Urlings et al.
An ANOVA for the smallest instances (mi = 1) shows that stage skipping PFj is the most important factor among all the instance properties, the algorithms and running time. Stage skipping makes the problem easier, as less tasks are involved. The second most important factor is the algorithms and there is no interaction between these two factors. Although the exact solution used in EGA is complete (i.e., the optimum solution is reachable), this algorithm is on average worse than BGA and SGA , which in turn do not differ significantly for a confidence interval of 99.9%. The results are given in Table 7, together with the results for the other sets of instances. For mi = 3, the percentage of eligible machines PEij is the most important factor. The percentage of eligible machines logically influences the importance of machine assignments. If only half of the machines are eligible, the performance differences are small, but if all machines can process all jobs, the machine assignment rules used in BGA, SGA and SGAR are proven to be more efficient than incorporating the assignments in the representation, as done in SGAM and EGA. For the large instances, the most important factor is NPj , i.e., the number of predecessors. These constraints make the problem harder to solve for the GAs. Again, we find here another counter-intuitive result. Presumably, with precedence constraints, less job permutations are feasible and therefore the search space becomes smaller. However, when precedence relations are present, the operators of the GAs are much more time consuming because feasibility checks must be done. Since the algorithms are stopped after a certain amount of CPU time, slow operators lead to worse results. The influence of this precedence constraints factor is especially large for EGA and SGAM (see Figure 3). The complicated EGA operators are especially slow under precedence constraints and SGAM spends more running time on machine assignments and has therefore less time to concentrate on the job sequence, which is more important in the case of precedence constraints.
Average Percentage Deviation
Figure 3
Interactions and Tukey 99.9% confidence intervals for the precedence constraints and the GA (large instances) (see online version for colours)
30
NPj 0 U[1,5]
25 20 15 10 5 0 BGA
EGA
SGA
SGAR SGAM
51
Genetic algorithms with different representation schemes
Also interesting is the performance of each algorithm for the different allowed running times. For EGA, we see the behaviour one would expect; increasing the allowed running time leads to significantly better results. The same holds, in a weaker sense, for SGAM. There is a clear improvement when increasing t from 5 to 25 milliseconds, but increasing further does not pay-off. BGA, SGA and SGAR do obtain better solutions with longer running times, but the difference is quite small. This proves that the algorithms with less direct solution representations and therefore smaller search spaces need less time to explore a large part of the solution space than algorithms based on more verbose representations.
6.3 Comparison with other methods To test the quality of the proposed GAs, we compare them with several other methods. For small instances, the MIP results in Ruiz et al. (2008) are used. In Ruiz et al. (2008), several dispatching rules and an adaptation of the heuristic by Nawaz et al. (1983) (NEH) are proposed for this HFFL. The implemented dispatching rules are shortest processing time (SPT), longest processing time (LPT), least work remaining (LWR), most work remaining (MWR) and most work remaining with average set-up times (MWR-AST). We apply each heuristic four times, once for each machine assignment rule. As a result, we pick for each heuristic the best solution out of the four we obtained. Despite the repeated execution, all these methods require very small CPU times. For more details about the heuristics, the reader is referred to Ruiz et al. (2008). Boyer and Hura (2005) implemented a random scheduling (RS) algorithm for sequencing all tasks in a distributed heterogeneous computing environment. They show that their algorithm is less complex than evolutionary algorithms, computes schedules in less time and requires less memory and less parameter fine-tuning. We, therefore, implement an RS algorithm, which simply produces random solutions until a given termination criterion is met. The solutions are represented by a random feasible job sequence and a machine assignment rule. We allow the same time for RS as for the GAs. For both small and larger instances, we compare the GAs with the results of the constructive heuristics and RS. All results are given in Table 8. Table 8
Results for other methods (SGA for comparison) Set
Algorithm
mi = 1
mi = 3
Large
SPT
26.475
19.030
227.034
LPT
24.322
17.607
225.050
LWR
28.438
19.102
138.152
MWR
15.660
14.024
95.777
MWR-AST
14.911
13.884
92.720
NEH
2.669
4.961
25.733
RS
0.288
3.152
35.696
SGA
0.236
2.106
6.655
Note: Average percentage deviation over optimum for small instances; over best-known solution for large instances.
52
T. Urlings et al.
It is clear that the dispatching rules, although improved with the variety of machine assignment rules, do not even approach the performance of any other method. However, one has to take into account that the computation time for the dispatching rules is extremely short (for these instances, less than a millisecond on average). It is trivial that NEH has a lower solution quality than the GAs, since GAs start with an initial population seeded with NEH solutions and the best solution stays the same or is improved over generations. Taking into account that NEH is a fast heuristic, compared to algorithms with longer running times, its performance is still good. Surprisingly, the performance of RS is fairly good for the small instances. The simplicity and speed of RS seems to be an advantage for solving a complex problem like the one addressed in this article. The lack of structure in the solution search of RS starts to play a role when the instances are larger. It is then even outperformed by NEH, which only needs about a second for these instances.
7
Conclusions and future work
In this paper, we have introduced GA approaches with various solution representations for a complex HFFL problem. The addressed problem is more complex than the problems usually studied in the literature and allows for direct implementation in real world situations. The algorithms with more compact, indirect solution representations (BGA, SGA, SGAR) already show good results for small allowed running time. Additional running time causes an insignificantly small improvement in the solution value. The algorithms with a more verbose solution representation (SGAM and especially EGA) profit more from the extra time, but still do not reach the solution quality of the earlier mentioned algorithms. The GAs are compared to some other existing methods. The solution quality obtained by the GAs is better than that of all constructive heuristics. A random solution generator (RS) with the same time limit as for the GAs is used for comparison. For small instances, RS is comparable to EGA and better than SGAM; for large instances, all GAs show a better performance. The presented SGA and the NEH adaptation are implemented in SeKuen (http://www.sekuen.com), a finite capacity production scheduling software, that is currently being deployed at three important ceramic tile manufacturing companies in Spain: Halcón Cerámicas S.A., ColorKer Cerámicas S.A. and TAULELL S.A. Other industrial companies like Frost-Trol S.A. and Galol S.A. are also in the process of collecting the necessary data and will soon start using the software. We are currently working on local search methods for this problem. Initial results show that performance can be improved with the help of an efficient local search implementation. Other complications found in real life problems, such as finite capacity buffers in Fahmy et al. (2008), can be included as well, such that an even broader range of problems is covered. Another valuable addition would be to consider two objectives, as in Hendizadeh et al. (2007). We hope that this paper serves as a motivation for more research on highly constrained scheduling problems.
Genetic algorithms with different representation schemes
53
Acknowledgements Thijs Urlings and Rubén Ruiz are partially funded by the Spanish Ministry of Science and Innovation, under the projects ‘SMPA – advanced parallel multiobjective sequencing: practical and theorerical advances’ with reference DPI2008-03511/DPI and ‘OACS – advanced optimisation of the supply chain’ with reference IAP-0201002008-11.
References Allahverdi, A., Ng, C.T., Cheng, T.C.E. and Kovalyov, M.Y. (2008) ‘A survey of scheduling problems with setup times or costs’, European Journal of Operational Research, Vol. 187, No. 3, pp.985–1032. Allaoui, H. and Artiba, A. (2004) ‘Integrating simulation and optimization to schedule a hybrid flow shop with maintenance constraints’, Computers and Industrial Engineering, Vol. 47, No. 4, pp.431–450. Armentano, V.A. and Ronconi, D.P. (1999) ‘Tabu search for total tardiness minimization in flowshop scheduling problems’, Computers and Operations Research, Vol. 26, No. 3, pp.219–235. Bertel, S. and Billaut, J.C. (2004) ‘A genetic algorithm for an industrial multiprocessor flow shop scheduling problem with recirculation’, European Journal of Operational Research, Vol. 159, No. 3, pp.651–662. Boyer, W.F. and Hura, G.S. (2005) ‘Non-evolutionary algorithm for scheduling dependent tasks in distributed heterogeneous computing environments’, Journal of Parallel and Distributed Computing, Vol. 65, No. 9, pp.1035–1046. Cavory, G., Dupas, R. and Gonçalves, G. (2004) ‘A genetic approach to solving the problem of cyclic job shop scheduling with linear constraints’, European Journal of Operational Research, Vol. 161, No. 1, pp.73–85. Fahmy, S.A., ElMekkawy, T.Y. and Balakrishnan, S. (2008) ‘Deadlock-free scheduling of flexible job shops with limited capacity buffers’, European Journal of Industrial Engineering, Vol. 2, No. 3, pp.231–251. Ghedjati, F. (1999) ‘Genetic algorithms for the job-shop scheduling problem with unrelated parallel constraints: heuristic mixing method machines and precedence’, Computers and Industrial Engineering, Vol. 37, Nos. 1–2, pp.39–42. Gilkinson, J.C., Rabelo, L.C. and Bush, B.O. (1995) ‘A real-world scheduling problem using genetic algorithm’, Computers and Industrial Engineering, Vol. 29, Nos. 1–4, pp.177–181. Hendizadeh, S.H., ElMekkawy, T.Y. and Wang, G.G. (2007) ‘Bi-critera scheduling of a flowshop manufacturing cell with sequence dependent setup times’, European Journal of Industrial Engineering, Vol. 1, No. 4, pp.391–413. Johnson, S.M. (1954) ‘Optimal two- and three-stage production schedules with setup times included’, Naval Research Logistics Quarterly, Vol. 1, No. 1, pp.61–68. Kwok, Y.K. and Ahmad, I. (1997) ‘Efficient scheduling of arbitrary task graphs to multiprocessors using a parallel genetic algorithm’, Journal of Parallel and Distributed Computing, Vol. 47, No. 1, pp.58–77. Lee, C.Y. and Vairaktarakis, G.L. (1994) ‘Minimizing makespan in hybrid flowshops’, Operations Research Letters, Vol. 16, No. 3, pp.149–158. Lohl, T., Schulz, C. and Engell, S. (1998) ‘Sequencing of batch operations for a highly coupled production process: genetic algorithms versus mathematical programming’, Computers and Chemical Engineering, Vol. 22, pp.S579–S585.
54
T. Urlings et al.
Low, C. (2005) ‘Simulated annealing heuristic for flow shop scheduling problems with unrelated parallel machines’, Computers and Operations Research, Vol. 32, No. 8, pp.2013–2025. Nawaz, M., Enscore, E.E. and Ham, I. (1983) ‘A heuristic algorithm for the m-machine, n-job flowshop sequencing problem’, Omega – International Journal of Management Science, Vol. 11, No. 1, pp.91–95. Nossal, R. (1998) ‘An evolutionary approach to multiprocessor scheduling of dependent tasks’, Future Generation Computer Systems, Vol. 14, Nos. 5–6, pp.383–392. Oduguwa, V., Tiwari, A. and Roy, R. (2005) ‘Evolutionary computing in manufacturing industry: an overview of recent applications’, Applied Soft Computing, Vol. 5, No. 3, pp.281–299. Ramachandra, G. and Elmaghraby, S.E. (2006) ‘Sequencing precedence-related jobs on two machines to minimize the weighted completion time’, International Journal of Production Economics, Vol. 100, No. 1, pp.44–58. Reeves, C.R. (1995) ‘A genetic algorithm for flowshop sequencing’, Computers and Operations Research, Vol. 22, No. 1, pp.5–13. Reisman, A., Kumar, A. and Motwani, J. (1997) ‘Flowshop scheduling/sequencing research: a statistical review of the literature, 1952–1994’, IEEE Transactions on Engineering Management, Vol. 44, No. 3, pp.316–329. Ruiz, R. and Maroto, C. (2006) ‘A genetic algorithm for hybrid flowshops with sequence dependent setup times and machine eligibility’, European Journal of Operational Research, Vol. 169, No. 3, pp.781–800. Ruiz, R., Maroto, C. and Alcaraz, J. (2006) ‘Two new robust genetic algorithms for the flowshop scheduling problem’, Omega – The International Journal of Management Science, Vol. 34, No. 5, pp.461–476. Ruiz, R., Sivrikaya Şerifoğlu, F. and Urlings, T. (2008) ‘Modeling realistic hybrid flexible flowshop scheduling problems’, Computers and Operations Research, Vol. 35, No. 4, pp.1151–1175. Salveson, M.E. (1952) ‘On a quantitative method in production planning and scheduling’, Econometrica, Vol. 20, No. 4, pp.554–590. Schutten, J.M.J. (1998) ‘Practical job shop scheduling’, Annals of Operations Research, Vol. 83, No. 1, pp.161–177. Sivrikaya Şerifoğlu, F. (1997) A New Uniform Order-based Crossover Operator for Genetic Algorithm Applications to Multi-component Combinatorial Optimization Problems, Technical report, Bogaziçi Üniversitesi, Istanbul. Tanev, I.T., Uozumi, T. and Morotome, Y. (2004) ‘Hybrid evolutionary algorithm-based realworld flexible job shop scheduling problem: application service provider approach’, Applied Soft Computing, Vol. 5, No. 1, pp.87–100. Ullman, J.D. (1975) ‘NP-complete scheduling problems’, Journal of Computer and System Sciences, Vol. 10, No. 3, pp.384–393. Vignier, A., Billaut, J.C. and Proust, C. (1999) ‘Les problèmes d’ordonnancement de type flow-shop hybride: état de l’art’, RAIRO Recherche Opérationnelle, Vol. 33, No. 2, pp.117–183, in French. Wang, L., Siegel, H.J., Roychowdhury, V.P. and Maciejewski, A.A. (1997) ‘Task matching and scheduling in heterogeneous computing environments using a genetic-algorithm-based approach’, Journal of Parallel and Distributed Computing, Vol. 47, No. 1, pp.8–22.
