Metaheuristics for Order Scheduling Problem with Unequal Ready Times

In recent years, various customer order scheduling (OS) models can be found in numerous manufacturing and service systems in which several designers, who have developed modules independently for several different products, convene as a product development team, and that team completes a product design only after all the modules have been designed. In real-life situations, a customer order can have some requirements including due dates, weights of jobs, and unequal ready times. Once encountering different ready times, waiting for future order or job arrivals to raise the completeness of a batch is an efficient policy. Meanwhile, the literature releases that few studies have taken unequal ready times into consideration for order scheduling problem. Motivated by this limitation, this study addresses an OS scheduling model with unequal order ready times. The objective function is to find a schedule to optimize the total completion time criterion. To solve this problem for exact solutions, two lower bounds and some properties are first derived to raise the searching power of a branch-and-bound method. For approximate solution, four simulated annealing approaches and four heuristic genetic algorithms are then proposed. At last, several experimental tests and their corresponding statistical outcomes are also reported to examine the performance of all the proposed methods.


Introduction
In recent years, various researchers have described customer order scheduling (OS) models (Framinan et al. and [1]).These models can be found in numerous manufacturing and service systems in which several designers, who have developed modules independently for several different products, convene as a product development team, and that team completes a product design only after all the modules have been designed.A practical example is that a manufacturer produces semifinished lenses and competes globally provided by Ahmadi et al. [2].
Regarding the literature on order scheduling with order ready times, only Leung et al. [3] discussed and analyzed the order ready times in a customer order scheduling model with regard to minimizing the total weighted completion time.
Garg et al. [1] analyzed the complexities of order schedules to optimize the weighted flow time or offline weighted completion time.Therefore, in this paper we investigate a multiple-machine OS model with different order ready times in which the goal is to find a schedule to minimize the total completion time of  orders.Regarding the importance of ready times in wafer fabrication, readers may refer to Monch et al. [4].Moreover, the jobs or orders to be processed may have different priorities such as the due dates or weights or ready times.In a model with different ready times, waiting for future order or job arrivals to raise the completeness of a batch is an efficient policy.
Within the relevant literature on taking the total weighted completion times into consideration, it has been shown as an NP-hard by Sung and Yoon [5].Some effective heuristics were developed by Wang and Cheng [6] and Leung et al. [3,7,8] for approximate solutions, and a branch-and-bound algorithm was proposed by Yoon and Sung [9] for the exact solution.For the total completion time criterion minimization, Ahmadi et al. [2] showed that it is NP-hard and built some heuristics accordingly.More recently, Framinan and Perez-Gonzalez [10] studied an OS model with completion time objective but zero ready times.They proposed a constructive heuristic with the same complexity compared to the ECT.The key element of this heuristic lies in its ability to estimate the expected contribution of the unscheduled orders, therefore mitigating the greedy behavior of the ECT.In addition, they proposed two improvement mechanisms that are further embedded into a greedy search procedure (GSA) for finding high-quality solutions.For the OS models with the due dates, readers may refer to Leung et al. [11] for minimizing the maximum lateness and to Lee [12] for minimizing the total tardiness.Extending the problem by Lee [12], Xu et al. [13] assumed that order processing times can be shortened by a position-based learning factor.Framinan and Perez-Gonzalez [14] studied the same problem as Lee [12] did.As extremely fast (negligible time) solutions are required, Framinan and Perez-Gonzalez [14] derived a new constructive heuristic that incorporates a look-ahead mechanism to estimate the objective function at the time that the solution is being built.For the scenarios where longer decision intervals are allowed, they provided a novel matheuristic strategy to provide extremely good solutions.Wu et al. [15] addressed an OS problem with sum of-processing-time-based learning effect to minimize total tardiness of the orders.For other researches on OS models, readers may refer to Yang and Posner [16], Leung et al. [3,17], and Leung, Li et al. [18] on identical but parallel machine settings.Lin et al. [19] utilized three variants of a particle swarm optimization (PSO) algorithm including a basic PSO, an opposite-based PSO, and a PSO with a declined inertia weight for a OS model with two agents and ready times.The criterion is to minimize the total completion time for the orders from agent A while the total completion time for the orders from agent B has a given upper bound.Wu et al. [20] considered an OS model to minimize the linear sum of the total flowtime and the maximum tardiness.In particular, they proposed a branch-and-bound (B&B) algorithm along with several dominance relations and a lower bound, three modified heuristics, and a hybrid iterated greedy algorithm to solve the problem.For some substantial works on approximation algorithms for 1|  | ∑   , readers may refer to Chekuri et al. [21], Hochbaum and Shmoys [22], Sevastianov and Woeginger [23], Alon et al. [24], and Schuurnman and Woeginger [25].Readers may refer to Chen et al. [26] for a general overview of approximation techniques.The main contributions of this work are described as follows: an order scheduling problem of introducing ready times for each orders and minimizing the total completion time criterion is studied.A B&B method with four propositions and two lower bounds is derived for finding the exact solution.Four versions of simulated annealing algorithm (SA) and four versions of genetic algorithm (GA) are provided for searching the good-quality approximate solutions.The instance simulation experiments and some statistical methods are utilized to determine the performances for all proposed algorithms.
The rest of this study is organized as follows: Section 2 introduces the notation and formulates the problem.Section 3 provides some dominance propositions and two lower bounds used in a branch-and-bound (B&B) algorithm.Section 4 proposes four variants of a simulated annealing (SA) approach and four heuristic genetic algorithms (GA) for finding approximate solutions.Section 5 presents computational results to evaluate the performance of the eight proposed algorithms.The conclusion and suggestions for future study are provided in Section 6.

Problem Statement
This section first introduces some notation that is applied in this study.(1) [] is the order which is arranged in the lth position in a given schedule.
The problem is formulated as follows.Suppose that  orders come in from  different clients at different times (ready times), and each order comprises  components.Let a facility with  different machines be operated in parallel form.A machine can produce its own item; that is, an item can be done on a dedicated machine.If each order has its own ready time, then unforced idleness is also allowed.Preemptions are not forbidden.Let   denote the processing time for component  of order  to be processed on machine k and let  [] denote order  to be placed in the rth position in a given sequence.The objective is to seek a sequence to let the total completion time criterion be minimized.To find that the optimal sequence is equivalent to finding a schedule  that optimizes the objective function ∑  =1   (), an illustrative example follows.
Example 1.Given an instance problem with n = 2, m = 2.The processing times of each component of order   , i = 1, 2, on machine   , and the ready times of order  i , i = 1, 2, are provided in Table 1.Given an order schedule S = (O 1 , O 2 ), according to the definition of   (), one have the following computation, and Figure 1 shows the Gantt diagram.

Propositions and Lower Bound
Branch-and-bound (B&B) has received a considerable amount of attention for solving numerous combinatorial problems (Pinedo 2008; [27][28][29]).On the basis of the proof by Lenstra et al. [30] that the problem 1|  | ∑   is strongly NP-hard when each order has one component only, we know our proposed problem is also an NP-hard problem.Garg et al. [1] also demonstrated that even the unweighted completion time problem with a single ready time is NP-hard.Thus, two lower bounds and certain dominant properties can be applied in a B&B algorithm to find an optimal solution.Following that, four variants of a simulated annealing and four heuristic genetic algorithms are proposed for finding near-optimal solutions.
The proofs of Propositions 3-5 are omitted because they are similar to that of Proposition 2.
Next, a lower bound is another element to raise the efficiency of a B&B algorithm; the algorithm can be expedited by eliminating the partial nodes.In the following, two lower bounds will be proposed for the B&B method.Let  be a partial sequence, in which the order of the first V jobs is determined and let  be the unscheduled part consisting of  1 = (n-v) jobs.Furthermore, let   be the starting time of the first order in US for machine k, and  = ∑  =1   /.Following the definition of (1), we have From the above discussions, we have Regarding the second right-hand term of ( 8), according to Hardy et al. [31], the value of may be optimized when the orders { 1 −  + 1} and {∑  =1  [V+] } are ordered in opposite ways.Therefore, the first lower bound (LB 1 ) can be obtained as follows. where Adopting similar steps, another lower bound is easily derived as follows. where for the remaining orders in US.
To tighten the lower bound, the maximum value from ( 9) and ( 10) can be set as the lower bound of AS; i.e.,

Four Variants of SA and Four GA Algorithms
Metaheuristics have been widely utilized to numerous discrete or continuous NP-hard dynamic combinatorial models.
For more examples, readers may refer to Kirkpatrick et al. [32] and Holland [33], among other works.Because the problem under study is considerably difficult, to minimize the solution time cost increased by the solving process, we developed four simulated annealing (SA) approaches and four genetic algorithms (GAs) for near-optimal solutions.Notably, both SA and GA are not simple heuristics; they are metaheuristics.This is crucial because heuristics are usually simple algorithms, but they are complex metaheuristics and they are also difficult to build and carry when comparing with simple heuristics.The SA is one of the most common metaheuristics to apply for many discrete or continuous optimization problems (see [32,34]).The main procedures of SA are described in the following.End do GA widely used another metaheuristic using an intelligent random searching policy to solve numerous difficult NPhard problems.The important steps are including a structure, a population, a fitness function, reproduction mechanism, and a crossover operator to generate offspring.For more details, readers may refer to Holland [33] and Essafi et al. [35].The procedure of the proposed GA is detailed as follows.
The steps of GA procedure: Do while (generation sizes < 500) (i) Input three initial sequences to generate N = 20 populations in GA. (ii) Compute the total completion time for each population and then calculate fitness function values of the strings as ( , where   (V) is the ith string chromosome in the vth generation; determine the selection probability of a schedule as (  (V)) = (  (V))/ ∑  =1 (  (V)).(iii) Use a linear order crossover in the GA (see Falkenauer and Bouffouix, [36]), and set the crossover rate P  at 1. (iv) Set the value of mutation (  ) at 0.35.(v) Excluding the ideal schedule with a minimum total completion time of  orders, create the other offspring from the parent sequences by using the roulette wheel method.

End do
In the present work, to obtain the final solution as quickly as possible, three initial sequences are adopted in SA or GA.In SA min or GA min, orders are arranged in nondecreasing sequence of   + min 1≤≤ {  }, whereas, in SA max or GA max, orders are arranged in nondecreasing sequence of   + max 1≤≤ {  }.In SA mean or GA mean, orders are arranged in nondecreasing sequence of   + ∑  =1 (  /).The weighted earliest completion time (WECT) heuristic from Leung et al. [3] is incorporated into SA and GA; Because the objective of this study is to minimize the total completion function of all  orders, instead of the total weighted completion time, we set all   = 1.Let  denote the set of  orders.Initially, place the order returned from min ∈ {max 1≤≤ (  +   )} in the first position and find its completion time, denoted as  [1] .Next, delete the scheduled order from N, and place the order returned from min ∈ {(  −  [1] )} in the second position.Repeat this process similarly for all orders.This is called the WECT method.For more details, readers may refer to Leung et al. [3].

Computational Experiments
Several experimental tests were conducted to determine the performance of the B&B, the four SAs, and four GAs.Those proposed algorithms are written in FORTRAN.
To determine the B&B performance, we report the mean and maximum numbers of nodes and the mean and maximum CPU times (in seconds), respectively.For the variants of SA or GA algorithms based on small numbers of orders (n = 12, 14, or 16), we report the mean and maximum error percentages in which the average error percentage (AEP) was defined as  = (  −  * )/ * × 100%, where   was the value of the total completion time yielded from SA or GA and  * was the value of total completion time yielded from the B&B algorithm.
For the variants of SA or GA algorithms based on large numbers of orders (n = 50 or 100), we recorded the mean and maximum relative percentages of deviation (RPDs) in which where   was the value of total completion time yielded from SA or GA and  * was the smallest objective value selected from among the four SAs and the four GAs.The two parts of the computational experiment involved small numbers of orders and large numbers of orders.
For the small numbers of orders, we set the numbers of machines at m = 2, 3, and 4. The number of orders was tested at n = 12, 14, and 16.A set of 100 instances was randomly generated for each case.
In the experiment, the B&B was set to skip to the next data set if the number of nodes exceeded 10 8 .The computational results of the B&B method are presented in Table 2, where the last column FS reports the number of instances for which the B&B achieved the optimal solution.The results from Table 2 can be examined in detail; the changes of number of nodes obtained by the B&B method with variations in the parameters n, m, and  are illustrated in Tables 3 and 4. From Table 3, it can be found that the number of nodes tends to decrease for each fixed value of  as the value of  increases.On the contrary, it appears from Table 4 that the number of nodes tends to increase for each fixed value of  as the value of  increases except for n=16.The computational results obtained by the four SAs and four GAs are given in Table 5, and the AEPs are obtained by these algorithms as the parameters n, m, and  vary.From Table 5, it can be seen that the AEP values obtained by all algorithms tend to linearly decrease as  increases for n = 12 and n = 14.For n = 16, the AEP values obtained by these algorithms first increase but then decrease as  increases.Table 5 also indicates that the variation range of AEP obtained by each algorithm is relatively small and the results reveal no trace concerning the impact of  on the AEP.Regarding the performance of these algorithms, the box plots in Figure 6 display the AEP distributions of the eight algorithms.To compare the statistically significant differences in solution quality levels for solutions from the four SAs and the four GAs, we applied analysis of variance (ANOVA); the p value was less than 0.05, as seen in Table 6.We then employed SAS package software to do Fisher's least significant difference (LSD) tests; the outcomes are shown in Table 7.At the 0.05 level of significance, the AEP means were divided into three groups.The AEPs of SA-mean and SA-max were in the smallest (optimal) group, and AEP of the GA-wect was the largest (worst), whereas the AEPs of the other five algorithms were in the middle group.The SA-max and SAmean algorithms can be recommended for small numbers of orders.
In experiments with large numbers of orders, we set the numbers of orders at n = 50 and 100 and the numbers of machines at m = 5, 10, and 20.One hundred instances were randomly created for each case.

Conclusions
Multifacility order scheduling model has become a vital challenge in numerous practical service and manufacturing situations.Unlike previous studies, which have assumed that all orders are available at time zero, this study investigates orders with different ready times and provides several contributions.First, two lower bounds and several dominant properties are developed, based on which a B&B algorithm is proposed to solve the problem with a small number of orders.Second, four SA variants and four GA variants are presented to obtain near-optimal solutions for problems with large numbers of orders.Computational experiments based on extensive test problems were conducted to evaluate the performance levels of the proposed B&B algorithm and the various SAs and GAs, as well as the impacts of parameters on their performance levels.The experimental outcomes reported that, with the help of the lower bounds and properties, the B&B can tackle problem instances up to n = 16 within a considerable time.
In addition, the tested outcomes also illustrate that the four SA variants and the four GA variants deliver satisfactory performance in terms of efficacy and efficiency for problem instances with both small and large numbers of orders.
Based on the outcomes obtained by the algorithms, it is recommended that SA-mean or SA-max be utilized to solve the proposed problem because they both outperform GAs and can quickly achieve favorable solutions with a very small value of AEPs.It can be also seen that the problem scale that can be solved by the proposed B&B algorithm only up to n = 16 is limited.The dominance relations or lower bounds of the B&B method appear to be not strong or tight enough.A future study may develop more powerful dominance relations or lower bounds.

Figure 1 :
Figure 1: The Gantt diagram of the completion times of two orders.

Figure 2 : 2 Figure 3 :
Figure 2: Change of RPD for each  as  increases for SAs and GAs for large number of orders.

Figure 4 :Figure 5 :
Figure 4: Change of CPU time for each  as  increases for SAs and GAs for large number of orders.

Figure 6 :Figure 7 :
Figure 6: Box plots of AEP for the algorithms for small number of orders.

Table 2 :
Computational results of the branch-and-bound method.

Table 3 :
The impact of  in the branch-and-bound algorithm.

Table 4 :
The impact of m in the branch-and-bound algorithm.

Table 5 :
Computational results of the SAs and GAs for small number of orders.

Table 6 :
ANOVA for the AEP for small number of orders.

Table 7 :
Results of Fisher's LSD for differences among algorithms for small number of orders.

Table 10 :
The RDP results of the SAs and GAs for large number of orders.

Table 11 :
CPU times (seconds) of the SAs and GAs for large number of orders.It is obvious that the four SA algorithms outperformed the GAs, and the GA-wect performed the worst.However, another ANOVA, shown in Table8, and another set of Fisher's least significant difference tests, shown in Table9, indicate that, at the 0.05 significance level, there are no differences among the algorithms except for GA-wect.Furthermore, the box plots in Figure7also indicate that the RPDs of the four SAs have less dispersion; thus, the SA algorithms solve these problems with both accuracy and stability when the numbers of orders are large.