chapter 3 development of heuristics and...

28

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.

3.2.1 PASCAL’S TRIANGLE

It is the triangular representation of the combinational elements of nCr,

r=0,1….,n. Mathematically, nCr = n!/r!(n-r)! . A typical triangle can be as shown in

Fig. 3.1.

3.2.2 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

29

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.

0Cr 1

1Cr 1 1

2Cr 1 2 1

3Cr 1 3 3 1

4Cr 1 4 6 4 1

5Cr 1 5 10 10 5 1

6Cr 1 6 15 20 15 6 1

… ………………………………….

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,

t1

ji = tj1 and t1

j2 = tjm

In other words, Johnson’s rule is applied to the first and mth operation and the

intermediate operations are ignored.

At stage 2,

t2

j1 = tj1+tj2, t2

j2 = tjm+tj,m-1

30

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 nCr, r=0, 1…., n.

That is, for m number of machines, the coefficients are the members of (m-2)Cr

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)Cr.

Step 3. : For each job, multiply the machining times with the corresponding

Pascal’s Triangle elements and add them together ; for Pi1, the last

31

machine is left out and for Pi2, 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.

32

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.

Yes

No

Fig.3.2: Flow Chart for Pascal’s Triangle based Algorithm

Jobs=n Machines=m

m≤3?

Pascal’s Triangle

Elements for

(m-2)Cr

Start

= X

Johnson’s Algorithm n Jobs, 2 Machines

Sequence Make Span

End

33

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

Processing Times in M/C

Job I II III IV

1 4 3 7 8

2 3 7 2 5

3 1 2 4 7

4 3 4 3 2

Step 1 : n=4 and m=4.

Step 2 : (m-2)Cr row has to be selected from the Pascal’s Triangle. That is, 2Cr

is selected and the elements are :1 2 1

Step 3 : Job no. 1: t11 = 1(4)+2(3)+1(7) = 17 and t12 = 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: t21 = 1(3)+2(7)+1(2) = 19 and t22 = 1(7)+2(2)+1(5) = 16

For Job no. 3: t31 = 1(1)+2(2)+1(4) = 09 and t32 = 1(2)+2(4)+1(7) = 17

For Job no. 4: t41 = 1(3)+2(4)+1(3) = 14 and t42 = 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.

34

Table 3.2: Four machine problem reduced to a two machine problem

Processing Times

Job M/C I M/C II

1 17 25

2 19 16

3 9 17

4 14 12

And, the sequence obtained is: 3-1-2-4 with a makespan of 30 time units.

If Palmer’s slope index method is applied, a sequence of 3-1-2-4 is found to be the

optimal one.

If Gupta’s Heuristic is used, a sequence of 3-2-1-4 with a makespan of 31 time units

is obtained, which is not optimal.

If RA Heuristic is used, a sequence of 3-2-1-4 with a makespan of 31 time units is

obtained, which is not optimal.

If CDS Heuristic is used, a sequence of 3-1-2-4 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:

35

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 Times

1 8 10 4 9 5

2 5 4 6 3 7

3 2 5 3 6 3

4 8 4 2 5 8

5 9 8 7 8 11

Processing of Job 1: 0-8 time units (M1) 8-13 time units (M2) 13-15 time

units (M3) 15-23 time units (M4) 23-32 time units (M5).

36

Total machine Idle Time, if job 1 is processed first: M1-0; M2-8; M3-13; M4-15; M5-

23, and Total Machine Idle Time: (0+8+13+15+23) = 59 time units. Similarly,

Total Machine idle time when Job No. 2 is processed: 66 time units




Total processing time for finishing Job no. 1: (8+5+2+8+9) = 32 time units and

Total processing time for finishing Job no. 2: 31 time units




The total machine idle time array for the problem is, [59 66 42 62 55] for the

jobs from 1 to 5 respectively.

Similarly, the total processing time array is [32 31 22 31 34].

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 [1.8438

2.1290 1.9091 2.0000 1.6176].

The ratio array is sorted in the ascending order and a sequence of (5 1 3 4 2)

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.

37

Table 3.4: Makespan for the sequence 5-1-3-4-2

Machines

Job Processing Times

5 0-5 5-12 12-15 15-23 23-34

1 5-13 13-18 18-20 23-31 34-43

3 13-17 18-24 24-27 31-33 .43-50

4 17-26 26-29 29-35 35-40 50-58

2 26-36 36-40 40-45 45-49 58-66

3.4 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.)

38

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 Machine Idle Time + Total Processing Time- DESC (first & second

jobs)

6. Total Machine Idle Time + Total Processing Time- DESC (first & last jobs)

7. Total Machine Idle Time + Total Processing Time- DESC (middle two

jobs)

8. Total Machine Idle Time + Total Processing Time- DESC (last two jobs)

9. Total Machine Idle Time-DESC (first two jobs)

10. Total Machine Idle Time-DESC (first & last jobs)

11. Total Machine Idle Time-DESC (middle two jobs)

12. Total Machine Idle Time-DESC (last two jobs)

13. Ratio-ASCE (first two jobs)

14. Ratio-DESC(first two jobs)

39

15. Total Machine Idle Time-ASCE (first two jobs)

16. Ratio-ASCE (first & last jobs)

17. Ratio-DESC (first & last jobs)

18. Total Machine Idle Time-ASCE (first & last jobs)

19. Total Machine Idle Time + Total Processing Time- ASCE (first & second

jobs)

20. Total Machine Idle Time + Total Processing Time- ASCE (first & last jobs)

21. Total Machine Idle Time-ASCE (middle two jobs)

22. Total Machine Idle 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: “http://soa.iti.es” 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 500× 20. 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.

40

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.

3.5.1 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.

3.5.2 NEW ALGORITHM BASED ON THE DUMMY MACHINE

Procedure:

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.

Step 2. : The dummy machine is introduced as the first machine. The number

of machines will be increased by one.

Step 3. : The original algorithm has to be used to compute the sequence and the

corresponding makespan.

Step 4. : 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.

41

Step 5.: 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).

Step 6. : 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 3.3.

3.5.3 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.

Pij – Processing time of job, ‘i’ in the machine, ‘j’

Table 3.5: A five machines, three jobs flow shop problem

Processing Times

Job M1 M2 M3 M4 M5

1 P11 P12 P13 P14 P15

2 P21 P22 P23 P24 P25

3 P31 P32 P33 P34 P35

42

No

Yes

Yes

No

Fig.3.3: Flow Chart for the Algorithm based on Dummy Machine

Start

Jobs-n

Machines-m Heuristics? (RA, CDS,

Palmer, Gupta)

M > 2 ?

Pseudo Machine First Machine

Sequence

Make Span

Pseudo Machine Last Machine?

Move Pseudo Machine

Towards Right

End

Optimum Make Span

Sequence

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;

43

(ii) Algorithms that reduce the ‘n’ jobs, ‘m’ jobs problem to a ‘n’ jobs, ‘two’

machine problem.

3.5.3.1 DUMMY MACHINE CONCEPT WITH THE PALMER SI METHOD

The formula for the Palmer slope index is,

Si = (m-1) t i,m + (m-3) t i,m-1 + (m-5) t i,m-2 +…- (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:

S1 = -4 P11 - 2P12 +2 P14 + 4 P15

S2 = -4 P21 - 2P22 +2 P24 + 4 P25

S3 = -4 P31 - 2P32 +2 P34 + 4 P35

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

Processing Times

JOB D M1 M2 M3 M4 M5

1 0 P11 P12 P13 P14 P15

2 0 P21 P22 P23 P24 P25

3 0 P31 P32 P33 P34 P35

Now, the new indices are computed.

S1 = -3P11 - P12 + P13 + 3P14 + 5P15

S2 = -3P21 - P22 + P23 + 3P24 + 5P25

S3 = -3P31 - P32 + P33 + 3P34 + 5P35

44

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

Processing Times

Job M1 D M2 M3 M4 M5

1 P11 0 P12 P13 P14 P15

2 P21 0 P22 P23 P24 P25

3 P31 0 P32 P33 P34 P35

The new indices are:

S1 = -5P11 - P12 + P13 + 3P14 + 5P15

S2 = -5P21 - P22 + P23 + 3P24 + 5P25

S3 = -5P31 - P32 + P33 + 3P34 + 5P35

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.

45

3.5.3.2 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

Processing Times

Machine I Machine II

5P11 + 4 P12 + 3P13 + 2P14 + P15 P11 + 2 P12 + 3P13 + 4P14 + 5P15

5P21 + 4 P22 + 3P23 + 2P24 + P25 P21 + 2 P22 + 3P23 + 4P24 + 5P25

5P31 + 4 P32 + 3P33 + 2P34 + P35 P31 + 2 P32 + 3P33 + 4P34 + 5P35

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 3.9.

46

Table 3.9: Dummy machine as the first machine

Processing Times


5P11 + 4 P12 + 3P13 + 2P14 + P15 2P11 + 3 P12 + 4P13 + 5P14 + 6P15

5P21 + 4 P22 + 3P23 + 2P24 + P25 2P21 + 3 P22 + 4P23 + 5P24 + 6P25

5P31 + 4 P32 + 3P33 + 2P34 + P35 2P31 + 3 P32 + 4P33 + 5P34 + 6P35

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 3.10.

Table 3.10: Dummy machine as the second machine

Processing Times


6P11 + 4 P12 + 3P13 + 2P14 + P15 P11 + 3 P12 + 4P13 + 5P14 + 6P15

6P21 + 4 P22 + 3P23 + 2P24 + P25 P21 + 3 P22 + 4P23 + 5P24 + 6P25

6P31 + 4 P32 + 3P33 + 2P34 + P35 P31 + 3 P32 + 4P33 + 5P34 + 6P35

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.

47

3.5.3.3 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

Processing Times


P11 + P12 + P13 + P14 P12 + P13 + P14 + P15

P21 + P22 + P23 + P24 P22 + P23 + P24 + P25

P31 + P32 + P33 + P34 P32 + P33 + P34 + P35

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:

Processing Times


P11 + P12 + P13 + P14 P11 + P12 + P13 + P14 + P15

P21 + P22 + P23 + P24 P21 +P22 + P23 + P24 + P25

P31 + P32 + P33 + P34 P31 +P32 + P33 + P34 + P35

48

Case (a)-Dummy as the last machine:

Processing Times


P11 + P12 + P13 + P14+ P15 P12 + P13 + P14 + P15

P21 + P22 + P23 + P24 + P25 P22 + P23 + P24 + P25

P31 + P32 + P33 + P34 + P35 P32 + P33 + P34 + P35

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.

3.5.3.4 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:

Processing Times


P11 P15

P21 P25

P31 P35

49

Trial 2:

Processing Times


P11 + P12 P14 + P15

P21 + P22 P24 + P25

P31 + P32 P34 + P35

Trial 3:

Processing Times


P11 + P12 + P13 P13 + P14 + P15

P21 + P22 + P23 P23 + P24 + P25

P31 + P32 + P33 P33 + P34 + P35

Trial 4:

Processing Times


P11 + P12 + P13 + P14 P12 + P13 + P14 + P15

P21 + P22 + P23 + P24 P22 + P23 + P24 + P25

P31 + P32 + P33 + P34 P32 + P33 + P34 + P35

The best sequence and the corresponding makespan can be selected out of the above

trials.

50

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:

Processing Times


P11 P15

P21 P25

P31 P35

Trial 2:

Processing Times


P11 P14 + P15

P21 P24 + P25

P31 P34 + P35

Trial 3:

Processing Times


P11 + P12 P13 + P14 + P15

P21 + P22 P23 + P24 + P25

P31 + P32 P33 + P34 + P35

51

Trial 4:

Processing Times


P11 + P12 + P13 P12 + P13 + P14 + P15

P21 + P22 + P23 P22 + P23 + P24 + P25

P31 + P32 + P33 P32 + P33 + P34 + P35

Trial 5:

Processing Times


P11 + P12 + P13 + P14 P12 + P13 + P14 + P15

P21 + P22 + P23 + P24 P22 + P23 + P24 + P25

P31 + P32 + P33 + P34 P32 + P33 + P34 + P35

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.

3.5.4 NUMERICAL EXAMPLE FOR THE ANALYSIS

For the analysis, a’ ten jobs ten machines’ problem is considered, as given in

Table 3.12. From the two categories of the heuristics, one from each category, the

Palmer slope index algorithm and the RA algorithm are considered.

52

Table 3.12: 10 Jobs and 10 Machines Problem

Processing Times

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/C10

1 5 2 3 5 7 9 7 8 2 7

2 2 6 4 2 6 2 5 2 6 1

3 1 2 2 1 3 7 2 5 4 4

4 7 5 6 3 2 3 2 4 2 2

5 6 6 1 8 6 4 3 9 6 4

6 3 7 5 2 2 1 5 3 2 6

7 7 2 4 6 5 5 1 2 5 2

8 5 1 7 1 7 3 6 6 2 2

9 7 8 6 9 1 8 2 1 6 6

10 4 3 5 8 3 1 3 8 3 7 [

3.5.4.1 PALMER SI METHOD

The formula for the slope index is,

Si = (m-1) t i,m + (m-3) t i,m-1 + (m-5) t i,m-2 +…- (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, 3-1-10-5-6-2-8-7-9-4 is

obtained with a makespan of 99 time units

Let Si indicate the slope index of Job ‘i’. The slope indices are:

S1 = 106, S2 = 22, S3 = 94, S4 = -42, S5 = 58, S6 = 26, S7 = -10, S8 = 26, S9 = -8 and

S10=70, when the dummy machine is introduced as a first machine.

The sequence obtained is 1-3-10-5-8-6-2-9-7-4 with a makespan of 101 time units.

Similarly,

1-3-10-5-6-2-8-9-7-4 with a makespan of 105 time units,




53






3-1-10-5-6-8-2-7-4-9 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:

S1 = 106, 96, 92, 86, 76, 62, 44, 30, 14, 10, -4

S2 = 22, 18, 6, -2, -6, -18, -22, -32, -36, -48, -50

S3 = 94, 92, 88, 84, 82, 76, 62, 58, 48, 40, 32

S4 = -42, -56, -66, -78, -84, -88, -94, -98, -106, -110, -114

S5 = 58, 46, 34, 32, 16, 4, -4, -10, -28, -40, -48

S6 = 26, 20, 6, -4, -8, -12, -14, -24, -30, -34, -46

S7 = -10, -24, -28, -36, -48, -58, -68, -70, -74, -84, -88

S8 = 26, 16, 14, 0,-2, -16, -22, -34, -46, -50, -54

S9 = -8, -22, -38, -50, -68, -70, -86, -90, -92, -104, -116

S10=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, S1 = 612, S2 = -168, S3 = 756, S4 = -936, S5 = 60, S6 = -120, S7 = -

588, S8 = -168, S9 = -744 and S10=300 and arranged in the descending order, the

Palmer Sequence of 3-1-10-5-6-2-8-7-9-4 with a makespan of 99 time units is

obtained.

54

3.5.4.2 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 3-10-1-5-9-8-6-2-7-4 with a makespan of 97 time

units is obtained.

Table 3.13: Processing Times-RA algorithm

Processing Times


277 328

205 191

139 202

237 159

289 294

203 193

239 190

227 213

328 266

235 260

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

3.14.

55

Table 3.14: Processing Times- Dummy as the first machine

Processing Times


284 376

213 219

142 230

249 183

307 335

213 219

248 220

233 247

343 305

242 298

[

Table 3.15: Processing Times- Dummy as the tenth machine

Processing Times


325 335

240 192

166 206

271 161

338 298

233 199

276 202

265 215

376 272

273 267

When the dummy machine is the first machine, the sequence of 3-6-2-8-10-1-

5-9-7-4 with a makespan of 106 time units is obtained.

56

Similarly,








3-1-5-9-10-8-6-2-7-4 with a makespan of 96 time units


3-1-5-10-9-8-6-2-7-4 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 3.16.

Table 3.16: All hypothetical processing times added together

Processing Times


3316 3932

2469 2292

1668 2424

2844 1903

3474 3528

2436 2310

2867 2290

2734 2583

3945 3165

2820 3120

57

And using Johnson’s Algorithm, a sequence of 3-10-1-5-9-8-6-2-7-4 with a

makespan of 97 time units is obtained, which is the one obtained using the original

RA Heuristic.

3.5.5 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;

58

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.

chapter 3 development of heuristics and...

Documents