A Job-Shop Scheduling Problem with Bidirectional Circular Precedence Constraints

,


Introduction
e job-shop scheduling problem (JSP) [1,2] and the openshop scheduling problem (OSP) [3,4] are well-known in practical applications. ey are also interesting academic topics since they are NP-hard problems [5]. ey both involve scheduling jobs onto machines in order to minimize makespan, i.e., the schedule's length. Each job consists of a number of operations; each operation must be processed on a predetermined machine with a given processing time. Each machine cannot process more than one operation at a time, and it cannot be stopped during processing an operation. To complete each job in JSP, all of its operations must be processed in the sequence from the first to the last operations.
is sequence is called an operation-precedence-relation chain. e operation-precedence-relation chain of each job is very strict and, thus, cannot be changed. In contrast to JSP, OSP has no operation-precedence-relation chains. is means all operations of each job in OSP can be processed in any orders. e job-shop scheduling problem with bidirectional circular precedence constraints (BCJSP) introduced in this paper is an intermediate problem between JSP and OSP. It is a generalized JSP where the operationprecedence-relation chain of each job is circular and bidirectional. BCJSP has a wide range of real applications, e.g., health check-up service, automobile repair shop, and instrument calibration service. In fact, when taking layouts and distances into account, many OSP's applications become BCJSP's applications. e health check-up service, as a BCJSP application, starts with multiple optional check-up programs offered to hospital customers. An optional checkup program consists of specific diagnoses, each of which is provided in a different room. For customer satisfaction, the best circular route of all diagnosis rooms has been predetermined by a hospital service manager for each check-up program. e manager may assign each customer to receive any diagnosis of his chosen program as the first diagnosis. However, the manager has to assign the customer to receive his next diagnosis in a nearest predetermined room, and so on. e customer finishes his check-up activities after successfully receiving all diagnoses of his chosen program. Notice that if the diagnosis rooms are very close to each other, the manager can then assign the customer to receive all diagnoses in any orders. en, this application fits with OSP rather than BCJSP.
ere are a number of JSP and OSP's variants recently presented in the literature, e.g., [6][7][8][9][10][11]. Some of them have some partially similar properties to the BCJSP's properties. For example, the extended resource-constrained project scheduling problem [12] allows processing its activities bidirectionally, but not circularly. e flexible job-shop scheduling problem (FJSP) has more flexibility than JSP and is also defined as a generalized form of JSP. However, the flexibility of FJSP [13,14] is due to a number of selectable machines for each operation, while the flexibility of BCJSP is due to the bidirectional circular precedence relations of operations.
To solve BCJSP, this paper introduces a multilevel metaheuristic (called MUL) based on the adaptive parameter control concept [15]. MUL consists of the top-level algorithm (called TOP), the middle-level algorithm (called MID), and the bottom-level algorithm (called BOT). In the MUL's top level, TOP controls the start operation and the operation-precedence-relation direction of every job in BCJSP. TOP is also usable to control the MID's input parameters if requested. In the middle level, MID transfers the start operation and the operation-precedence-relation direction of every job given by TOP into BOT. However, the MID's main function is to control the BOT's input parameters. In the bottom level, BOT uses the start operations and the operation-precedence-relation directions to generate a JSP instance, which is a subproblem of the BCJSP instance. BOT then acts as a local search algorithm for solving the generated JSP instance. MID evolves the BOT's input-parameter values based on feedback from BOT, while TOP evolves the operation-precedence-relation chains and the MID's input-parameter values based on feedback from MID. e BOT combined with MID is similar to the two-level metaheuristic developed by [16]. A major difference of the MID-BOT combination from the algorithm of [16] is in the solution-decoding procedure. Once the MID-BOT combination is combined with TOP, they all together have become MUL. MUL can be defined as an adaptive multistart iterated local search algorithm for solving BCJSP.
ere are two variants of MUL proposed in this paper, i.e., the basespecification MUL (called MUL-B) and the top-specification MUL (called MUL-T). e only difference between the two variants is in their TOP-MID relationships. In both MUL-B and MUL-T, their TOPs control the start operation and the operation-precedence-relation direction of every job. In only MUL-T, its TOP also controls the MID's input parameters. Performance of MUL-B and MUL-T was evaluated on the BCJSP instances, modified from the JSP instances of [17,18,19]. On the BCJSP instances, MUL-B's and MUL-T's results were compared with each other. Because the existing JSP-solving algorithms can be used to solve BCJSP, their results were also used in the performance comparisons. Note that the existing JSP-solving algorithms mean the algorithms developed for solving JSP in the literature, e.g., [1,2,16,20,21]. e remainder of this paper is divided into six sections. Section 2 provides an overview of the relevant publications of the research topic. Section 3 describes the job-shop scheduling problem with bidirectional circular precedence constraints (BCJSP). Section 4 presents the procedure of MUL, where the procedures of BOT, MID, and TOP are described in Sections 4.1-4.3, respectively. e differences between MUL-B and MUL-T, as the two variants of MUL, are also described in Section 4. Section 5 presents the experiment's results for MUL-B's and MUL-T's performance evaluations. Section 6 then discusses the experiment's results. Finally, Section 7 concludes the research's findings.

Related Works
Metaheuristics can be classified into two categories based on their numbers of solutions used in each iteration, i.e., singlepoint-based and population-based search algorithms [22]. As its name implies, a single-point-based search algorithm starts with a single solution. en, it moves from its current solution to another solution repeatedly. Local search is a well-known type of single-point-based search algorithms. A local search algorithm improves its solution gradually within a local region of the solution space. Although a local search algorithm aims to find just a local optimal solution, the algorithm with a good initial solution occasionally finds a global optimal solution. Iterated local search [23] is another well-known type of single-point-based search algorithms. It can be defined as a local search algorithm that can escape a local region of the solution space. During its exploration, an iterated local search algorithm uses a neighbor operator repeatedly to find a local optimal solution. After that, it tries to escape the current local region into another local region by using a perturbation operator. In general, an iterated local search algorithm starts with a single solution; however, some recent variants, e.g., [24,25], have multistart properties.
ere are three operators, i.e., swap, insert, and inverse, commonly used as a neighbor operator and a perturbation operator [26]. To define these three operators, let h and v be two different random integers from 1 to the number of members in a solution-representing permutation. e swap operator is to swap between the two members in the h-th and thev-th positions. e insert operator is to remove a member from the h-th position and then insert it back at the v-th position. e inverse operator is to inverse the sequence of 2 Complexity all members from the h-th to thev-th positions. Some iterated local search algorithms, e.g., [27,28], use the swap operator or insert operator multiple times as their perturbation operators. As mentioned, the population-based search algorithm category is the alternative of the single-point-based search algorithm category. A population-based search algorithm starts with a set (i.e., a population) of solutions instead of a single solution. At each iteration, a population-based search algorithm evolves its population by using the information from its previous iterations. Some population-based search algorithms were purposely developed for solving discrete optimization problems, such as genetic algorithm [29] and ant colony optimization [30]. In contrast, some others were intentionally developed for exploring in real-number search spaces, such as particle swarm optimization [31], differential evolution [32], and cuckoo search [33] algorithms.
A common drawback of most metaheuristics is that there is no single set of input-parameter values performing best for all problem's instances. However, several techniques can be applied for handling such a drawback. One of these techniques is adaptive parameter control [15], where an upper-level metaheuristic acts as a parameter controller for a lower-level metaheuristic. (Note that upper-level metaheuristic is commonly called metaevolutionary algorithm [15,34].) In addition, an upper-level metaheuristic can be applied to control parameters of a being-considered problem for generating its simpler subproblems [35,36]. For applying the adaptive parameter control technique, the metaheuristics usually have only two levels [4,15,16,[37][38][39]. However, for solving highly complicated problems, they may require more than two levels [35,36].
A two-level metaheuristic of [37] was developed for solving JSP. It consists of the algorithms named UPLA and LOLA in its upper and lower levels, respectively. LOLA is a local search algorithm exploring in a solution space of parameterized-active schedules (hybrid schedules) [40][41][42], where each parameterized-active schedule is decoded from an operation-based permutation [29,43]. UPLA is the population-based search algorithm intentionally developed for being a parameter controller. Its population consists of a number of value combinations of input parameters of LOLA. For updating an input-parameter-value combination, each input-parameter value is iteratively moved by a sum of two changeable opposite-direction vectors. e first vector's direction is toward the memorized best-found value, whereas the second vector's direction is away from it. e magnitudes of these two vectors are generated randomly between zeros and their given maximum values. e two-level metaheuristic of [16] is a recent variant of [37]. In this variant, MUPLA and LOSAP are the upper-level and lower-level metaheuristics, respectively. LOSAP [16] is a local search algorithm exploring in a probabilistic-based hybrid neighborhood structure. To generate each neighbor solution, LOSAP randomly uses one of the two predetermined neighbor operators by a preassigned probability. (Other applications of randomly using one of two different operators can be found in [44,45].) Note that while LOLA's solution space is a set of parameterized-active schedules, LOSAP's solution space is just a set of semiactive schedules. It means that the LOSAP's search ability is mainly based on its hybrid neighborhood structure, not based on a special solution space like LOLA. LOSAP has many optional operators proposed for being its perturbation and neighbor operators. In addition, LOSAP uses a different criterion from that of LOLA on accepting a new best-found solution.
MUPLA [16] is a population-based metaheuristic designed to be a parameter controller for LOSAP. us, its population consists of a number of value combinations of the LOSAP's input parameters. Each input-parameter-value combination contains specific values of the perturbation operator, the scheduling direction, the ordered pair of two neighbor operators, the probability of selecting a neighbor operator, and the start solution-representing permutation. A major change of MUPLA from UPLA is that each inputparameter-value combination in its population includes a specific start solution-representing permutation. us, the MUPLA combined with LOSAP acts as a multistart iterated local search algorithm, while the UPLA combined with LOLA is just an iterated local search algorithm.

Problem Definition
BCJSP is an intermediate problem between JSP and OSP; however, it can be explained simpler as a JSP's generalized variant. BCJSP aims to find a feasible schedule that minimizes makespan (i.e., a total length of the schedule). e problem comes with m given machines (i.e., M 1 , M 2 , . . ., M m ) and n given jobs (i.e., J 1 , J 2 , . . ., J n ). At the beginning (i.e., time 0), all jobs have already been arrived, and all machines have not yet been occupied. Each job J i (where i � 1, 2, . . ., n) consists of m operations (i.e., O i1 , O i2 , . . ., O im ). Each operation must be processed by a predetermined machine with a predetermined processing time. Each machine cannot process more than one operation at a time, and it cannot be stopped or paused during processing an operation. In other words, an operation preemption is not allowed. BCJSP differs from JSP in that an operation-precedence-relation chain of each job J i (where i � 1, 2, . . ., n) is circular and bidirectional, as shown in Figure 1. Figure 1 shows the relationships of the operations O i1 , O i2 , . . ., O im of the job J i in BCJSP. For each job J i , let the precedence relations of O i1 , O i2 , . . ., O im be all together connected as a circular chain. It means that any operation from O i1 to O im can be selected as the start operation of the job J i (i.e., the operation processed first in the job J i ). en, to complete the job J i , the remaining operations in the circular chain must be processed one-by-one in either a clockwise or counterclockwise direction. In Figure 1, the operations connected together by green arrows present the circular operation-precedence-relation chain in clockwise direction, while those by blue arrows present the chain in counterclockwise direction.
A BCJSP instance can be divided into (2m) n JSP instances as all of its subproblems. Each subproblem is generated from the BCJSP instance by assigning a specific start operation and a specific operation-precedence-relation direction into every job. To generate a subproblem, let O ik be the start operation of the job J i , which is selected from any en, let the operationprecedence-relation direction of the job J i be selected from either clockwise or counterclockwise. If the clockwise direction is selected, let the operation-precedence-relation chain of the job In this paper, D ⇒ E means that D must be finished before E can be started.
To clarify the above paragraph, consider a BCJSP instance that has three machines (i.e., M 1 , M 2 , M 3 ) and two jobs (i.e., J 1 and J 2 ). Each job J i (where i � 1 and 2) then consists of three operations (i.e., O i1 , O i2 , and O i3 ). To generate a subproblem, there are six options for the job J 1 's operation-precedencerelation chain: In addition, there are six options for the job J 2 's operation-precedence-relation chain: (1) 22 . Of each job, the first three options are generated in clockwise direction, while the last three options are generated in counterclockwise direction. Based on the six options of each job, this BCJSP instance can be divided into 36 JSP instances as all of its subproblems.
BCJSP is a generalization of JSP and is also much more complex than JSP. Every single BCJSP instance can be divided into (2m) n JSP instances as all of its subproblems. Because JSP with m = n = 3 has been proven to be NP-hard [5], BCJSP with m ≥ 3 and n ≥ 3 thus belongs to a class of NP-hard problems. In the literature, no algorithms excepting MUL-B and MUL-T have been developed for BCJSP. Although the existing JSPsolving algorithms without modifications can be used to solve BCJSP, they may not perform well on BCJSP. is is because, with the same m and n, a solution space of BCJSP is much larger than that of JSP.

Methods
As mentioned, MUL represents the proposed multilevel metaheuristic for solving BCJSP. It consists of BOT, MID, and TOP algorithms in its bottom, middle, and top levels, respectively. BOT is a local search algorithm, modified from LOSAP [16], for solving subproblems of the BCJSP instance. Each subproblem is a JSP instance modified from the BCJSP instance by assigning a specific start operation and a specific operation-precedence-relation direction into every job. MID, as a variant of MUPLA [16], is a population-based metaheuristic for controlling BOT's input parameters. Another function of MID is to transfer the start operation and the operation-precedence-relation direction of every job from TOP into BOT. TOP is a populationbased metaheuristic developed based on the framework of MUPLA [16]. TOP is used to control the start operation and the operation-precedence-relation direction of every job in the BCJSP instance. If requested, TOP can also control the MID's input parameters as an extra optional function.
In this paper, there are two variants of MUL, i.e., the base-specification MUL (MUL-B) and the top-specification MUL (MUL-T). MUL-B is the MUL whose TOP controls only the start operation and the operation-precedence-relation direction of every job in BCJSP. MUL-T is the MUL whose TOP controls the start operation and operationprecedence-relation direction of every job and also the MID's input parameters. e details of BOT, MID, and TOP are described in Sections 4.1-4.3, respectively.

BOT Algorithm.
BOT is a local search algorithm for solving subproblems of the being-solved BCJSP instance; each subproblem is a JSP instance. BOT generates each subproblem from the BCJSP instance by assigning a specific start operation and a specific operation-precedence-relation direction into every job. Let A i and B i represent the start operation and the operation-precedence-relation direction, respectively, of the job J i (where i � 1, 2, . . ., n). For each job J i , A i can be any operation selected from O i1 , O i2 , . . ., O im ; in addition, B i can be either a clockwise or counterclockwise direction. In this paper, BOTreceives A i and B i from TOP via MID.
To illustrate how to use A i and B i , assume

Complexity
After BOT has successfully generated a JSP instance (which is a subproblem of the BCJSP specified by A i and B i ), BOT acts as a local search algorithm for solving the JSP instance. BOT uses operation-based permutations [29,43] to represent semiactive schedules, where an operation-based permutation is a permutation with m repetitions of the numbers 1, 2, . . ., n. However, the transformation into a schedule for the BCJSP's subproblem differs from the transformation used by [29,43] for the classical JSP. e difference is due to the specific order of operations in the operation-precedence-relation chain assigned by A i and B i . For example, on a 2-machine/3-job BCJSP instance, assume a given permutation be (2, 1, 2, 3, 1, 1, 3, 3, 2). In addition, assume BOT, as modified from LOSAP [16], improves its solutions by using PT and PN. Let PT represent the perturbation operator, and let PN ≡ (PN f , PN s ) represent the ordered pair of the first neighbor operator (PN f ) and the second neighbor operator (PN s ). BOT offers five options for PT, i.e., n-medium swap, n-large swap, n-medium inverse, n-large insert, and n-medium insert. In addition, BOT offers four options for PN ≡ (PN f , PN s ), i.e., (1-small inverse, 1-medium insert), (1-large swap, 1-large insert), (1medium swap, 1-medium insert), and (1-small swap, 1small insert).
In the names of the above-mentioned operators, the number in front of the hyphen sign indicates the number of repeated uses of the operator mentioned in back of the hyphen sign. For example, the n-medium inverse operator is to use the medium inverse operator n times on a permutation. In addition, the words small, medium, and large are used to restrict the value of v from h (note that the uses of h and v for operators are already reviewed in Section 2). Let h and v be two different random integers within [1, mn], where mn is the number of all operations in the BCJSP instance. e words small and medium then provide additional limitations on generating v as follows: v must be generated within

MID Algorithm.
MID is a population-based metaheuristic modified from MUPLA [16]. It is a channel to transfer A i and B i (where i = 1, 2, . . ., n) from TOP into BOT. However, a main function of MID is to be a parameter controller for BOT. At the t-th iteration, the MID's population contains N members, i.e., , pr g (t), p g (t)) represent a value combination of the BOT's input parameters PT, PN, PR, and P, respectively. Each of pt g (t + 1), pn g (t + 1), and pr g (t + 1) is updated from its old value via two opposite-direction vectors. e first vector's direction is toward the memorized best-found value, whereas the second vector's direction is away from it. Differently, p g (t + 1) is set to the final operation-based permutation returned from the BOT with C g (t)-given input-parameter values. e procedure of MID is presented in Algorithm 2, and its flowchart is presented in Figure 3. e following list presents the definitions of parameters and abbreviations used in Algorithm 2 and Figure 3. In addition, the transformation (i.e., decoding method) of each member of C g (t) is also given: (iii) Let C g (t) ≡ (pt g (t), pn g (t), pr g (t), p g (t)) represent the g-th member (where g = 1, 2, . . ., N) in the MID's population at the t-th iteration. In addition, let Score(C g (t)) stand for the performance score of C g (t). Note that the lower the performance score, the better the performance.
(iv) Let pt g (t) ∈ R represent the perturbation operator (PT) of BOT. Equation (1) is used to transform pt g (t) into PT. (v) Let pn g (t) ∈ R represent the ordered pair of the first and second neighbor operators (PN) of BOT. Equation (2) is used to transform pn g (t) into PN. (vi) Let pr g (t) ∈ R represent the probability of selecting the first neighbor operator (PR) of BOT.
Generate a subproblem of the being-solved BCJSP instance by specifying A i and B i (i = 1, 2, …, n).
Generate an initial P 0 by using PT on P.
If u ≤ PR, generate P 1 by using PN f on P 0 . Otherwise, generate P 1 by using PN s on P 0 .
Return P 0 and S 0 to MID.

No
No Generate Π 0 from P 0 . Construct S 0 by assigning the operations in the order given by Π 0 into a timetable.
Generate Π 1 from P 1 . Construct S 1 by assigning the operations in the order given by Π 1 into a timetable.

Complexity
In the transformation, let PR ← pr g (t) if 0 ≤ pr g (t) ≤ 1; in addition, let PR ← 0 if pr g (t) < 0, and let PR ← 1 if pr g (t) > 1. (vii) Let p g (t) represent the start operation-based permutation (P) of BOT, and let it be a member of all possible operation-based permutations. In the transformation, let P ← p g (t). (viii) For updating pt g (t + 1), let y pt and w pt be the controlling weights of the maximum magnitudes of the first and second vectors, respectively. However, if pt g (t) = pt best , let w pt be the controlling weights of the maximum magnitudes of both vectors. (ix) For updating pn g (t + 1), let y pn and w pn be the controlling weights of the maximum magnitudes of the first and second vectors, respectively. However, if pn g (t) = pn best , let w pn be the controlling weights of the maximum magnitudes of both vectors.
(x) For updating pr g (t + 1), let y pr and w pr be the controlling weights of the maximum magnitudes of the first and second vectors, respectively. However, if pr g (t) = pr best , let w pr be the controlling weights of the maximum magnitudes of both vectors.
(xi) Let P 0 and S 0 , respectively, stand for the final operation-based permutation and the final schedule returned from BOT. In addition, let Makespan(S 0 ) stand for the makespan of S 0 .
(xii) Let C best ≡ (pt best , pn best , pr best , p best ) and S best stand for the best C g (t) and the best S 0 , respectively, ever found by the population. In addition, let Score(-C best ) stand for the performance score of C best .
(1) Receive values of BOT's input parameters (i.e., PT, PN, PR, and P) from MID. In addition, receive A i and B i (where i � 1, 2, . . ., n) from MID. (2) To generate a subproblem of the BCJSP instance, let the start operation and the operation-precedence-relation direction be assigned to every job by using Steps 2.1 to 2.4.
Step 2.2. Otherwise, go to Step 3. (3) Generate an initial P 0 by using PT on P. en, transform P 0 into S 0 by using Steps 3.1 and 3.2.
(3.1) Generate Π 0 by changing the j-th repetition of the number i in P 0 into the operation listed in the j-th order of the job J i 's operation-precedence-relation chain. (Note that the job J i 's operation-precedence-relation chain is given in Step 2.) (3.2) Construct S 0 by assigning the operations in the order given by Π 0 (from left to right) into a timetable. In the timetable, each operation must be assigned to its predetermined machine at its earliest possible start time. (Note that the earliest possible start time of each operation is the maximum between the completion time of its immediate-predecessor operation in its job and the completion time of the current latest operation on its machine.) (4) Find a local optimal schedule by using Steps 4.1 to 4.3.  2) Construct S 1 by assigning the operations in the order given by Π 1 (from left to right) into a timetable. In the timetable, each operation must be assigned to its predetermined machine at its earliest possible start time.
In Algorithm 2, MID starts its procedure by receiving A i , B i (where i = 1, 2, . . ., n), and its input-parameter values (i.e., y pt , y pn , y pr , w pt , w pn , and w pr ) from TOP. MID assigns t ← 1 and Score(C best ) ← +∞; then, it generates C g (t) randomly. To solve a BCJSP subproblem specified by A i and B i , MID then starts a repeated loop by executing BOT N times. In the g-th execution (where g = 1, 2, . . ., N), BOT is executed with C g (t)-given parameter values to return P 0 and S 0 ; then, let Score(C g (t)) ← Makespan(S 0 ) and p g (t + 1) ← P 0 . If MID finds any C g (t) better than or equal to C best , then let this C g (t) and its corresponding S 0 become a new C best and a new S best , respectively. After that, MID completes C g (t + 1) by using the two opposite-direction vectors to generate each of pt g (t + 1), pn g (t + 1), and pr g (t + 1). If the stopping criterion is not met, MID assigns t ← t + 1 and starts the repeated loop's next round.
As mentioned earlier, there are two variants of MUL, i.e., the base-specification MUL (MUL-B) and the top-specification MUL (MUL-T). e difference between MUL-B and MUL-T in their MIDs is given as follows. In MUL-T, the input parameters (i.e., y pt , y pn , y pr , w pt , w pn , and w pr ) of its MID are controlled by TOP. is means MID in MUL-T is identical to Algorithm 2. Differently, these input-parameter values of MID in MUL-B are constants. e procedure of MID in MUL-B is thus modified from Algorithm 2 by removing y pt , y pn , y pr , w pt , w pn , and w pr from Step 1 and (1) Receive A 1 , A 2 , . . ., A n , B 1 , B 2 , . . ., B n , y pt , y pn , y pr , w pt , w pn , and w pr from TOP.
3) If g < N, let g ← g + 1 and repeat from Step 5.2. Otherwise, go to Step 6. (6) If the stopping criterion is not met, let t ← t + 1 and repeat from Step 4. Otherwise, return S best to TOP. ALGORITHM 2: e procedure of MID. 8 Complexity changing y pt , y pn , y pr , w pt , w pn , and w pr in Step 5.2 to constants. In this paper, the values of y pt , y pn , y pr , w pt , w pn , and w pr of MID in MUL-B all are set to 0.5, as mentioned again in Section 5.

TOP Algorithm.
Like MID, TOP is developed based on the framework of MUPLA [16]. e main function of TOP is to control the start operation and the operation-precedencerelation direction of every job in the being-solved BCJSP instance. As previously mentioned, A i and B i represent the start operation and the operation-precedence-relation direction, respectively, of the job J i (where i = 1, 2, . . ., n, and n is the number of all jobs in BCJSP). After assigning A i and B i , the BCJSP instance has become a JSP instance that is a subproblem of the BCJSP instance. In addition to the main function, TOP can control the MID's input parameters, i.e., y pt , y pn , y pr , w pt , w pn , and w pr , as its optional extra function.

Yes
No g < N?
Transform C g (t) into the values of PT, PN, PR, and P of BOT. Execute BOT with the given PT, PN, PR, P, A 1 , A 2 , …, A n , B 1 , B 2 , …, B n in order to receive P 0 and S 0 .
(viii) Let S best and Makespan(S best ) stand for the best schedule returned from MID and its makespan, respectively.
Transform ζ q (τ) into the values of A 1 , A 2 , …, A n , B 1 , B 2 , …, B n , y pt , y pn , y pr , w pt , w pn , and w pr . Execute MID with the given A 1 , A 2 , …,A n , B 1 , B 2 , …, B n , y pt , y pn , y pr ,w pt ,w pn , and w pr in order to receive S best .

Yes
No q < M?
In Algorithm 3, TOP starts its procedure by receiving information of a BCJSP instance from the user. TOP assigns τ ← 1 and Score(ζ best ) ← +∞; then, it generates ζ q (τ) randomly. After that, TOP starts a repeated loop by executing MID M times. In the q-th execution (where q = 1, 2, . . ., M), MID is executed with ζ q (τ)-given parameter values to return S best ; then, let Score(ζ q (τ)) ← Makespan(S best ). If TOP finds any ζ q (τ) better than or equal to ζ best , then let this ζ q (τ) and its corresponding S best become a new ζ best and a new Z, respectively. After that, TOP chooses to update each member of ζ q (τ + 1) by either the two opposite-direction vectors or the reinitialization. If the stopping criterion is not met, TOP assigns τ ← τ + 1 and starts the repeated loop's next round.
us, the procedure of TOP in MUL-B is modified from Algorithm 3 by removing c kq (τ) from Step 3; removing y pt , y pn , y pr , w pt , w pn and w pr from Steps 4.2 and 4.3; and removing c kq (τ + 1) and its generating equation from Step 5.2.

Results
e performance of the two proposed variants of MUL (i.e., MUL-B and MUL-T) was evaluated via an experiment on 53 BCJSP instances. ese BCJSP instances were modified from the well-known JSP instances, i.e., FT06, FT10, and FT20 instances of [17]; LA01 to LA40 instances of [18]; and ORB01 to ORB10 instances of [19]. e modification of each instance was done by letting the operation-precedence-relation chains of all jobs be circular and bidirectional. In this paper, let BCFT06, BCFT10, and BCFT20 represent the BCJSP instances modified from FT06, FT10, and FT20, respectively. Let BCLA01 to BCLA40 represent the BCJSP instances modified from LA01 to LA40, respectively. en, let BCORB01 to BCORB10 represent the BCJSP instances modified from ORB01 to ORB10, respectively. For each BCJSP instance, let its original JSP instance stand for the JSP instance later modified to become it. For example, FT06 is the original JSP instance of BCFT06.
Because of the BCJSP's novelty, no algorithms excepting MUL have intentionally been developed for BCJSP. us, to (1) Receive information of the being-solved BCJSP instance from the user.
(4.1) Let q ← 1. (4.2) Transform ζ q (τ) into the values of A 1 , A 2 , . . ., A n , B 1 , B 2 , . . ., B n , y pt , y pn , y pr , w pt , w pn , and w pr .  A 1 , A 2 , . . ., A n , B 1 , B 2 , . . ., B n , y pt , y pn , y pr , w pt , w pn , and w pr taken from Step 4.2. is is done for receiving S best from MID. (4.4) Let Score(ζ q (τ)) ← Makespan(S best ). (4.5) If Score(ζ q (τ)) ≤ Score(ζ best ), then let ζ best ← ζ q (τ), Score(ζ best ) ← Score(ζ q (τ)), and Z ← S best . Otherwise, generate α iq (τ + 1), β iq (τ + 1), and c kq (τ + 1) by below three equations, respectively (i � 1, 2, . . ., n and k � 1, 2, . . ., 6). Let u 1 and u 2 ∼ U[0, 1). Complexity evaluate the performance of MUL-B and MUL-T, their performance was compared with each other and with the performance of the existing JSP-solving algorithms. Without modifications, the existing JSP-solving algorithms can solve BCJSP as well. However, they hardly find good solutions for BCJSP. is is because, for each BCJSP instance, the solution space of its original JSP instance is just a subset of its whole solution space. Consequently, for each BCJSP instance, the JSP-solving algorithms cannot return better solutions than the optimal solution of its original JSP instance. is is the reason that the original JSP instance's optimal solution is used as the best possible result from all JSP-solving algorithms on each BCJSP instance. e settings of MUL-B and MUL-T for the experiment are summarized as follows: Reasons for the above-mentioned parameter settings are given as follows. For limiting MUL-B's and MUL-T's computational time, the population sizes of their MIDs and TOPs were set to 2, the smallest possible size. With the same reason, their MIDs were set to stop after their 10-th iterations. However, for avoiding premature stops, their TOPs were set to stop after 100 consecutive iterations without finding a better solution. For performing as well as MUPLA [16], the parameters y pt , y pn , y pr , w pt , w pn , and w pr of MID in MUL-B were set to 0.5. is made the equations in Step 5.2 of Algorithm 2 become identical to those of MUPLA [16]. e experiment's results on the 53 BCJSP instances are presented in Table 1. Terms and abbreviations used in Table 1 and in its discussion are defined as follows: (i) Let a solution and a solution value stand for a schedule and a schedule's makespan, respectively.
(ii) For each BCJSP instance, let its original JSP instance mean the JSP instance that was later modified to become it. For example, LA01 is the original JSP instance of BCLA01.
(iii) Let Ins column present the name of each BCJSP instance.
(iv) Let JSP Opt column present the optimal solution value of the original JSP instance of each BCJSP instance. e values in this column were given by published articles, e.g., [20,21].
(v) For each of MUL-B and MUL-T, let Best and Avg stand for its best final solution value and its average final solution value, respectively, over three runs.  Table 2 then summarizes the results shown in Table 1. In Table 2, the 53 BCJSP instances are classified into nine categories based on the numbers of machines (m) and the numbers of jobs (n). Terms and abbreviations used in Table 2 are defined as follows:       14 Complexity and the average %BD over 53 instances, respectively, from the first to the 350-th iterations. One obstacle of plotting each plot was that each algorithm was usually stopped before the 350-th iteration, as shown in Table 1. To deal with the obstacle, since the algorithms were stopped, the last values of %AD and %BD had been used in the plots until the 350-th iterations.  Table 1 denotes the optimal solution value of its original JSP instance. (Note that, for example, FT06 is the original JSP instance of BCFT06.) Rather than comparison with many JSP-solving algorithms, let JSP Opt be a representative of the best possible result from all existing JSP-solving algorithms on BCJSP. As shown in Table 1, MUL-B returns better solution values than JSP Opt on 32 instances, equivalent values on 20 instances, and worse values on one instance. is means MUL-B performs better than the best performance of the existing JSP-solving algorithms on 32 instances, has equivalent performance on 20 instances, and has worse performance on one instance. MUL-T returns better solution values than JSP Opt on 33 instances, equivalent values on 20 instances, and worse values on none of the instances.

Result Comparisons of MUL-B and MUL-T with Other
is means MUL-T performs better than the best performance of the existing JSP-solving algorithms on 33 instances, has equivalent performance on 20 instances, and has worse performance on none of the instances.
Note that, in Table 1, %JD, %BD, and %AD represent the percent deviations from UB of JSP Opt, Best, and Avg, respectively. One-sided paired t tests conclude that the population mean %BDs of MUL-B and MUL-T are both significantly better than the population mean %JD (with p values of 4 × 10 − 7 and 3 × 10 − 7 , respectively). Moreover, the population mean %ADs of MUL-B and MUL-T are also significantly better than the population mean %JD (with p values of 10 × 10 − 7 and 5 × 10 − 7 , respectively). As an  interpretation, the two variants of MUL outperform the existing JSP-solving algorithms on BCJSP.
A cause for the above-mentioned results is that MUL-B and MUL-T can both explore the whole solution space of the BCJSP instance, while the existing JSP-solving algorithms can explore only the original JSP instance's solution space. For each BCJSP instance, the solution space of its original JSP instance is just a small subset of its whole solution space. en, a BCJSP instance usually has multiple better solutions than the optimal solution of its original JSP instance. Consequently, MUL-B and MUL-T both possibly find better solutions than the original JSP instance's optimal solution, whereas the existing JSP-solving algorithms cannot. Tables 1 and 2, MUL-T performs slightly better than MUL-B in the average solution quality. Over 53 instances, Avg %BD of MUL-T (i.e., 0.41%) is slightly better than Avg %BD of MUL-B (i.e., 0.59%). Likewise, Avg %AD of MUL-T (i.e., 1.21%) is slightly better than Avg %AD of MUL-B (i.e., 1.36%). However, based on one-sided paired t tests, no sufficient evidence suggests that the population mean % BD of MUL-T is better than that of MUL-B (with p value of 0.24). In addition, no enough evidence suggests that the population mean %AD of MUL-T is better than that of MUL-B (with p value of 0.19).

Result Comparisons between MUL-B and MUL-T. As shown in
By counting the instances won in Table 1, the outperformance of MUL-T over MUL-B can be detected more clearly. On each instance, let MUL-T be judged to win MUL-B if the MUL-T's %BD is lower than the MUL-B's % BD, and vice versa. Over 53 instances, MUL-T wins MUL-B on 18 instances, draws on 26 instances, and loses on nine instances. As noticed, the number of instances won by MUL-T (i.e., 18) is twice of the number of instances won by MUL-B (i.e., 9). Although a proportion of drawn instances (i.e., 26 out of total 53) is very high, most of the drawn instances are small or easy to solve (e.g., the instances in the 5 × 10, 5 × 15, 5 × 20, and 10 × 30 categories in Table 2). To determine whether the total number of all instances won by MUL-T is greater than that by MUL-B, a one-sided binomial test was conducted at a significance level of 0.1. Let a sample size be the number of instances not drawn from the total 53 instances (i.e., 27). e test's result concludes that, from all not-drawn instances, the number of all instances won by MUL-T is significantly greater than that by MUL-B (with p value of 0.061).
As mentioned previously, the main difference between MUL-B and MUL-T is in their TOPs. e MUL-B's and MUL-T's TOPs both control the start operations and the operation-precedence-relation directions in BCJSP. However, only TOP of MUL-T additionally controls the MID's input parameters as the extra function. e outperformance of MUL-T over MUL-B abovementioned indicates that this extra function can enhance the performance of MUL. is means the MID's performance can be enhanced by using TOP to control its input parameters. Once the MID's performance has been enhanced, MID can provide better input-parameter values for BOT. Consequently, BOT can find better solutions.

Number of Iterations and Computational Time
Consumed. For MUL-B and MUL-T, the numbers of used iterations directly affect computational time spent. e more the number of iterations used, the longer the computational time consumed. Table 1 presents the average number of iterations and the average computational time of the three runs of each algorithm. For each instance, Avg Iters and Avg time columns present the average number of iterations and the average computational time, respectively, used until the stopping criterion is met. (Note that the stopping criterion was to stop when TOP could not find an improving solution within 100 consecutive iterations.) In parentheses, Avg Iters and Avg time columns show the average minimum number of iterations and the average minimum computational time, respectively, required to find the last improving solution. A summary of the data from Table 1 just-mentioned can be found in Table 2.
As mentioned above, the stopping criterion for each algorithm was to stop when its TOP could not find an improving solution within 100 consecutive iterations. e purpose of using this stopping criterion is to avoid a premature stop for each algorithm. However, it probably results in an unnecessary high consumption of the number of iterations and of computational time. For example, on BCLA34, MUL-B and MUL-T both find their best-found solutions at their first iterations; however, they have to proceed until the 101-st iterations. For computational time on BCLA34, the both algorithms find their best-found solutions within 10 minutes; however, they have to stop after around 11 hours. Such cases also happen on many other instances, not only BCLA34.
Because the given stopping criterion causes a very long computational time, the user should not wait until MUL-B and MUL-T meet their stopping criteria. e user can break off the algorithms' executions at any time to receive their current best-found solutions. To choose a breaking-off time, the user may use information from the values in parentheses of Avg Iters and Avg time columns in Table 1. Avg Iters column indicates that, on more than 50% of all instances, the algorithms find their last improving solutions within 55 iterations; on all instances excepting BCORB03, they find their last improving solutions within 170 iterations. Avg time column indicates that, on more than 50% of all instances, the algorithms find their last improving solutions within 4.5 minutes; on all instances, they find their last improving solutions within 145 minutes.
As suggested from Avg Iters column, MUL-B and MUL-T should be broken off during the 55-th to the 170-th iterations. In addition, as suggested from Avg time column, they should be broken off during the 4.5-th to the 145-th minutes. us, as a minimum requirement, the user should break off each algorithm at the 55-th iteration or the 4.5-th minute of computational time, whichever comes first. If an optimal or near-optimal solution is required, the user is suggested to break off each algorithm at the 170-th iteration or the 145-th minute of computational time, whichever comes first. Moreover, the user may decide to break off each algorithm at any iteration index during the 55-th to the 170th iterations or at any time during the 4.5-th to the 145-th minutes. e decision is made based on his trade-off between the computational time and the possibility of finding an improving solution. Note that the computational time in the above suggestions may be changed if the user's computer has a different specification from the computer used in this research.
6.4. Solution Improvement Rate over Iteration. Since started, Avg-%AD-over-iteration plots and Avg-%BD-over-iteration plots of MUL-B and MUL-T in Figure 5 have already been below Avg %JD (i.e., 8.09%). At their first iterations, Avg % AD of MUL-B, Avg %AD of MUL-T, Avg %BD of MUL-B, and Avg %BD of MUL-T are 6.72%, 6.67%, 5.03%, and 4.53%, respectively. Since then, the values of the four plots have still been reduced continuously. e four plots in the mentioned order finally become 1.36%, 1.21%, 0.59%, and 0.41%, respectively, at their final values. Obviously, all their final values are much lower than Avg %JD. is means MUL-B and MUL-T perform better than the JSP-solving algorithms on BCJSP because Avg %JD is the best possible result of the JSP-solving algorithms.
All given plots in Figure 5 behave similarly to each other in their patterns. ese plots can be divided into three periods based on their similar patterns. e first period of each plot, where the value is reduced very quickly, is approximately started from the first iteration to the 55-th iteration. e second period, where the value is reduced gradually, is approximately started from the 55-th iteration to the 170-th iteration. e third period, where the value is reduced hardly, is approximately started from the 170-th iteration onwards. After the 170-the iteration, the plot has become more and more stable. e patterns of the plots emphasize that the user should break off each algorithm during the 55-th to the 170-th iterations, where the number of more iterations is a trade-off for the higher possibility of finding an improving solution.

Conclusions
MUL is the multilevel metaheuristic developed to solve the job-shop scheduling problem with bidirectional circular precedence constraints (BCJSP). MUL consists of TOP, MID, and BOT algorithms in its top, middle, and bottom levels, respectively. TOP is the population-based metaheuristic developed to control the start operation and the operation-precedence-relation direction of each job in BCJSP. If requested, TOP can also control the MID's input parameters. MID is the population-based metaheuristic developed to control the BOT's input parameters. BOT generates a subproblem of the BCJSP instance, in the form of JSP, by using the start operations and the operation-precedence-relation directions given by TOP. BOT then acts as a local search algorithm to solve the generated subproblem. e population in MID is evolved by the feedback from BOT, while the population in TOP is evolved by the feedback from MID. In this paper, there are two proposed variants of MUL, i.e., MUL-B and MUL-T. ese two variants both use their TOPs to control the start operation and the operationprecedence-relation direction of each job. However, only MUL-T additionally uses its TOP to control the MID's input parameters. Because MUL-B and MUL-T were intentionally developed for BCJSP, they perform much better than the existing JSP-solving algorithms on BCJSP. When comparing the two MUL variants, MUL-T outperforms MUL-B slightly in the average solution quality and significantly in the number of instances won.

Data Availability
e data used to support the findings of this study are available from the author upon request.

Conflicts of Interest
e author declares that there are no conflicts of interest regarding the publication of this article.