CHAPTER 3 DEVELOPMENT OF HEURISTICS AND ALGORITHMS

Transcription

1 CHAPTER 3 DEVELOPMENT OF HEURISTICS AND ALGORITHMS 3.1 INTRODUCTION In this chapter, two new algorithms will be developed and presented, one using the Pascal s triangle method, and the other one to find more than one sequence. Pascal s triangle based algorithm is a simple heuristic that can be used to find more than one sequence having optimal/ near optimal makespans. For this purpose, the concept of dummy machine is used in combination with the proposed heuristic. The other algorithm is a dummy machine based one. This could be used with many other simple heuristics like CDS, Palmer, Gupta, RA to improve the makespan and to find more than one sequence having optimal/ near optimal makespans. 3.2 NEW HEURISTIC USING PASCAL S TRIANGLE In this section, a proposed simple heuristic based on the Pascal s triangle has been discussed. The elements of the triangle represent the weights allotted to different machines, which will be multiplied with their corresponding machining times of jobs and subsequently reduced to a two machines, n jobs problems. These problems can then be solved using the Johnson s algorithm PASCAL S TRIANGLE It is the triangular representation of the combinational elements of nc r, r=0,1.,n. Mathematically, nc r = n!/r!(n-r)!. A typical triangle can be as shown in Fig NEW HEURISTIC ALGORITHM BASED ON PASCAL S TRIANGLE Before stating the procedure, it will be appropriate to explain the situation, which resulted in this algorithm. On using the extended Johnson s algorithm, the 3 28

2 machines are reduced to 2 machines. This is done by adding the processing times of the first two machines of any job and assigning them to the first hypothetical machine, and those of the last two machines to the second hypothetical machine. 0C r 1 1C r 1 1 2C r C r C r C r C r Fig.3.1: Pascal s Triangle When considering a problem with more than three machines, it can be shown that each heuristic follows a certain procedure. For example, the RA Heuristic takes the sum of the products of the weights of a particular machine and the processing time of the corresponding machine of a particular job, and assigns them to the first hypothetical machine. But, the weights will be in the decreasing order. That is, m for the first machine and 1 for the last machine. The weights will be in the increasing order for the second hypothetical machine, that is, 1 for the first machine and m for the last machine. Gupta s Heuristic just adds the processing times of all the machines except the last one, and assigns the sum to the first hypothetical machine, and adds the processing times of all machines except the first one, and assigns it to the second hypothetical machine, for a particular job. The CDS Heuristic corresponds to the multistage use of Johnson s rule applied to a new problem formed from the original problem. At stage 1, t 1 ji = t j1 and t 1 j2 = t jm In other words, Johnson s rule is applied to the first and m th operation and the intermediate operations are ignored. At stage 2, t 2 j1 = t j1 +t j2, t 2 j2 = t jm +t j,m-1 29

3 That is, Johnson s rule is applied to the sum of the first two and the last two operation processing times. In general, at stage I, For each stage, i (i=1, 2 m-1), the job order obtained is used to calculate a makespan for the original problem. After m-1 stages, the best makespan among the m-1 schedules is identified (some of the m-1 sequences may be identical). These Heuristics were studied; once a trial was made to reduce the m machine problem in to a two machine problem. Let us consider, for simplicity, one job to be processed in 8 machines, from A to H with processing times a to h respectively. That is, the two adjacent processing times are added together to get another time and in this process, one machine gets reduced at each level. In a similar way, the process is continued for all the jobs and the problem will be reduced to a n jobs and 2 machine problem, which can conveniently be solved using Johnson s Algorithm. In the above procedure, at each stage, it may be noted that the coefficients of the processing times in each element are nothing but the members of a Pascal s Triangle for nc r, r=0, 1., n. That is, for m number of machines, the coefficients are the members of (m-2)c r in the final stage. The new algorithm based on the Pascal s triangle can be presented as follows: Step 1. : Let n number of jobs be machined in m machines. It is assumed that all jobs are available for processing at time zero. At any time, each machine can process at the most one job, and each job can be processed on at the most one machine Step 2. : From the Pascal s Triangle, select the elements pertaining to (m-2)c r. Step 3. : For each job, multiply the machining times with the corresponding Pascal s Triangle elements and add them together ; for P i1, the last 30

4 machine is left out and for P i2, the first machine is left out, i=1,2,,n. The processing times of the two hypothetical machines can also be represented in a matrix form: = X Step 4. : Now, the problem is reduced to n jobs and 2 machine and then the optimum / near optimum makespan is determined, by using the data of the original problem using Johnson s Algorithm. Machine A B C D E F G H Job-I a b c d e f g h Now, the machines are reduced to 7 with processing times as shown: a+b b+c c+d d+e e+f f+g g+h and to 6 machines, a+2b+c b+2c+d c+2d+e d+2e+f e+2f+g f+2g+h and to 5 machines, a+3b+3c+d b+3c+3d+e c+3d+3e+f d+3e+3f+g e+3f+3g+h and to 4 machines, a+4b+6c+4d+e ; b+4c+6d+4e+f ; c+4d+6e+4f+g; d+4e+6f+4g+h and to 3 machines, a+5b+10c+10d+5e+f ; b+5c+10d+10e+5f+g ; c+5d+10e+10f+5g+h and finally to 2 machines with processing times, a+6b+15c+20d+15e+6f+g and b+6c+15d+20e+15f+6g+h. 31

5 Note: If m=2, the procedure is reduced to Johnson s algorithm and If m=3, the procedure is reduced to the extended Johnson s algorithm straight away. The flow chart for the algorithm is presented below. Codes were generated in MATLAB for the purpose of validating the algorithm using benchmark problems. Start Jobs=n Machines=m Yes m 3? No Pascal s Triangle Elements for (m-2)c r = X Johnson s Algorithm n Jobs, 2 Machines Sequence Make Span End Fig.3.2: Flow Chart for Pascal s Triangle based Algorithm 32

6 3.2.3 DEMONSTRATION OF THE NEW HEURISTIC ALGORITHM To demonstrate the new heuristic, an example described by Panneerselvam (2005), as mentioned in Table 3.1 is considered. There are 4 jobs to be processed in 4 machines with the corresponding processing times. Table 3.1: Example to illustrate the new Heuristic Algorithm in M/C Job I II III IV Step 1 : Step 2 : n=4 and m=4. (m-2)c r row has to be selected from the Pascal s Triangle. That is, 2C r is selected and the elements are :1 2 1 Step 3 : Job no. 1: t 11 = 1(4)+2(3)+1(7) = 17 and t 12 = 1(3)+2(7)+1(8) = 25 That is, the machining times are multiplied with the corresponding Pascal s Triangle elements and added together; for t11, the last machining is left out and for t12, the first machining time is left out. For Job no. 2: t 21 = 1(3)+2(7)+1(2) = 19 and t 22 = 1(7)+2(2)+1(5) = 16 For Job no. 3: t 31 = 1(1)+2(2)+1(4) = 09 and t 32 = 1(2)+2(4)+1(7) = 17 For Job no. 4: t 41 = 1(3)+2(4)+1(3) = 14 and t 42 = 1(4)+2(3)+1(2) = 12. Step 4: Now, the problem has been reduced to a 2 machine problem as shown in Table 3.2, and using the Johnson s algorithm the optimal sequence is computed. 33

7 Table 3.2: Four machine problem reduced to a two machine problem Job M/C I M/C II And, the sequence obtained is: with a makespan of 30 time units. If Palmer s slope index method is applied, a sequence of is found to be the optimal one. If Gupta s Heuristic is used, a sequence of with a makespan of 31 time units is obtained, which is not optimal. If RA Heuristic is used, a sequence of with a makespan of 31 time units is obtained, which is not optimal. If CDS Heuristic is used, a sequence of with a makespan of 30 time units is obtained, which is optimal. This example shows that the new proposed heuristic gives the optimal sequence along with Palmer s method and CDS Heuristics, for the given problem. 3.3 ANALYSIS OF A FEW STARTING SEQUENCES Many classic heuristics consider only the processing time and give the result using different approaches. As all are aware of, the heuristic procedures are approximate methods and the PFSP is NP hard. Hence, it cannot be explicitly stated that a particular Heuristic can always report an optimal/ near optimal solution. The overall performance is assessed using a set of benchmark problems totaling 120 in number proposed by Taillard (1993). The processing time varies from 1 to 99 time units, and generated using a random number generator for a given seed. Codes were generated in MATLAB R2008a and the following nine cases were analyzed: 34

8 1. CDS original algorithm 2. Total idle time in the ascending order for all machines when a particular job is processed 3. Total idle time in the descending order for all machines when a particular job is processed 4. Total processing time in the ascending order for a particular job 5. Total processing time in the descending order for a particular job (NEH initial sequence) 6. Total Machine idle time + Total processing time (IT+PT), in the ascending order 7. Total Machine idle time + Total processing time, in the descending order 8. Ratio of machine idle time to total processing time (IT/PT), in the ascending order 9. Ratio of machine idle time to total processing time, in the descending order The jobs were scheduled based on the above and the makespans were computed. The method of computing the total machine idle time and total processing time is illustrated, using an example given in Table 3.3. Table 3.3: Example PFSP (5 machines, 5 jobs) Jobs Machine, M Processing of Job 1: 0-8 time units (M1) 8-13 time units (M2) time units (M3) time units (M4) time units (M5). 35

9 Total machine Idle Time, if job 1 is processed first: M1-0; M2-8; M3-13; M4-15; M5-23, and Total dle Time: ( ) = 59 time units. Similarly, Total Machine idle time when Job No. 2 is processed: 66 time units Total Machine idle time when Job No. 3 is processed: 42 time units Total Machine idle time when Job No. 4 is processed: 62 time units Total Machine idle time when Job No. 5 is processed: 55 time units Total processing time for finishing Job no. 1: ( ) = 32 time units and Total processing time for finishing Job no. 2: 31 time units Total processing time for finishing Job no. 3: 22 time units Total processing time for finishing Job no. 4: 31 time units Total processing time for finishing Job no. 5: 34 time units The total machine idle time array for the problem is, [ ] for the jobs from 1 to 5 respectively. Similarly, the total processing time array is [ ]. In the algorithm using the ratio of the machine idle time to the total processing time (IT/PT), in the ascending order (serial number 8 above), the ratio array is [ ]. The ratio array is sorted in the ascending order and a sequence of ( ) with a makespan of 66 time units (Table 3.4) is obtained. In the similar way, other procedures can easily be converted into algorithms for computing the sequence and corresponding makespan. 120 numbers of problem instances proposed by Taillard are used for the complete analysis of all the nine heuristic procedures. Initially, all the procedures were tested for the makespan requirement. The complete results are presented for the first and last sets of problem instances in the Chapter, Results and Discussion (Tables 5.5 and 5.6). MS1 represents the makespan obtained using the first procedure, the CDS algorithm and so on. It was found that the CDS and the algorithm based on the ratio of the machine idle time to the total processing time in the ascending order perform better, in most of the cases for the makespan objective. 36

10 Table 3.4: Makespan for the sequence Machines Job ANALYSIS OF THE JOB INSERTION TECHNIQUE FOR DIFFERENT INITIAL SEQUENCES Framinan et al. (2003) considered twenty two different approaches for the indicator value and eight different sorting criteria, totaling 176 approaches for every objective function. Additionally, for every objective function, the RANDOM choice of a sequence was considered. For the 177 different approaches to generate initial sequences and for every combination of n = 5, 6, 7, 8, 10, 15, 20, 25, 30, 50, 75, 100 jobs and m = 5, 10, 15, 20, 25 machines, 100 problem instances were generated. Therefore, 6000 problem instances were considered. The processing times were drawn randomly as integers from a discrete uniform distribution between 1 and 99. It was concluded that for makespan, the best five-tuple consists of the NEH-insertion approach using the following five initial sequences: SUM PIJ / DECR (i.e. original NEH) Rank 1. SS SRA/2SRN / DECR Rank 3. SS SRS/RCN / DECR Rank 4. SS SRA/RCN / DECR Rank 5. RA C3 / INCR Rank 7. It may be noted that in the top four cases, the decreasing order proves to be better. SUM PIJ/ DECR: total processing time of the jobs, decreasing order (This indicator value is exactly the one used in the original NEH approach.) 37

11 SS SRA/2SRN/ DECR: sum of the absolute residuals with negative residuals weighted double, no carryover, decreasing order SS SRS/RCN/ DECR: sum of the squared residuals with negative residual carryover, decreasing order SS SRA/RCN/ DECR: sum of the absolute residuals with negative residual carryover, decreasing order RA C3/INCR: sum of possible waiting time of jobs and idle time of machines, increasing order Though the indicator values and sorting sequences are unlimited, the important ones were covered by Framinan et al. In this analysis, initially, twenty three starting sequences have been considered, combining the total processing time and the total machine idle time. In all the cases, the insertion technique is used. However, unlike the original NEH which selects the first two jobs as an initial sequence, the first & last jobs, the middle two jobs and the last two jobs are also considered for the analysis. 1. NEH original Algorithm (first two jobs) 2. NEH1 (first & last jobs) 3. NEH2 (middle two jobs) 4. NEH3 (last two jobs) 5. Total dle Time + Total Processing Time- DESC (first & second jobs) 6. Total dle Time + Total Processing Time- DESC (first & last jobs) 7. Total dle Time + Total Processing Time- DESC (middle two jobs) 8. Total dle Time + Total Processing Time- DESC (last two jobs) 9. Total dle Time-DESC (first two jobs) 10. Total dle Time-DESC (first & last jobs) 11. Total dle Time-DESC (middle two jobs) 12. Total dle Time-DESC (last two jobs) 13. Ratio-ASCE (first two jobs) 14. Ratio-DESC(first two jobs) 38

12 15. Total dle Time-ASCE (first two jobs) 16. Ratio-ASCE (first & last jobs) 17. Ratio-DESC (first & last jobs) 18. Total dle Time-ASCE (first & last jobs) 19. Total dle Time + Total Processing Time- ASCE (first & second jobs) 20. Total dle Time + Total Processing Time- ASCE (first & last jobs) 21. Total dle Time-ASCE (middle two jobs) 22. Total dle Time + Total Processing Time- ASCE (middle two jobs) 23. Ratio-DESC (last two jobs) [Ratio= total machine idle time/total processing time] Table 3.3 in the previous section is again considered here. The total machines idle time when a particular job is being processed, and the total processing time for processing a job are calculated. Taillard (1993) and Ruben Ruiz s (2009) benchmark problems available on the web page for the research group "Sistemas de Optimización Aplicada SOA" or Applied Optimization Systems: are used for the analysis. The Taillard benchmark is composed of 12 groups of 10 instances each, totaling 120 instances. Each group is characterized by a combination of n and m values (n m). The groups are {20, 50, 100} {5, 10, 20}, 200 {10, 20} and As this is incomplete as on date, in the sense that some combinations of n and m are missing, the Ruben Ruiz problems are also used in addition. They were developed originally for the no-idle flow shop scheduling problem and are adapted for our permutation flow shop scheduling analysis. The benchmarks have 250 instances with 17 combinations of n = {50, 100, 150, 200, 250, 300, 350, 400, 450, 500} and m = {10, 20, 30, 40, 50}. There are five replicates per combination. The processing times are uniformly distributed in the range [1, 99], similar to the Taillard instances. The codes were generated in MATLAB and run in a i5 PC with 4 GB RAM. 39

13 3.5 NEW ALGORITHM TO FIND MORE THAN ONE SEQUENCE In the shop floor, having multiple processing sequences help the planning engineer to re-schedule the jobs in case of any constraints. Also, to enforce effective implementation, the procedure should be a simple one. The proposed algorithm using the concept of dummy machine can be used with many simple heuristics to achieve this DUMMY MACHINE The dummy machines have a processing time of zero for all jobs. This machine is introduced initially before the first machine, and an optimal or near optimal sequence will be determined. Secondly, the dummy machine with zero processing times will be introduced between the first and second machine, and another optimal or near optimal sequence will be determined and the procedure continues. Altogether, (m+1) sequences will be computed and they will be evaluated for the optimality in terms of makespan requirement. This concept may be used in other popular heuristics, like RA, Palmer, Gupta, and the CDS Heuristics to find more than one optimal sequence or near optimal sequence NEW ALGORITHM BASED ON THE DUMMY MACHINE Procedure: Step 1. : Step 2. : Step 3. : Step 4. : Let n number of jobs be machined in m machines. It is assumed that all jobs are available for processing at time zero. The dummy machine is introduced as the first machine. The number of machines will be increased by one. The original algorithm has to be used to compute the sequence and the corresponding makespan. The dummy Machine is now introduced as the second machine, that is, between first and second real machines and the steps are repeated to obtain the second sequence and its makespan. 40

14 Step 5.: Step 6. : The process is repeated in the similar way, till the dummy machine is introduced as the (m+1) th machine. That is, after the m th machine, and all possible sequences and the makespans are obtained. The total number of sequences will be (m+1). All the sequences are to be evaluated for optimality in terms of the makespan. Different Heuristics follow different approaches to find the sequence having the optimal makespan. The popular heuristics proposed in the earlier days are the Palmer Slope Index method, Gupta s Heuristics, RA Algorithm, and the CDS Algorithm, which are still popular due to their simplicity. This concept can be effectively used in conjunction with these heuristics, to improve the makespan and additional sequences. The flow chart that was used is presented in Figure ANALYSIS OF THE EFFECT OF THE DUMMY MACHINES IN THE CLASSICAL HEURISTICS For the analysis, a five machines, three jobs flow shop problem is considered as shown in Table 3.5. P ij Processing time of job, i in the machine, j Table 3.5: A five machines, three jobs flow shop problem Job M 1 M 2 M 3 M 4 M 5 1 P 11 P 12 P 13 P 14 P 15 2 P 21 P 22 P 23 P 24 P 25 3 P 31 P 32 P 33 P 34 P 35 41

15 Start Jobs-n Machines-m Heuristics? (RA, CDS, Palmer, Gupta) M > 2? No Yes Pseudo Machine First Machine Sequence Make Span Pseudo Machine Last Machine? Yes No Move Pseudo Machine Towards Right Optimum Make Span Sequence End Fig.3.3: Flow Chart for the Algorithm based on Dummy Machine The effect of the dummy machines has been analyzed by two categories of algorithms. (i) Algorithms that do not reduce the n jobs, m jobs problem to a n jobs, two machine problem; 42

16 (ii) Algorithms that reduce the n jobs, m jobs problem to a n jobs, two machine problem DUMMY MACHINE CONCEPT WITH THE PALMER SI METHOD The formula for the Palmer slope index is, S i = (m-1) t i,m + (m-3) t i,m-1 + (m-5) t i,m (m-3) t i,2 (m-1) t i,1, where m is the total number of machines. For the original Palmer algorithm, the slope indices are computed as follows for the three jobs: S 1 = -4 P 11-2P P P 15 S 2 = -4 P 21-2P P P 25 S 3 = -4 P 31-2P P P 35 These indices will be arranged in the descending order to find the optimum sequence. Now, the dummy machine is introduced as the first machine as shown in Table 3.6. The number of machines goes up by one to 6. Table 3.6, Dummy Machine as the first machine JOB D M 1 M 2 M 3 M 4 M P 11 P 12 P 13 P 14 P P 21 P 22 P 23 P 24 P P 31 P 32 P 33 P 34 P 35 Now, the new indices are computed. S 1 = -3P 11 - P 12 + P P P 15 S 2 = -3P 21 - P 22 + P P P 25 S 3 = -3P 31 - P 32 + P P P 35 43

17 These are completely different from the original indices. Both the number of terms and the coefficients vary resulting in different values. Like the parent algorithm, these indices will be arranged in the descending order to find the optimum sequence. Now, the dummy machine is moved towards the right to become the second machine, as shown in Table 3.7. Table 3.7: Dummy Machine as the second machine Job M 1 D M 2 M 3 M 4 M 5 1 P 11 0 P 12 P 13 P 14 P 15 2 P 21 0 P 22 P 23 P 24 P 25 3 P 31 0 P 32 P 33 P 34 P 35 The new indices are: S 1 = -5P 11 - P 12 + P P P 15 S 2 = -5P 21 - P 22 + P P P 25 S 3 = -5P 31 - P 32 + P P P 35 In this case also, the coefficient of the first term differs from the previous case, and hence, the indices values vary from the previous ones. Like the parent algorithm, these indices will be arranged in the descending order to find the optimum sequence. Proceeding in a similar way, the dummy machine is moved towards the right till it becomes the last machine. The coefficients for the processing times of machines that come before the dummy machine change,, giving different indices. As the indices vary, the sequences get changed resulting in new sequences and makespans. They may be better, the same or even worse than the original values obtained from the parent algorithm. 44

18 DUMMY MACHINE CONCEPT WITH THE RA METHOD Many heuristics fall under this category. Three heuristics are analyzed. The RA algorithm assigns weights to the processing times depending on their relative position. The weights, w assign values from 1 to m. The processing times of the two hypothetical machines are then, t i1 = and t i2 = Now, the n jobs, m machines problem will be converted to a n jobs, two machine problem, that can be solved using Johnson s algorithm for optimal solutions. If the original algorithm is used for the same three jobs, five machines problem discussed above, the processing times in the two hypothetical machines can be computed as given in Table 3.8. Table 3.8: Three jobs five machines converted to three jobs two machines I 5P P P P 14 + P 15 P P P P P 15 5P P P P 24 + P 25 P P P P P 25 5P P P P 34 + P 35 P P P P P 35 Now, introducing the dummy machine as the first one, the total number of machines becomes six. The processing times in the two hypothetical machines can be computed as shown in Table

19 Table 3.9: Dummy machine as the first machine I 5P P P P 14 + P 15 2P P P P P 15 5P P P P 24 + P 25 2P P P P P 25 5P P P P 34 + P 35 2P P P P P 35 In this case, the processing times of the first hypothetical machine remain the same as the original times. However, the times for the second machine completely vary as the coefficients are changed. Now, if the dummy machine becomes the second machine, the processing times are computed, as given in Table Table 3.10: Dummy machine as the second machine I 6P P P P 14 + P 15 P P P P P 15 6P P P P 24 + P 25 P P P P P 25 6P P P P 34 + P 35 P P P P P 35 Here also, the first coefficients are different, resulting in different processing times. Proceeding in a similar way, the dummy machine is moved towards the right till it becomes the last machine. The coefficients for the processing times vary in a specific pattern, giving different processing times. The resultant problem can be solved using Johnson s algorithm for getting different sequences and their corresponding makespans. 46

20 DUMMY MACHINE CONCEPT WITH THE GUPTA S METHOD Table 3.11 indicates the processing times of the two hypothetical machines using the original Gupta s Algorithm: Table 3.11: Processing times of the hypothetical machines in Gupta s algorithm I P 11 + P 12 + P 13 + P 14 P 12 + P 13 + P 14 + P 15 P 21 + P 22 + P 23 + P 24 P 22 + P 23 + P 24 + P 25 P 31 + P 32 + P 33 + P 34 P 32 + P 33 + P 34 + P 35 In Gupta s algorithm, it can be seen that the dummy machine can be introduced either as the first or the last one. If it is introduced in between, it has no impact on the result. Case (i)-dummy as the first machine: I P 11 + P 12 + P 13 + P 14 P 11 + P 12 + P 13 + P 14 + P 15 P 21 + P 22 + P 23 + P 24 P 21 +P 22 + P 23 + P 24 + P 25 P 31 + P 32 + P 33 + P 34 P 31 +P 32 + P 33 + P 34 + P 35 47

21 Case (a)-dummy as the last machine: I P 11 + P 12 + P 13 + P 14 + P 15 P 12 + P 13 + P 14 + P 15 P 21 + P 22 + P 23 + P 24 + P 25 P 22 + P 23 + P 24 + P 25 P 31 + P 32 + P 33 + P 34 + P 35 P 32 + P 33 + P 34 + P 35 In both the cases, the coefficients remain the same, as unity. But, only the combinations of the different processing times change. In fact, due to this, the maximum number of possible sequences can be only two more, irrespective of the number of jobs. Now, using the popular Johnson s algorithm, the problem can be solved for optimality DUMMY MACHINE CONCEPT WITH THE CDS METHOD Parent CDS Algorithm: The CDS algorithm selects the sequence and optimum makespan from a set of (m-1) enumerations. Our problem is a five machine one and the number of enumerations is four, as analyzed in the following trials. Trial 1: I P 11 P 15 P 21 P 25 P 31 P 35 48

22 Trial 2: I P 11 + P 12 P 14 + P 15 P 21 + P 22 P 24 + P 25 P 31 + P 32 P 34 + P 35 Trial 3: I P 11 + P 12 + P 13 P 13 + P 14 + P 15 P 21 + P 22 + P 23 P 23 + P 24 + P 25 P 31 + P 32 + P 33 P 33 + P 34 + P 35 Trial 4: I P 11 + P 12 + P 13 + P 14 P 12 + P 13 + P 14 + P 15 P 21 + P 22 + P 23 + P 24 P 22 + P 23 + P 24 + P 25 P 31 + P 32 + P 33 + P 34 P 32 + P 33 + P 34 + P 35 The best sequence and the corresponding makespan can be selected out of the above trials. 49

23 Now, if the dummy machine is introduced as the first one and a total of (6-1) =5 trials will be carried out. Subsequently, the dummy machine will be moved towards the right, and in each case 5 trials will be analyzed. Let us consider only one situation; the dummy machine is the second machine. Now, five trials are carried out to reduce the problem and to compute the two processing times as follows: Trial 1: I P 11 P 15 P 21 P 25 P 31 P 35 Trial 2: I P 11 P 14 + P 15 P 21 P 24 + P 25 P 31 P 34 + P 35 Trial 3: I P 11 + P 12 P 13 + P 14 + P 15 P 21 + P 22 P 23 + P 24 + P 25 P 31 + P 32 P 33 + P 34 + P 35 50

24 Trial 4: I P 11 + P 12 + P 13 P 12 + P 13 + P 14 + P 15 P 21 + P 22 + P 23 P 22 + P 23 + P 24 + P 25 P 31 + P 32 + P 33 P 32 + P 33 + P 34 + P 35 Trial 5: I P 11 + P 12 + P 13 + P 14 P 12 + P 13 + P 14 + P 15 P 21 + P 22 + P 23 + P 24 P 22 + P 23 + P 24 + P 25 P 31 + P 32 + P 33 + P 34 P 32 + P 33 + P 34 + P 35 In this case, the trials go up by one, as the number of machines is six now. It may be noted that, the new trial one matches with the original trial one and trial five is the same as the original trial number four. All three other trials are different, yielding three new sequences. The best sequence and the corresponding makespan can now be selected out of the above trials NUMERICAL EXAMPLE FOR THE ANALYSIS For the analysis, a ten jobs ten machines problem is considered, as given in Table From the two categories of the heuristics, one from each category, the Palmer slope index algorithm and the RA algorithm are considered. 51

25 Table 3.12: 10 Jobs and 10 Machines Problem Job M/C 1 M/C 2 M/C 3 M/C 4 M/C 5 M/C 6 M/C 7 M/C 8 M/C 9 M/C [ PALMER SI METHOD The formula for the slope index is, S i = (m-1) t i,m + (m-3) t i,m-1 + (m-5) t i,m (m-3) t i,2 (m-1) t i,1, where m is the total number of machines. If Palmer s slope index method is applied to find a sequence, is obtained with a makespan of 99 time units Let S i indicate the slope index of Job i. The slope indices are: S 1 = 106, S 2 = 22, S3 = 94, S4 = -42, S 5 = 58, S 6 = 26, S 7 = -10, S 8 = 26, S 9 = -8 and S 10 =70, when the dummy machine is introduced as a first machine. The sequence obtained is with a makespan of 101 time units. Similarly, with a makespan of 105 time units, with a makespan of 104 time units, with a makespan of 103 time units, with a makespan of 99 time units, 52

26 with a makespan of 100 time units, with a makespan of 100 time units, with a makespan of 99 time units, with a makespan of 99 time units, with a makespan of 100 time units, with a makespan of 100 time units are obtained when the dummy Machine is introduced as the second, third.. and eleventh machine. That is, out of the (m+1) =11 additional sequences, eight are new sequences. The corresponding slope indices for the different jobs are: S 1 = 106, 96, 92, 86, 76, 62, 44, 30, 14, 10, -4 S 2 = 22, 18, 6, -2, -6, -18, -22, -32, -36, -48, -50 S 3 = 94, 92, 88, 84, 82, 76, 62, 58, 48, 40, 32 S 4 = -42, -56, -66, -78, -84, -88, -94, -98, -106, -110, -114 S 5 = 58, 46, 34, 32, 16, 4, -4, -10, -28, -40, -48 S 6 = 26, 20, 6, -4, -8, -12, -14, -24, -30, -34, -46 S 7 = -10, -24, -28, -36, -48, -58, -68, -70, -74, -84, -88 S 8 = 26, 16, 14, 0,-2, -16, -22, -34, -46, -50, -54 S 9 = -8, -22, -38, -50, -68, -70, -86, -90, -92, -104, -116 S 10 =70, 62, 56, 46, 30, 24, 22, 16, 0, -6, -20. It may be noted that the values of the indices steadily decrease from left to right, that is, as the dummy machine moves from the beginning towards the end. If the indices are added together, S 1 = 612, S 2 = -168, S 3 = 756, S 4 = -936, S 5 = 60, S 6 = -120, S 7 = - 588, S 8 = -168, S 9 = -744 and S 10 =300 and arranged in the descending order, the Palmer Sequence of with a makespan of 99 time units is obtained. 53

27 RA HEURISTIC Consider the other case where the algorithms first reduce the n jobs and m machines problems to a n jobs, 2 machines problem, and then use Johnson s Algorithm to find the optical sequence(s). One such method is RA Heuristics which has been used here to study the effect of the dummy machines in finding the optimal/near optimal sequences. The weights, w = 1 to m. The processing times of the two hypothetical machines are then, t i1 = and t i2 = When the original RA algorithm is used, the processing times are computed as shown in Table 3.13, and a sequence of with a makespan of 97 time units is obtained. Table 3.13: -RA algorithm I When the dummy machine is introduced as a third machine, the 10 jobs 10 machines problem is reduced in to a 10 jobs 2 machines problem, as shown in Table

28 Table 3.14: - Dummy as the first machine I [ Table 3.15: - Dummy as the tenth machine I When the dummy machine is the first machine, the sequence of with a makespan of 106 time units is obtained. 55

29 Similarly, with a makespan of 106 time units, with a makespan of 108 time units, with a makespan of 105 time units, with a makespan of 99 time units, with a makespan of 97 time units, with a makespan of 97 time units, with a makespan of 97 time units, with a makespan of 96 time units with a makespan of 94 time units, with a makespan of 94 time units are obtained, when the dummy machine is introduced as the second, third.. and eleventh machine. ie., out of the (m+1)=11 additional sequences, seven are new sequences and three are with makespans less than those of 97 time units obtained using the RA Heuristic. Table 3.15 shows the data for the specific case of the dummy machine inserted as the tenth machine. When all the eleven processing times of the two hypothetical machines are added together, the hypothetical processing times are obtained as indicated in Table Table 3.16: All hypothetical processing times added together I

30 And using Johnson s Algorithm, a sequence of with a makespan of 97 time units is obtained, which is the one obtained using the original RA Heuristic VALIDATION USING BENCHMARK PROBLEMS A set of benchmark problems starting from 5 machines, 20 jobs up to 20 machines, 500 jobs, and a total of 120 problems (Taillard, 1993) is available for permutation flow shop scheduling problems, which are being used by researchers to compare and validate the results with other known algorithms. The processing times vary from 1 to 99 time units, and they are generated using a random number generator for different seeds. In this work, those problems are used in the original algorithms and the makespans are computed. Dummy machines are introduced, and once again, by using the original algorithms, makespans are computed and analyzed for the improvement towards the lower bound. The results are tabulated and analyzed. In these tables, the terminology used: Seed Integer used for random number generation as given by Taillard LB Lower Bound, Optimal Makespan for a problem MS - Makespan, Total completion time for all jobs, using the original algorithm New MS New lowest Makespan after applying the dummy machines concept Movement, % Percentage improvement towards the Lower Bound Count Number of additional sequences having Makespans equal to or less than the makespan obtained using the original algorithm [max. (m+1) possible] The generation of random numbers is more critical and due care is paid to this. The MATLAB code for this is: function taillard (m, n) global ISEED data=zeros (m, n); a=16807; b=127773; c=2836; d=2^31-1; uint64 k; uint64 U; k=0; U=0; 57

31 ISEED1=ISEED; for ii=1: m for jj=1: n k=floor (ISEED1/b); ISEED1=a*mod (ISEED1, b)-k*c; if ISEED1<0 ISEED1=ISEED1+d; end U= (ISEED1/d); data (ii,jj)=floor(1+u*99); end end end 3.6 CONCLUSION This chapter discussed in detail, the development of a new heuristic algorithm based on the Pascal s triangle. Nine starting sequences using the total machine idle time in addition to the total processing time have been analyzed using the benchmark problems. Using the powerful job insertion technique, twenty three different initial sequences have been studied using different problem instances. A new algorithm based on the dummy machine concept has been proposed to find more than one sequence and its effects analyzed for different classical heuristics. After thoroughly analyzing a few existing heuristics including the NEH algorithm, further work has been done to develop different models with the objective of makespan minimization. This will be discussed in detail in the coming chapter. 58