INTERNATIONAL TRANSACTIONS IN OPERATIONAL RESEARCH

Intl. Trans. in Op. Res. 00 (2015) 1-19 DOI: 10.1111/itor.12195

INTERNATIONAL TRANSACTIONS IN OPERATIONAL RESEARCH

Accelerated simulated annealing algorithm applied to the flexible job shop scheduling problem

Marco Antonio Cruz-Chaveza, Martin G. Martinez-Rangelb and Martin H. Cruz-Rosalesc

aCIICAP, Autonomous University of Morelos State, Cuernavaca, Morelos, Mexico bFCAeI, Autonomous University of Morelos State, Cuernavaca, Morelos, Mexico cFC, Autonomous University of Morelos State, Cuernavaca, Morelos, Mexico E-mail: mcruz@uaem.mx [Cruz-Chavez]; mmtzr@uaem.mx [Martinez-Rangel]; mcr@uaem.mx [Cruz-Rosales]

Received 27 November 2014; received in revised form 8 May 2015; accepted 12 June 2015

Abstract

This paper presents a simulated annealing algorithm accelerated by a partial scheduling mechanism and a cooling schedule mechanism that is a function of the standard deviation. This facilitates a rapid approach to good solutions in the flexible job shop scheduling problem (FJSSP). The results demonstrate that for benchmark instances of several sizes, simulated annealing that implements the proposed mechanism converges more quickly to good solutions than simulated annealing that does not implement the proposed mechanism.

Keywords: partial scheduling; controlled simulated annealing; standard deviation; complexity

1. Introduction

In everyday life, various problems frequently occur in the area of combinatorial optimization (Dash and Kajiji, 2014; Niroomand and Vizvar, 2015). The most prominent scheduling problems are considered NP-hard and complex, and require many computational resources (Alba et al., 2013). The flexible job shop scheduling problem (FJSSP) is one of the most well-known scheduling problems, and is also one of the most difficult NP-complete problems to solve (Kacem et al., 2002a). FJSSP can be grouped according to the characteristics of the problem. One group processes the problems with total flexibility, in which there is availability of all machines for each operation. One machine, from all machines involved in the process, is selected to perform each operation. Another group processes the problems with partial flexibility. In this group, not all machines are available for all operations. This latter type of problems is more difficult to handle in

The copyright line for this article was changed on August 12, 2015 after original online publication.

© 2015 The Authors.

International Transactions in Operational Research published by John Wiley & Sons Ltd on behalf of International Federation of Operational Research Societies

This is an open access article under the terms of the Creative Commons Attribution-NonCommercial-NoDerivs License, which permits use and distribution in any medium, provided the original work is properly cited, the use is non-commercial and no modifications or adaptations are made.

the FJSSP (Kacem et al., 2002a; Ho and Tay, 2004; Ida and Oka, 2011; Nouiri et al., 2013; Zhang and Manier, 2013; Bozejko et al., 2014). Problems in the partial flexibility group have application in the manufacturing industry. In addition, the literature shows that they can be successfully used for various scheduling problems (Shaw, 1988; Gu et al., 1997; Wang et al., 2003; Babayan and He, 2004). These problems serve as a reference for other problem resolution techniques in the field of resource assignment, for example, the vehicle routing problem and the resource assignment problem in classrooms (Liu et al., 2010; Wu et al., 2013; Rahimi et al., 2015; Zheng et al., 2015). Traditional approaches for resolution of the FJSSP are as varied as the different formulations of the problem. They include fast, simple heuristics, taboo search (Liouane et al., 2007), evolutionary approaches (Gu et al., 2006; Zhang et al., 2007; Ma et al., 2014a; Ma et al., 2014b; Yuan and Xu, 2015; Zheng et al., 2015), Monte-Carlo Tree Search (Wu et al., 2013), simulated annealing (SA) (Shivasankaran et al., 2014), and modern hybrid metaheuristics that consolidate the advantages of different approaches (Zhou et al., 2014). The FJSSP is an extension of classic JSSP, and incorporates all the difficulties and complexities of this problem (Mastrolilli and Gambardella, 2000; Kacem et al., 2002a, 2002b; Ho and Tay, 2004; Chen and Chen, 2008; Amiri et al., 2010; Mati et al., 2011; Knopp et al., 2014). The difference between these two problems is that JSSP limits the performance of each operation to a single machine, while FJSSP allows multiple machines to perform each operation (Mastrolilli and Gambardella, 2000; Ho and Tay, 2004).

According to the complexity theory (Papadimitriou and Steigliths, 1998), there are not exact methods that can solve an FJSSP in polynomial time. For this reason, metaheuristics are used, which are bound in polynomial time, to search for the global optimum. These metaheuristics usually give good solutions very close to the global optimum (Applegate and Cook, 1991). The FJSSP model is used in manufacturing environments that are related to control and/or production planning. If better solutions were found to this model, it would enable more efficient use of limited resources, such as manufacturing machinery, because more optimal scheduling ofresources would be possible.

Many of the metaheuristics used in FJSSP are characterized using an iterated local search, requiring the use of a neighborhood function. For this reason, the development of more efficient and effective mechanisms to accelerate iterated local search is important for improving the efficiency of these metaheuristics. Many metaheuristics that use iterated local search have been proposed to find good solutions to the FJSSP. A well-known example is the SA algorithm (Kirkpatrick et al., 1983; Cerney, 1985). In literature, various approaches that use heuristics with local search have been proposed, which enable FJSSP to find good solutions. In Mastrolilli and Gambardella (2000), some neighborhood functions that can generate very efficient solutions are proposed, which can be used by iterated local search algorithms. One of these approaches is presented in Hansmann and Hoeck (1997), in which the local search is based on the Laarhoven neighborhood (Van Laarhoven et al., 1992). It accepts only solutions below the lower bound in its local search in order to escape local optima, thereby increasing the probability of finding the global optimum. In Amiri et al. (2010), a variable neighborhood search is used to solve the FJSSP. Linear coding, known as sequenced task list, is used for representing the solutions in this search. To generate the solution space with this method, two neighborhood structures related to the sequencing problem and three neighborhood structures related to the assignment problem are used. The two sets of structures are combined (both for allocation and for sequencing) to select a solution candidate. In Mati et al. (2011), the resource assignment problem is presented as a complex dynamic programming problem. They consider some resources as flexible and take into account block restrictions for genetic algorithms.

All these approaches of iterated local search require the evaluation of the solution quality at every step of the heuristic algorithm. To achieve this, the most commonly used scheduling algorithm is the one presented in Zalzala and Fleming (1997), Kacem et al. (2002a), Liouane et al. (2007), Zhang et al. (2007), Gao et al. (2014). In this algorithm, scheduling is performed as a function of time for each of the operations involved in the process and part of the problem instance. This scheduling is carried out in order to obtain the end time for the last operation that runs in the system; this time is the makespan.

This paper presents an SA algorithm that applies partial scheduling to accelerate the neighborhood search in FJSSP. The partial scheduling algorithm reported good results for JSSP in Cruz-Chavez et al. (2007), with a 50% faster average to obtain the makespan evaluation as compared to the classical scheduling algorithm (Nakano and Yamada, 1991; Yamada and Nakano, 1992; Zalzala and Fleming, 1997; Kacem et al., 2002a; Liouane et al., 2007; Zhang et al., 2007). The partial scheduling proposal in this paper for FJSSP has two major variants to the proposal made in Cruz-Chavez et al. (2007). It has a selective mechanism for choosing a particular machine or a set of machines that can perform the same operation. It also has a control mechanism that allows for a balance of loads on the machines used during the process of assigning a sequence based on the machines. The proposed mechanism is applied to SA for FJSSP. A cooling sequence is also applied, which uses standard deviation to improve the algorithm convergence (Martinez-Rangel et al., 2007).

This work consists of the following sections. Section 1 is the introduction. Section 2 describes the FJSSP and the model that it represents. Section 3 describes the mechanism of partial scheduling in FJSSP. Section 4 describes the SA algorithm that is tuned using standard deviation. To evaluate solutions in the neighborhood search, the partial scheduling mechanism is applied to FJSSP. An analysis of the complexity of the SA algorithm for the FJSSP is included. Section 5 presents the computational results. Finally, Section 6 explains the conclusions.

2. The FJSSP

This paper addresses the partial FJSSP (Brandimarte, 1993; Mastrolilli and Gambardella, 2000; Kacem et al., 2002a, 2002b; Ho and Tay, 2004; Liouane et al., 2007), in which each machine can process only some of the operations involved in the process. These problems have a great similarity to the problems that arise in industry, due to the existence of multiple machines that may exist in a job shop, not all of which can process all the jobs. Table 1 presents a partial FJSSP; this figure shows that a machine can only run some operations of some jobs. For example, the set of operations that M2 can run is M2 = {O21, O12, O32, O13, O23, O33}. It is also important to note that the processing time for an operation may be different on each machine. For example, operation one of job two, O12, when run on the machine Mj, has a processing time of t(Ol 2, Mx) = 4. If the operation is executed on machine M2, then t(O12, M2) = 6 and if the operation is executed on machine M3, then t(Oh2, M3) = 5.

The FJSSP generally consists of a set of N jobs, a set of M machines, and a set O of operations, where each job consists of a subset of O in sequence. Each operation i that belongs to a job j has duration^ O, j). In a schedule of jobs, a start time for each operation st(Oi) is defined such that:

• A machine cannot process more than one operation at a time.

Table 1

Instance of Partial-FJSSP

M1 M2 M3

°1.1 6 5

O2,1 2 4

O3,1 6

J2 O1,2 4 6 5

O2,2 6 6

O3,2 5 3

O1,3 2 3

O2,3 4 2 6

O3,3 5 4

• There is an order of precedence in the operations of a job.

• An operation that has already started cannot be interrupted.

The time in which all operations are executed and completed in FJSSP is known as makespan. In this work, the objective for the FJSSP is to find a schedule that minimizes the makespan.

2.1. The disjunctive graph model

The model presented below of FJSSP is an extension of the JSSP model presented in Roy and Sussman (1964). The general problem FJSSP is defined by the graph G = (V, A, E, FL, P, O, /), where

V = O U{I, F}

A = {{{^ °1,j}. Oj, O+u}. {Omj, F}} I VU j : Oij e O A Oij < O+lJ)}

E = {{O,j, Oi tj,} I Vi, j, i, j, j = j , k : O.j, Oi tj, e O a (Mk(O,j) < Mk(Ot,j,) v Mk(Ot,j,)

^ Mk(O,j))}

FL = {{O,j} I Vi, j : {O,j} c O A {Mk(O,j)} C M}

P = {{Pi,j,k + st,jkW, j, k : Oi j e O a Mk(O,j) e M a (p,jk + st,j^) > 0} / : OM ^ IN.

Vertices in set V represent operations. There are two vertices (fictitious operations) that have no processing time, these are the initial operation I and final operation F.

Each conjunctive arc in the set of arcs A unites a pair of operations belonging to the same job. The first operation of each job is directly connected to the operation I, (I, OXj)A, while the last operation m of each of the jobs is connected with the operation F, (Om,j, F)A. The precedence constraint between a pair of operations of the same job j is represented by a conjunctive arc [Otj, Oi+hj]A. Here A = {{I, Ohj}, {O,j, O+hj}, {Om^j, F}}.

Each disjunctive arc that is in the set of edges E, connects a pair of operations that can be performed on the same machine or on different machines. In the set E, resource capacity constraints are represented for disjunctive arcs where Mk(Oj) precedes Mk(Ofj) or Mk(Orj) precedes Mk(O{ j), between pairs of operations (O{j, O{j) O. The possible direction of each edge depends on which operation of the pair (Oj O{ j) is first performed on machine

The set of operations FL is the set that corresponds to the property that flexible systems have; each operation O,j of the subset of operations {O,j} and set O can choose more than one machine from the subset of machines {Mk(O,j)} of set M to be processed. When machine Mk is selected, it is the only one that executes the operation Oj.

The set P is the set of processing times p, plus the start time st of each operation i of job j executed on machine Mk.

The function ^ indicates that all operations can be executed on more than one machine {Mk(O{j)}. Collectively with the set {Oi j} c O, where O,j can be executed on only one machine, the processing time pijk is defined as the set of positive integers IN. There is set OM = {{Mk(Oi j)},{Oj}}, where i' = i and j' = j. The processing time /x(O,j) is for each operation of OM and for the fictitious operations /x(I) = /x(F) = 0.

3. Partial scheduling mechanism

The partial scheduling mechanism requires an initial solution So for FJSSP. This method is used in Cruz-Chavez et al. (2007) for JSSP; in this paper it is modified for use in FJSSP. The mechanism of partial FJSSP scheduling uses a neighborhood structure of adjacent operation pairs, which randomly selects a pair of operations Ov j, < O, j of So to be executed on the machine Ma, between the operation Oj and operation Ot j that immediately precedes it. There should be no slack time between them. It randomly selects machine Mb, then operation Oj is allocated to its earliest start time before the operations executed in Mb. This must be done without violating precedence constraints. For example, if the operations in Mb belong to the same job as Oi j, the precedence constraints must be respected. This occurs because in the FJSSP, a machine is allowed to execute more than one operation of the same job. Operations in solution So with a completion time of less than or equal to the start time of Oi j keep the same scheduling. Therefore, the partial scheduling starts with the operation that was permuted. The procedure is explained in detail below with an example of an instance of FJSSP presented in Table 1. An instance of three jobs and three machines is presented in Table 1. The machines can process each of the operations in their respective times. In the case of the operation O31, there is only one machine that can process it, t(O31, M3) = 6. Otherwise the operation corresponds to O23, which has three different machines that can process it, each with its respective processing time.

Table 2 presents data from a first solution So for the instance of FJSSP presented in Table 1. For each of the operations, a consecutive number for each is established, from Ol = O1;1 to O9 = O33. This information is reflected in Table 2, column 2. In column 1, a turn T is assigned to each of the operations as they are executed in the system. If two or more operations have the same start time (Ini), the turn is assigned randomly. Column 3 (Job) indicates the job required to execute the operation O. Column 4 (Mk) shows the machine executing the operation O. Column 5 (pt) presents

Table 2

Data for the first solution (So)

Process control

T O Job Mk pt In Ao Pr Ep Ini E

1 4 2 1 4 0 0 0 0 0 4

2 1 1 3 5 0 0 0 0 0 5

3 7 3 1 2 1 4 0 0 4 6

4 5 2 3 6 1 1 4 4 5 11

5 8 3 2 2 0 5 7 6 6 8

6 2 1 1 2 1 7 1 5 6 8

7 9 3 2 4 0 0 8 8 8 12

8 3 1 1 6 0 0 2 8 8 14

9 6 2 3 3 0 0 5 11 11 14

the processing time of operation O on the machine. Column 6 (In) is a flag; if In = 1, then operation O can be permuted with another. If In = 0, it indicates that operation O cannot be permuted with any other operation. Column 7 (Ao) shows that the operation in that column is adjacent to the operation O with which it can be permuted. Column 8 (Pr) presents the case of an operations pair in the same job; it indicates the operation that precedes the operation in column 2. Column 9 (Ep) shows the completion time of the operation in Pr. Column 10 (Ini) indicates the start time of operation O in turn T. Finally, column 11 (E) states the end time of the operation O in turn T, where E = Ini + pt.

To permute a pair of operations Ot, O, executed on the same machine, it is essential that the first operation Oj have a precedent operation O{ (without slack time between Ot, Oj). For example, O{ must precede Oj, otherwise Oj cannot be permuted (In = 0). Oj also cannot be permuted if the preceding operation O{ belongs to the same job. According to the solution So, presented in Table 2, O4, which corresponds to the first operation of job J2 (see Table 1), was assigned T = 1, machine Mj, and has a duration pt = 4 time units. If this is the operation selected as Oj, it cannot be permuted (In = 0). This is because Oj has no preceding operation O{ (Pr) because it is the first operation that is executed on Mj. Therefore, Pr = 0 and the completion time of the preceding operation O{ is Ep = 0. The start time of O4 is Ini = 1 and the completion time is E = 4. Table 2 shows that the operations that can be permuted are the operations O7, O5, and O2 (with value In = 1).

Figure 1 shows the Gantt chart of the solution So. It is noted that operations O7, O5, and O2, each have an adjacent operation on the same machine that precedes them without slack time (O4 -< O7, Ol < O5, O7 < O2) and with operations that correspond to different jobs (see Table 2, column 3). Figure 1 shows that there are three operations (O3, O9, and O6) that have no slack time with the operation that precedes them in the assigned machine. These cannot be considered candidates to be exchanged because of the fact that each of these operations with their respective preceding operation belongs to the same job (so permutation would violate precedence constraints). Figure 1 shows that the makespan of the solution So is 14 time units, since the operation O6 in M3 and operation O3 in M1 are the last to finish (at the same time) at 14 units time. Figure 1 shows each operation, its turn, operation, and job (T O, J).

Fig. 1. Gantt chart of scheduling solution So.

Fig. 2. New scheduling before the permutation of operations 2 and 7 in M1. Solution S1

3.1. Scheduling

A JSSP solution, when applied to a neighborhood structure that permutes pairs of adjacent operations that have no slack time between them, generates feasible solutions (Cruz-Chavez et al., 2006). The partial scheduling method applied to JSSP in Cruz-Chavez et al. (2007) applies this neighborhood structure. Once the permutation of a pair of operations is executed, the proposed algorithm generates a partial scheduling of the problem sequence from the operations affected during the permutation. In the partial scheduling method applied to JSSP (Cruz-Chavez et al., 2007) for a permutation, it randomly selects a turn T from the list of all the operations that can be exchanged (if In = 1), such that the operation in turn T can be permuted by the operation that the precedes it in the same machine. For the case of FJSSP, with the same procedure, it can be seen on review of Table 2 that the operations that can be permuted are O7, O5, and O2. Likewise, O2 is randomly selected to be permuted with three possibilities. Instead of being permuted with O7 (see Fig. 1) that precedes it in the same machine, a machine able to process O2 is randomly chosen. This machine does not have to be the one currently processing O2. The operation O2 is assigned the earliest possible start time, taking care that the new assignment does not violate the precedence constraint between pairs of operations of the same job. For example, operation O2 can be processed in M1 and M2 in 2 and 4 time units, respectively (see Table 1). In So, represented in Fig. 1, the operation O2 is executed in M1 with a start time of 7 time units. The partial scheduling method randomly chooses the machine M2 and verifies that O2 is allocated in its earliest start time possible, respecting precedence constraints. In this case, the result is presented in Fig. 2, where the earliest possible time

Table 3

Data for the new solution S1 (result of the permutation of operations 2 and 7)

Process control

T O Job Mk d In Ao Pr Ep Ini E

1 4 2 1 4 0 0 0 0 1 4

2 1 1 3 5 0 0 0 0 1 5

3 7 3 1 2 1 4 0 0 5 6

4 2 1 2 4 0 0 1 5 6 9

5 5 2 3 6 1 1 4 4 6 11

6 8 3 2 2 1 2 7 6 10 11

7 3 1 1 6 0 0 2 9 10 15

8 9 3 2 4 0 0 8 11 12 15

9 6 2 3 3 0 0 5 11 12 14

without violating precedence constraints with operation Ox that is executed in the same job, was 6 time units. The result is a feasible sequence. At first, operation O2 was in turn T = 6 (see Table 2), but after the reassignment, it moved to turn T = 4 (see Table 3). In cases where an operation to be permuted can only be executed in one machine, then it is permuted with the preceding operation in the same machine (like the partial scheduling procedure for JSSP). The scheduling of turn T = 1 to T = 3 suffered no change in the turn of each operation (see Tables 2 and 3), so these operations do not require a new scheduling. Consequently, the scheduling of operations is only carried out in turns 4 through 9 using the scheduling algorithm presented in Nakano and Yamada (1991). The result of the new solution 5'1 is presented in Fig. 2 and the data for the new 5'1 solution are presented in Table 3. For this example, there is a makespan of 15 time units.

Figure 3 presents the partial scheduling algorithm (Partial-S) that applies the proposed procedure. The algorithm starts by choosing an FJSSP problem instance, then finds an initial solution So and obtains the solution's makespan (scheduling). From So, a list of candidate operations (restrict_list) is selected that can be permutated (In = 1). Candidate operations are those with an adjacent operation and without slack time on the assigned machine. The pairs of adjacent operations cannot be part of the same job. From the list of candidate operations, one is selected and its position (position) is obtained in order to be permutated with an operation from a different machine that can also process it (select_workLoad_machine). The selected machine is different from the assigned one (perturbation_machine). In the event that the selected operation has a single machine that can process it, then the operation is permutated with the adjacent preceding operation on the same machine (perturbation_opAdjacent) as performed in partial scheduling for JSSP, always ensuring that the permutation does not violate the precedence constraint (adjacent operations that belong to the same job cannot be permutated on the same machine). The start time and end time of the operation used for the permutation (Time_ini_endj) is obtained. Then a partial scheduling is made from the new schedule of operations that are in the selected position (position) by the function (re_scheduling_MS) to obtain the complete scheduling of the new solution St and its makespan. The partial scheduling of the new schedule is made by the re_scheduling_MS function that uses the classic scheduling algorithm presented in Nakano and Yamada (1991), Yamada and Nakano (1992), Zalzala and Fleming (1997).

So - Initial solution (Problem); for (i = 0,j = 1; j < = SizeNeighborhood; i++,j++){ list = restrict list(Si); position = turn _perturbation(Si); Mik=select_workLoad_machme (Si,position); IfMik <> 1 then Time ini endj = perturbation machine (Su position, list);

Time ini endj perturbation opAdyacent(Si, position, list) Sj = re_scheduling_MS (Sj, position);

Fig. 3. Local search algorithm with partial scheduling (Partial-S).

4. Accelerated SA algorithm

SA is a stochastic local search technique to approximate the minimum value of the cost function f : S ^ R on a finite set of solutions S. It is an iterative method that searches in the solution space with an iterated local search using a neighborhood function N(s). By generating a new solution neighbor s' of s, the candidate solution s' is accepted as a new solution if f (s') < f (s). When f (s') > f (s), then the new solution is evaluated with an acceptance probability of P(s) based on the Boltzmann function, which involves the control parameter T, and the difference in the quality values solution As = f (s;) — f (s). Initially, T has very high values and as the algorithm progresses, T decreases, which influences the acceptance probability of the solution s'.

In FJSSP, s' is a neighbor of s, which is a schedule of the problem. The cost function f(s) is defined in this work by the makespan (MS). The neighborhood N(s) of s is defined as the set of feasible solutions that can be generated from s in a single step, that is, a permutation of a pair of operations (O, Oj) assigned to a machine Mk.

SA requires initializing the control parameters. The required parameters include parameters To, Tf, and the coefficient of control y, which controls the decrease rate of T. The length of the Markov chain required for an optimization problem is defined by the size of the problem neighborhood,

which indicates the number of iterations performed in the Metropolis algorithm before generating a decrease in T.

The tuning of SA needs uniform distribution P(s) of the Boltzmann function and the distribution P(n) of n random numbers generated to determine the acceptance or rejection of a solution based on P(s). The problem used for achieving equality in terms of uniform distribution of probabilities is P(s) = e—(f (s)—f (s)/T, which has a Poisson distribution, while P(n) has a normal distribution. The principles of probability accept that P(s) has a greater dispersion. This is true for the proper behavior of the phenomenon of SA; the beginning of SA obtains a very high probability of acceptance when T is very high, and as T decreases and approaches zero, the probability of acceptance P(s) is minimal. The cooling sequence in this proposal defines the initial value of the parameter as twice the standard deviation of a sample of randomly generated solutions. When the solutions are compared in the Boltzmann function, they must be in a range (upper bound and lower bound) determined by the average of the solutions generated, more or less two times the standard deviation. The probability principle can accept 75% of all solutions generated in the process of SA, which is equivalent to 95% in processes that follow a normal distribution (Kendall and Stuart, 1958). According to the above, the tuning of the control parameter of SA is based on the standard deviation of a set of 65,000 solutions for each of the selected test instances of FJSSP (Martinez-Rangel et al., 2007). The only differences accepted are those in the cost function | As| = -( f (s') — f (s)) within the range defined as two times the standard deviation. The distribution of P(s) can be uniform in the SA process, the value of To is taken as two times the same standard deviation (To = 2 x a).

The values of each of the parameters involved in the SA process, taking into account the standard deviation, are defined as follows:

• For each of the benchmarks used in the tests, randomly generate a set of enough solutions Q to be able to identify the standard deviation of the quality of the solutions that comprise it.

• To value is equal to two times the standard deviation (2 x a) found for the set Q.

• The decrease in temperature is defined by T y x T, where y = 0.998, the value obtained by an empirical sensibility analysis.

• The length of the Markov chain is twice the neighborhood size of the problem. Ve = 2 x (m x (n — 1)), according to the neighborhood structure used, which performs permutations in adjacent operation pairs without slack time (Cruz-Chavez et al., 2006), where n is the number of jobs and m is the number of machines in the problem, which determines the number of iterations in Metropolis.

• A solution s' of the problem may be evaluated for acceptance or rejection by the Boltzmann probability distribution function, whenever As is not more than twice the standard deviation found in set Q.

• The partial scheduling algorithm seen in Section 3 is used to evaluate the solution s'. This speeds up the local search in SA.

The above points are used to accelerate the process of SA. Figure 4 shows the SA algorithm,

which takes into account the above points, facilitating a more rapid convergence to good solutions

for the FJSSP benchmarks used in this work.

/. Input Data: S, a, Tf, MS=f(S); T = 2 *a, SizeNeighborhood = m *(n-l) *2,

2. while (T>0){

3. NNeighbor = 0;

4. while (NNeighbor < SizeNeighborhood){

5. pick S «= N ( S ) ; 5. If (f(S')<=f(S))

S. S=S';

9. if (MS > f(S')) MS = f(S') ;

10. NNeighbor++;

11. }//end if

12. else

14. A S=f(S')-f(S)

15. if(AS<=2*°)

17. n*-(0<probability<l)

18. if (n<exp (-AS /T)))

70. S = S« //accept new solution

71. NNeighbor++;

73. else

74. S = S; //reject new solution

75. }//end if

76. else S = S; //reject new solution ? 7. } //end else

78. } //end while Markov

79. T = y*T

10. }//end while Tf>0

Fig. 4. Accelerated simulated annealing algorithm.

4.1. Asymptotic complexity of the accelerated SA algorithm

According to Aarts and Van Laarhoven (1985), the computational complexity of the SA algorithm is presented in the following expression (1), where t is the time to generate and evaluate a possible solution, L is the length of the Markov chain, and R is the solution space of the problem being evaluated.

O (tLln |R|). (1)

In the case of FJSSP, the maximum number of steps required to generate and evaluate a solution in the worst cases with a partial scheduling algorithm has the complexity O(nm). L is (nm), which equals the size of the neighborhood. The size of the solution space in the worst cases of an FJSSP is bound, as is the solution space of a classical JSSP (n!)m. More solution space results from the flexibility of FJSSP when, in the worst cases, operations of jobs can be executed by any machine

Table 4

Standard deviation obtained for Q = 65,000

Benchmarks Job/Mach/Op Std. dev.

mk01 10/6/55 11.9

mk02 10/6/58 10.54

mk04 15/8/90 16.58

mk07 20/5/100 36.79

mk05 15/4/106 22.43

mk03 15/8/150 47.30

mk06 10/15/150 23.87

mk08 20/10/225 26.34

mk09 20/10/240 32.49

mk10 20/15/240 28.45

n((nm)!). Then R has a complexity of R e (O((n!)m) + O(m((nm)!))). Therefore the asymptotic complexity of the SA algorithm for FJSSP involves making substitutions fort, L, and R in (1). This is presented in (2) for the JSSP portion, and in (3) for the flexible portion.

O {(nm)2 ln {(n!)m]] (2)

O {(nm)2 ln (m ((nm)!))]. (3)

In (2), if ln(n!) is pushed toward the limit where n approaches infinity, then the limit is infinity, ln(n!) ^ a and ln(n) ^ a, ln(n!) ~ ln(n), and yields expression (4).

O {n2m3 ln (n)]. (4)

In (3), ln(m(nm)!) is pushed toward the limit where nm approaches infinity, then the limit is ln(nm2) and yields expression (5).

O {(nm)2 ln {nm2]]. (5)

The computational complexity of the accelerated SA algorithm for FJSSP is presented in (6).

O {(nm)2 {m ln (n) + ln {nm2]]]. (6)

5. Computational results

The proposed algorithm was implemented in ANSI C using the Visual C on a PC with 2 GHz and 1 GB of RAM, running Windows XP. To test the efficiency of the proposed mechanism, a set of benchmarks of partial FJSSP were used, which are the most difficult within the set of FJSSP problems. The group of test problems was taken from those proposed by Brandimarte (1993).

For tuning the parameter To, of SA, a sample space of feasible solutions for each problem is generated (see Table 5) using the local search algorithm with partial scheduling (see Fig. 3) and using the neighborhood structure proposed in Cruz-Chavez et al. (2006). Table 4 shows the standard deviation values that were generated for test instances using a sample space of feasible solutions. The set ^ consists of 65,000 solutions. Thirty sets ^ were generated for each of the problems. Table 4

Fig. 5. Efficiency of S-Partial versus S-Total.

shows the average deviation of 30 sets Q for each problem. According to Section 4, the initial value for the control parameter of SA is twice the standard deviation.

To compare the efficiency and efficacy of the proposed scheduling mechanisms, two strategies were used to generate schedules for each of the test instances. The first strategy is called S-Total; it uses the classic scheduling algorithm proposed in Nakano and Yamada (1991), Yamada and Nakano (1992), and Zalzala and Fleming (1997). This procedure requires obtaining the total scheduling of all operations in an FJSSP to evaluate the quality of the solution. The strategy S-Total is used in many of the algorithms presented in the literature for FJSSP. The second strategy, called S-Partial (proposed mechanism), obtained the scheduling for some of the operations involved in the instance of the problem to evaluate the quality of the solution. Figure 5 shows the average time required for S-Partial to generate 65,000 solutions in 30 executions of each problem presented in Table 5. It also shows the average time required for S-Total to generate 65,000 solutions for all of test instances used. In Fig. 5, it can be observed that S-Partial has a better efficiency in comparison to S-Total for each of the test instances. S-Partial's largest average time does not exceed 300 seconds, while S-Total's shortest average time is 2500 seconds. It is demonstrated that S-Partial works with greater efficiency and requires an average of one-tenth of the time required by S-Total to evaluate a set Q of solutions.

Figure 6 shows the degree of dispersion of the solutions for the evaluation of the Q of the mk07 instance. This is one of the most intractable of all the used test instances. If the average of the resulting solutions is added to about two times the standard deviation, the probabilistic principle would accept 75% of all solutions generated in the process of SA; the process follows a Poisson distribution. In processes with a normal distribution, two times the standard deviation leads to an acceptance of 95% of the solutions evaluated (Kendall and Stuart, 1958). In SA, when solutions are bad, these solutions can be evaluated with the Boltzmann acceptance criteria, only

Table 5

Results for 10 test instances of FJSSP using controlled and noncontrolled SA-Partial

SA-Partial controlled SA-Partial noncontrolled

Mastrolilli and

Problem Job/Mach/Op Gambardella (2000) taboo search MS RE Av( t) (seconds) MS RE Av( t) (seconds)

Mk01 10/6/55 40 40 0 3200 46 15.0 8705

Mk02 10/6/58 26 28 3.44 4600 31 6.89 9260

Mk03 15/8/90 204 216 5.88 6786 217 6.37 14,371

Mk04 20/5/100 66 60 0 5467 76 15.15 15,678

Mk05 15/4/106 173 168 0 6781 177 2.31 9786

Mk06 15/8/150 58 59 0 3783 64 10.34 8765

Mk07 10/15/150 144 147 2.08 7526 159 10.41 13,940

Mk08 20/10/225 523 524 0.10 8795 534 2.01 17,867

Mk09 20/10/240 307 307 0 4563 317 3.2 12,338

Mk10 20/15/240 198 197 0.50 7865 205 3.53 15,896

0 50 100 150 200 250 300 350

Fig. 6. Dispersion of the generated neighborhood for the Mk07 problem (20 x 5).

when AS < 2 x a. Figure 6 shows that the maximum value of AS is about 312, so the solutions to be evaluated with the Boltzmann criteria must satisfy the condition AS < 234.

If SA is controlled, 75% of all solutions within the search space of feasible solutions are delimited, which must fulfill the condition that AS < 2 x a (see Fig. 4). In addition, if the initial temperature is tuned so To = 2 x a, this accelerates the convergence toward a better solution. The partially controlled SA assists as well, where the partial term refers to the partial scheduling procedure (see Section 3). The result of an SA-Partial controlled is shown in Fig. 7, where the SA-Partial controlled process converges to a better makespan value of 41 in an average of 30 executions of SA for the Mk01 instance, while the SA-Partial noncontrolled process for the same instance at the same time achieves a makespan of 52 after an average of 30 executions. In real terms, the SA-Partial controlled process is 26% more effective than the SA-Partial noncontrolled process; the same phenomenon was observed in all other instances where the proposed algorithm was tested.

Fig. 7. Performance comparison for the Mk01 problem.

As explained in the SA-Partial controlled process, T0 = 2 x a, the value a is obtained by running the local search algorithm 30 times with the partial scheduling presented in Fig. 3, using a population of 65,000 solutions. According to the above problem for Mk01 = 11.9, so that T0 = 2 x 11.9 (Table 4). The value of T0 for the noncontrolled process used values ranges from 10 to 2000, which varied at random in each of the 30 executions.

Of the set of 10 test instances shown in Table 4, only those that could be compared with other studies referenced in the literature were chosen to show the effectiveness of the proposed algorithm. Table 5 shows evidence of efficiency and efficacy of the algorithm SA-Partial controlled and SA-Partial noncontrolled, using the average results of 30 runs for the test problems. The data shown in Table 5 correspond to the relative error (RE) for the best solution found (MS = makespan) and the time required to find the solution for the four test cases. According to the results shown in this table, the effectiveness of the algorithm with a controlled process is much better than the algorithm without controlled process, since the RE and time required to find the solution in all test cases is much higher in the noncontrolled process. Table 5 presents the RE with respect to the results of taboo search (Mastrolilli and Gambardella, 2000).

Table 6 shows a comparison of the efficacy of the proposed algorithm SA-Partial controlled with other studies in the literature and application of other heuristics for instances of the Flexible-JSSP for Brandimarte benchmarks. The RE corresponds to the best solution found (MS = makespan). Compared with taboo search, the proposed algorithm obtains the same or improved results in 40% of the problems evaluated. Compared with GA, the proposed algorithm obtains the same or improved results in 67% of the problems evaluated. Compared with the Ant System algorithm, the proposed algorithm obtains the same or improved results in 40% of the problems evaluated. Compared with variable neighborhood search, the proposed algorithm achieves the same results in one of four problems evaluated. According to the results shown in Table 6, the effectiveness of the

Table 6

RE for Flexible-JSSP for Brandimarte benchmarks

Mastrolilli and Amiri et al.

Gambardella Ho and Tay (2010) variable

SA-Partial (2000) tabu (2004) genetic Gao et al. (2007) neighborhood

Benchmarks Job/Mach/Op UB-LB controlled search algorithm Ant system search

mk01 10/6/55 36-40 0 0 00 0

mk02 10/6/58 24-232 17 8.3 21 8.3 9.2

mk03 15/8/90 204-211 5.9 0 n.d. 0 0

mk04 20/5/100 48-81 25 38 40 25 n.d.

mk05 15/4/106 168-186 0 3 4.8 2.4 n.d.

mk06 15/8/150 33-86 79 76 103 76 n.d.

mk07 10/15/150 133-147 11 8.3 11 4.5 5.9

mk08 20/10/225 523 0.2 0 00 n.d.

mk09 20/10/240 299-369 2.7 2.7 1 2.7 n.d.

mk010 20/15/240 165-296 19 20 39 19 n.d.

n.d. = no data.

Table 7

RE for Flexible-JSSP for Barnes and Chambers benchmarks

SA-Partial Mastrolilli and Oddi et al.

controlled Gambardella (2011) iterative

simulated (2000) taboo flattering

Benchmarks Job/Mach annealing search search

mt10x 10/11 0 0 0

mt10xx 10/12 0 0 0

mt10xxx 10/13 0 0 0

mt10xy 10/12 0 0.1 0

mt10xyz 10/13 0 0 0

mt10cl 10/11 0.1 0.1 0

mt10cc 10/12 0 0.2 0

setb4x 15/11 0 0 0

setb4xx 15/12 0 0 0

setb4xxx 15/13 0 0 0

setb4xy 15/12 0.2 0.7 0

setb4xyz 15/13 0 0 0

algorithm with a controlled process appears competitive with respect to other algorithms reported in the literature.

Table 7 shows a comparison of the efficacy of the proposed partial algorithm SA-controlled with other studies in the literature and application of heuristics for instances of the Flexible-JSSP benchmarks of Barnes and Chambers. The RE corresponds to the best solution found (MS = makespan). Compared with taboo search, the proposed algorithm obtains the same or improved results in 100% of the problems evaluated. Compared with flattering iterative search, the proposed algorithm achieves the same result in 67% of the problems evaluated. According to the results shown in Table 7, the effectiveness of the algorithm with a controlled process appears competitive with respect to other algorithms reported in the literature.

6. Conclusions

Experimental results show that the scheduling algorithm, Partial-S, proposed for FJSSP has better efficiency than Total-S, These experimental results were obtained in a shorter time due to the use of partial scheduling instead of full scheduling. Logically, this allows the SA to accelerate its local search and thus it can explore a larger solution space in FJSSP. Moreover, the tuning of the control parameter T0 by the standard deviation allows an accelerated convergence of the SA-Partial controlled, obtaining better solutions faster, as shown in the experimental results. The combination of these two techniques, the partial scheduling and tuning by the standard deviation, improves the efficacy and efficiency in the process of SA and produces results that compete with those reported in the literature for instances of different sizes of FJSSP.

References

Aarts, E.H.L., Van Laarhoven P.J.M., 1985. Statistical cooling: a general approach to combinatorial optimization problems. Philips Journal of Research 40, 4, 193-226.

Alba, E., Luque, G., Nesmachnow, S., 2013. Parallel metaheuristics: recent advances and new trends. International Transaction in Operational Research 20, 1-48.

Amiri, M., Zandieh, M., Yazdani M., Bagheri, A., 2010. A variable neighborhood search algorithm for the flexible job-shop scheduling problem. International Journal of Production Research 48, 19, 5671-5689.

Applegate, D., Cook, W., 1991. A computational study of thejob shop scheduling problem. ORSA Journal on Computing 3, 149-156.

Babayan, A., He, D., 2004. Solving the n-job 3-stage flexible flowshop scheduling problem using an agent-based approach. International Journal of Production Research 42, 4, 777-799.

Bozejo, W., Uchronski, M., Wodecki, M., 2014. Multi-GPU taboo search metaheuristic for the flexiblejob shop scheduling problem. Advanced Methods and Applications in Computational Intelligence 6, 43-60.

Brandimarte, P., 1993. Routing and scheduling in a flexiblejob shop by taboo search. Annals of Operations Research 2, 158-183.

Cerney, V., 1985. Thermodynamical approach to the traveling salesman problem: an efficient simulation algorithm. Journal of Optimization Theory and Applications 45, 1, 41-51.

Chen, J., Chen, F., 2008. Adaptive scheduling and tool flow control in flexiblejob shops. International Journal of Production Research 46, 15, 4035-4059.

Cruz-Chavez, M.A., Frausto-Solis, J., Cora-Mora, J.R., 2006. Experimental analysis of a neighbourhood generation mechanism applied to scheduling problems. Proceeding of CERMA 2006, Morelos, Mexico, 26-29 September, pp. 226-229.

Cruz-Chavez, M.A., Martinez-Rangel, M.G., Hernandez-Perez, J.A., Zavala-Diaz, J.C., Diaz-Parra, O., 2007. An algorithm of scheduling for the job shop scheduling problem. Proceeding of CERMA 2007, Morelos, Mexico, 25-28 September, pp. 336-341.

Dash, G.H. Jr., Kajiji, N., 2014. On multiobjective combinatorial optimization and dynamic interim hedging of efficient portfolios. International Transactions in Operational Research 21, 6, 899-918.

Gao, J., Sun, L., Gen, M., 2007. A hybrid genetic and variable neighborhood descent algorithm for flexiblejob shop scheduling problems. Computers & Operation Research 35, 9, 2892-2907.

Gao, K.Z., Suganthan, P.N., Pan, Q.K., Chua, T.J., Cai, T.X., Chong, C.S., 2014. Pareto based grouping discrete harmony search algorithm for multi-objective flexiblejob shop scheduling. Information Sciences 289, 24, 76-90.

Gu, F., Chen, H.P., Lu, B.Y., 2006. The solution for multi-objective flexiblejob shop scheduling based on genetic algorithm. Operations Research & Management Science 2006, 2, 134-139.

Gu, P., Balasubramanian, S., Norrie, D.H., 1997. Bidding-based process planning and scheduling in a multi-agent system. Computers and Industrial Engineering 32, 2, 477-496.

Hansmann, K.W., Hoeck, M., 1997. Production control of a flexible manufacturing system in a job shop environment. International Transactions in Operational Research 4, 5/6, 341-351.

Ho, N.B., Tay, J.C., 2004. GENACE: an efficient cultural algorithm for solving the flexible job-shop problem. CEC2004: Evolutionary Computation, Vol. 2, IEEE, New York, pp. 1759-1766.

Ida, K., Oka, K., 2011. Flexible job-shop scheduling problem by genetic algorithm. Electrical Engineering in Japan 177, 3, 28-35.

Kacem, I., Hammadi, S., Borne, P., 2002a. Approach by localization and multiobjective evolutionary optimization for flexible job-shop scheduling problems. Systems, Man and Cybernetics, Part C: Applications and Reviews, IEEE Transactions 32, 1, 1-13.

Kacem, I., Hammadi, S., Borne, P., 2002b. Pareto-optimality approach for flexible job-shop scheduling problem: hybridization of evolutionary algorithms and fuzzy logic. Journal of Mathematics and Computer in Simulation 60, 245-276.

Kendall, M.G., Stuart, A., 1958. The Advanced Theory of Statistics, Vol. 1. Charles Griffin, London.

Kirkpatrick, S., Gelatt, S.D., Vecchi, M.P., 1983. Optimization by simulated annealing. Science 220, 4598, 671-680.

Knopp, S., Dauzere-Peres, S., Yugma, C., 2014. Flexible job-shop scheduling with extended route flexibility for semiconductor manufacturing. Winter Simulation Conference (WSC). IEEE Conference Publications, IEEE, New York, pp. 2478-2489.

Liouane, N., Saad, I., Hammadi, S., Borne, P., 2007. Ant systems & local search optimization for flexible job shop scheduling production. International Journal of Computers, Communications & Control 2, 174-184.

Liu, J., Zhang, Ch., Gao, L., Wang, X., 2010. Research on flexible job-shop scheduling problem under uncertainty based on genetic algorithm. Sixth International Conference on Natural Computation (ICNC) 2010, Shandong, China, 10-12 August, pp. 2462-2467.

Ma, J., Lei, Y., Wang, Z., Jiao, L., Liu, R., 2014a. A memetic algorithm based on immune multi-objective optimization for flexible job-shop scheduling problems. IEEE Congress on Evolutionary Computation (CEC) 2014, Beijing, 6-11 July, pp. 58-65.

Ma, W, Zuo, Y., Zeng, J., Ling, S., Jiao, L., 2014b. A memetic algorithm for solving flexiblejob-shop scheduling problems. IEEE Congress on Evolutionary Computation (CEC) 2014, Beijing, 6-11 July, pp. 66-73.

Martínez-Rangel, M.G., Cruz-Chavez, M.A., Zavala-Díaz, J.C., Juarez-Romero, D., Díaz-Parra, O., 2007. Analysis of the simulated annealing convergence in function of the standard deviation and the Boltzmann quotient for scheduling problems. Research in Computing Science 32, 1, 282-293.

Mastrolilli, M., Gambardella, L.M., 2000. Effective neighbourhood functions for the flexiblejob shop problem. Technical Report, Instituto Dalle Molle Di Studi Sull Intelligenza Artificiale (IDSIA), pp. 45-98.

Mati, Y., Lahlou, Ch., Dauzere-Peres, S., 2011. Modelling and solving a practical flexiblejob-shop scheduling problem with blocking constraints. International Journal of Production Research 49, 8, 2169-2182.

Nakano, R., Yamada, T., 1991. Conventional genetic algorithm for job-shop problems. In Belew, R.K., Booker, L.B. (eds) Proceedings of the 4th International Conference on Genetic Algorithms and their Applications, San Diego, pp. 474-479.

Niroomand, S., Vizvar, B., 2015. Exact mathematical formulations and metaheuristic algorithms for production cost minimization: a case study of the cable industry. International Transactions in Operational Research 22, 3, 519-544.

Nouiri, M., Jemai, A., Ammari, A.C., Bekrar, A., Niar, S., 2013. An effective particle swarm optimization algorithm for flexiblejob-shop scheduling problem. Industrial Engineering and Systems Management (IESM), Proceedings of 2013 International Conference on Publication, Rabat, 28-30 October, pp. 1-6.

Oddi, A., Rasconi, R., Cesta, A., Smith, S.F., 2011. Iterative flattering search for the flexiblejob shop scheduling problem. Proceeding of the Twenty-Second International Journal Conference on Artificial Intelligence, AAAI Press, Menlo Park, CA, pp. 1991-1996.

Papadimitriou, C.H., Steigliths, K., 1998. Combinatorial optimization. Algorithms and Complexity. Dover Publications, New York.

Rahimi, M., Fallah, E., Amiri, M., 2015. Optimization using simulation and response surface methodology with an application on subway train scheduling. International Transactions in Operational Research, DOI: 10.1111/itor.12150.

Roy, B., Sussman, B., 1964. Les problemes d'ordonnancement avec contraintes disjonctives, Note D.S. No. 9 bis, SEMA, Paris.

Shaw, M.J., 1988. Dynamic scheduling in cellular manufacturing systems: a framework for networked decision making. Journal of Manufacturing Systems 7, 2, 83-94.

Shivasankaran, N., Senthilkumar, P., Venkatesh, R.K., 2014. Hybrid non-dominated sorting simulated annealing algorithm for flexible job shop scheduling problems. Advances in Intelligent Systems and Computing 248, 101-107.

Van Laarhoven, P.J.M., Aarts, E.H.L., Lenstra, J.K., 1992. Job shop scheduling by simulated annealing. Operations Research 40, 113-125.

Wang, Y.H., Yin, C.W., Zhang, Y., 2003. A multi-agent and distributed ruler based approach to production scheduling of agile manufacturing systems. International Journal of Computer Integrated Manufacturing 16, 2, 81-92.

Wu, T.-Y., Wu, I.-C., Liang, C.-C., 2013. Multi-objective flexible job shop scheduling problem based on Monte-Carlo tree search. Conference on Technologies and Applications of Artificial Intelligence (TAAI) 2013, Taipei, 6-8 December.

Yamada, T., Nakano, R., 1992. A genetic algorithm applicable to large-scale job-shop. In Manner, R., Manderick, B. (eds) Parallel Problem Solving from Nature 2, North-Holland, Amsterdam, pp. 281-290.

Yuan, Y., Xu, H., 2015. Multiobjective flexible job shop scheduling using memetic algorithms. IEEE Transactions on Automation Science and Engineering 12, 1, 336-353.

Zalzala, A.M.S., Fleming, P.J. (eds), 1997. Genetic Algorithms in Engineering Systems. Institution of Electrical Engineers, London.

Zhang, C.Y., Rao, Y., Li, P.G., Shao, X.Y., 2007. Bilevel genetic algorithm for the flexible job-shop scheduling problem. Chinese Journal of Mechanical Engineering, 4, 119-124.

Zhang, Q., Manier, H., Manier, M., 2013. Metaheuristics for job shop scheduling with transportation. In Jarboui, B., Siarry, P., Teghem, J. (eds) Metaheuristics for Production Scheduling, Hoboken, NJ, John Wiley & Sons, 465-493.

Zheng, Y., Lian, L., Fu, Z., Mesghouni, K., 2015. Evolutional algorithm in solving flexible job shop scheduling problem with uncertainties. LISS 2013: Proceedings of 3rd International Conference on Logistics, Informatics and Service Science, Springer Verlag, Berlin, pp. 1009-1015.

Zhou, W., Bu, Y., Zhou, Y., 2014. Combining CA and PSO to solve flexible job shop scheduling problem. The 26th Chinese Control and Decision Conference (CCDC) 2014. Changsha, China, 31 May-2 June, pp. 1031-1036.