TO MINIMIZE TOTAL TARDINESS
Submitted to the Graduate Faculty
of Texas Tech University in Partial Fulfillment of the Requirements for
the Degree of
DOCTOR OF PHILOSOPHY
ACKNOWLEDGMENTS
1 would like to express my profound appreciation to my committee chairman. Dr.
Milton L. Smith, for his guidance, encouragement, and financial support throughout the
process of my research. My gratitude goes to my other advisory committee members. Dr.
John E. Kobza, Dr. Surya D. Liman, Dr. William J. B. Oldham, and Dr. Yung-Nien
Yang, for their helpful advice. Furthermore, 1 am deeply indebted to Dr. Jatinder N. D.
Gupta, who has provided many useful suggestions. Moreover, I would like to thank Dr.
Sharon Myers for help with documentation preparation.
I would like to dedicate this dissertation to my parents, Sumet and Piyapom
Chantaravarapan, and my aunt Mayuree Chantaravarapan for their support and
encouragement. My appreciation also goes to my brothers and sister, Apirak, Attakom,
Apichart, and Sunan Chantaravarapan. Without their support, I could not have finished
this dissertation.
I INTRODUCTION 1
Introduction to Scheduling 1 Family Scheduling 5 Research Objectives 8 Notations 10
II LITERATURE SURVEY 11 Introduction 11 Single Machine Total Tardiness Problems 12
Optimization Algorithms 13 Heuristics 19
Problems with Sequence Dependent Setups 28 Family Scheduling 30
Total (Weighted) Flowtime/Maximum Flowtime 31 Maximum Lateness 37 (Weighted) Number of Tardy Jobs 40 Total Earliness and Tardiness about a Common Due Date 41
III FAMILY SCHEDULING PROBLEMS: SEQUENCE INDEPENDENT CASE 43
Problem Description 45 Problem Notations and Formulation 46
Notations 46 Formulation 46
Properties 49 Property 3.1 50 Property 3.2 52 Property 3.3 52 Property 3.4 52 Property 3.5 53
111
Heuristics 55 The Group Technology (GT) Heuristic 55 The Modified PSK (M-PSK) Heuristic 59 The Modified NBR (M-NBR) Heuristic 65 The Pairwise Interchange (PI) Heuristic 71 The M-NEH Heuristic 75 The Insertion and Swap (FN/SW) Heuristic 82 The MIN Heuristic 89 The COMBO Heuristic 90
Chapter Summary 91
Notations 96 Formulation 97
Initial Population and Population Size 103 Fitness Scaling Function and Selection Technique 105 Crossover Operator 107 Improving Heuristic 110 Reproduction (Replacement Technique) 111 Mutation Operator 113 Terminating Conditions 113
Chapter Summary 114
V EXPERIMENTS 115 Experimental Parameter Settings 115 Sequence Independent Setup Case 117
The Friedman Nonparametric Test 136 The Kruskal-Wallis Nonparametric Test 139
Sequence Dependent Setup Case 146 Genetic Algorithm Parameter Determination 148 The Kruskal-Wallis Nonparametric Test 164
Chapter Summary 168
REFERENCES 175
B GAMS CODE FOR PROBLEMS WITH SEQUENCE INDEPENDENT SETUPS 193
C GAMS CODE FOR PROBLEMS WITH SEQUENCE DEPENDENT SETUPS 200
D C++ CODE FOR PROBLEMS WITH SEQUENCE INDEPENDENT SETUPS: HEURISTICS 210
E C++ CODE FOR PROBLEMS WITH SEQUENCE DEPENDENT SETUPS: COMBO HEURISTIC 236
F C++ CODE FOR PROBLEMS WITH SEQUENCE DEPENDENT SETUPS: HYBRID GENETIC ALGORITHM 261
ABSTRACT
of its real-life applications. The family scheduling problems involve multiple job types
where jobs are classified into specific families by their similarity characteristics. Setup
occurs only when the two consecutive jobs are fi-om different families. An example of
application of family scheduling problems is the colored plastic injecfion machine.
Changing from one color to another color requires a setup. The purpose of this research
is to implement methodologies to minimize total tardiness on single machine problems.
However, the complexity of the proposed problem is NP-Hard. Seeking for optimal
solutions for large problem sizes within a reasonable time is quite questionable.
Therefore, this research aims to implement good heuristics that could provide good
solutions within a reasonable time.
This research can be divided into two main parts: problems with sequence
independent setups and problems with sequence dependent setups. Integer programming
models for both problems are proposed in this research. In case of problems with
sequence independent setups, three constructive heuristics and five improving heuristics
are proposed. The constructive heuristics are implemented to provide initial sequences for
improving heuristics.
In case of problems with sequence dependent setups, a hybrid genetic algorithm
(HGA) is presented. The implementation of the proposed HGA is discussed thoroughly in
this study. Furthermore, the proper genetic algorithm settings, such as crossover
probability and population size, can enhance the performance of the algorithm. Thus,
vi
prior to investigating the performance of the proposed HGA, a pilot study is performed to
determine proper genetic algorithm values.
Experiments for each problem can be divided into two parts: experiments with
small problem sizes, and experiments with large problem sizes. In the case of
experiments of small problem sizes, the solutions of heuristics/HGA were compared with
the solutions from CPLEX solver. In the experiments of large problem sizes, the
solutions of heuristics/HGA were compared among each other. Furthermore,
nonparametric tests, such as the Friedman tests and Kruskal-Wallis tests, were performed
to investigate the effect of parameters, such as number of jobs and number of families, on
the performance of heuristics/HGA.
on 60 job problems. 111
5.1 Average deviations of heurisfics: small problem sizes 119
5.2 Average CPU time of optimal solutions and heuristics: small problem sizes 120
5.3 Average deviafions of three constructive heurisfics grouped by job size, number of families, and setup type 122
5.4 Average deviations of three constructive heurisfics grouped by job size, number of families, and due date range parameter 123
5.5 Average deviafions of five improving heurisfics grouped by job size, number of families, and setup type 126
5.6 Average deviations of five improving heuristics grouped by
job size, number of families, and due date range parameter 127
5.7 Average CPU fime grouped by job sizes 130
5.8 SSE values of transformafion models 134
5.9 Results from the Friedman tests: five improving heurisfics 138
5.10 Results of the Kruskal-Wallis tests on job size factor: five improving heurisfics 140
5.11 Results of the Kruskal-Wallis tests on family size factor: five improving heurisfics 143
5.12 Resuhs of the Kruskal-Wallis tests on due date range factor: five improving heuristics 145
vm
5.13 Results of the Kruskal-Wallis tests on job size factor:
five improving heuristics. 146
5.14 Results of the Friedman test for 81 combinafion pilot study 150
5.15 Results of the Friedman test for 27 combination pilot study 152
5.16 Parameter settings of the hybrid genefic algorithm 153
5.17 Statistical summary for small problem size 154
5.18 Stafisfical summary for large problem size 155
5.19 Average deviation of the HGA grouped by job size, number of families, and due date range parameter 158
5.20 Average deviafion of the HGA grouped by job size,
number of families, and setup type 159
5.21 Summary of SSE values for five transformafions 162
5.22 Results of the Kruskal-Wallis test on job size factor 165
5.23 Resuhs ofthe Kruskal-Wallis test on family size factor 166
5.24 Results ofthe Kruskal-Wallis test on due date range parameter factor 167
5.25 Resuhs ofthe Kruskal-Wallis test on setup type factor 168
IX
1.1 Classification diagram of scheduling (Jordan, 1996, p. 11) 5
3.1 Property 3.1 diagram 50
3.2 Property 3.5 diagram 53
3.3 The PI heuristic diagram 73
3.4 The M-NEH diagram 77
3.5 The IN/SW heuristic diagram 83
3.6 The COMBO heuristic diagram 90
5.1 The M-NEH heurisfic and partial COMBO heuristic diagram 128
5.2 Comparison ofthe M-NEH and COMBO heurisfics: an example 129
5.3 Plot of average computational times grouped by problem sizes 130
5.4 Statistical summary of residuals of untransformed data v (sequence independent setups case) 133
5.5 Normality plot of residuals of untransformed data \' (sequence independent setups case) 133
5.6 Normality probability plot of residuals of transformed data 1 / ^ \ ' + 1 135
5.7 Normality tests of residuals of transformed data 1 /-/v + l 135
5.8 Plot of the effect of job size factor on performance of heurisfics 141
5.9 Plot ofthe effect of family size factor on performance of heuristics 143
5.10 Plot ofthe effect of due date range factor on performance of heurisfics 144
5.11 Plotoftheeffect of setup type factor on performance of heuristics 146
5.12 Plots ofrequired number of generafions and computation fime 156
5.13 Plot of average deviation percentage by the problem size 157
5.14 Statistical summary of residuals of untransformed data v (sequence dependent setups case) 160
5.15 Nomiality plot of residuals of untransformed data y (sequence dependent setups case). 161
5.16 Results of normality test for 1/-yjy , and 1/v transformafions 163
5.17 Normality plots for l / . / v , and l/i'transformations 163
XI
prompting manufacturers to reevaluate their manufacturing systems. Price and on-time
deli\ery are crucial factors for customers. Customers expect low priced products and on-
time delivery from manufacturers. From manufacturers' viewpoints, cost and customer
satisfaction are essential concems in the battle with other competitors. The key is to
produce and deliver products to customers at the right time while attempting to reduce
production costs as much as possible so that manufacturers can sell their products at a
lower price than their competitors. Scheduling plays a very important role in most
manufacturing and production systems as well as in most information-processing
environments. The need for scheduling also exists in transportation, distribution settings
and in service industries.
Scheduling is known as a decision-making process of allocating limited resources
over time in order to perform a collection of tasks for the purpose of optimizing certain
objective functions (Baker, 1974). Tasks can have differences in their priority levels,
ready times, and processing times. The objective functions could be, for example,
minimizing completion time, or minimizing the number of tardy jobs. There are two
issues commonly considered in scheduling problems: how to allocate jobs on machines
and how to sequence jobs on each machine. In other words, there are allocation decisions
and sequencing decisions. Before going further, it is worth noting the distinction between
1
a sequence and a schedule. A sequence usually corresponds to a permutation of the job
set or the order in which jobs are to be processed on a given machine. A schedule refers
to an allocafion of jobs within a more complicated setting of machines, which could
allow for preemptions of jobs by other jobs that are released at later points in time and
start/completion time.
Scheduling problems can be classified in many ways. A scheduling problem is
called static if all jobs are ready at time zero and do not change over time. By contrast, in
a dynamic scheduling problem, all jobs are not available simultaneously but become
available over time. Furthermore, the problem is called deterministic when processing
times and all other parameters are known and fixed in advance. Otherwise, it is called
stochastic. Scheduling problems also can be categorized into single-stage and multi-stage
systems. A single-stage system requires one operation for each job and involves either a
single machine or m parallel machines. Parallel machines can be sub-classified into three
cases: identical parallel machines in which all machines are identical; uniform parallel
machines in which each machine process occurs at different speeds; and unrelated
machines in cases in which each job has different processing times on each machine.
Multi-stage systems can be categorized into flow shop, open shop and job shop
systems. A flow shop system has m machines in a series and all jobs have the same
routine to be processed on each one ofthe machines. In open shop and job shop systems,
each job has its own machine route to follow. However, the difference between a job
shop and an open shop system is that a job in an open shop system can visit the same
machine more than once while the job in a job shop system can visit machines only once.
There are various performance measures considered in scheduling research. All
measures can be classified into two groups: regular measures of performance and non-
regular measures of performance. The key concept of regular measure is that the change
ofthe opfimal value depends on the change of at least one of a job's complefion fimes.
That is, decreasing a completion time of any job results in a lower performance measure
value. Otherwise, it is called a non-regular measure. The examples of regular measures
are total (mean) completion time, total (mean) flowtime, and total (mean) tardiness. The
instances of non-regular measures are related to due dates, such as the total of earliness
and tardiness about a common due date. Furthermore, according to Pinedo (1995), a
scheduling problem can be described by a triplet a | /? | /. The a field describes the
machine environment and contains only a single entry. The /? field provides details ofthe
processing characteristics and constraints and may contain more than one entry. The y
field contains the objective to be minimized and usually contains only one single entry.
Examples from all fields are presented in the book by Pinedo (1995).
In the early literature, most research paid attention to regular measure problems,
such as minimizing completion time or flow time. However, due to the tremendous
increase in world competition in the last two decades. Just In Time (JIT) production has
proved to be an essential requirement for world class manufacturing. On time delivery of
jobs has become one ofthe crucial factors for customer satisfaction. Scheduling plays an
important role in achieving this goal. The task ofthe manufacturers is to fulfill the
customers' orders before or right on their due dates. The due dates can be either
determined by customers, in which case they are called exogenous due dates, or by
manufacturers, in which case they are called endogenous due dates.
3
Scheduling systems have attracted numerous researchers and practitioners since
the eariy 1950s. In the past four decades, a considerable amount of theoretical research
has been done in the field of determinisfic scheduling (Pinedo, 1995). A significant
amount of research in deterministic scheduling has been devoted to finding efficient
polynomial time algorithms for scheduling problems. However, many scheduling
problems do not have a polynomial fime algorithm, leading to the emergence ofthe
concept of complexity. The trend of scheduling research is either to find a polynomial
algorithm or to show that the problem is intractable. It is also acceptable to implement
heuristic methods to find approximation solutions for a complex problem. There are
clearly tradeoffs between the quality of a solution and the required computational time.
Pinedo's (1995) summary ofthe complexity of some scheduling problems is shown in his
book.
Lee, Lei, and Pinedo (1997) noted that the new trend of scheduling theory is to
extend the results of classical algorithms to models that are more closely related to real
problems. Some studies are motivated by real industrial problems. However, most of
these problems are too complicated to formulate in mathematical models; therefore, it is
difficult to apply classical techniques, such as branch and bound and dynamic
programming algorithms, to solve these problems. Even if a mathematical model can be
formulated, obtaining a good solution for such complex problems within a reasonable
time is difficult. As a result, many researchers have been attracted to heuristics and search
techniques to seek for solutions to complex problems. Such approaches are easier to
implement than classical operations research techniques and they obtain good solutions
within a reasonable time.
For more detail, excellent surveys in deterministic scheduling problems are
provided by Graham et al. (1979), Baker (1974), Pinedo (1995), Anderson, Glass and
Potts (1997), and Lee et al. (1997).
Family Scheduling
Scheduling problems may be classified into two main categories: scheduling with
and without batching. In the last decades, the majority of research has been involved with
scheduling without batching. However, in the last few years, scheduling with batching
problems has appealed to numerous researchers because of its real life applications. One
common example is one in which machines require setups if they are to process jobs that
have different characteristics. The setup may require a tool-change or cleaning the
machine. Jordan (1996) presents the scheduling classification diagram in Figure 1.1.
Scheduling
batch processor
group technology splitting of families due to
flowtime minimization
Figure 1.1. Classification diagram of scheduling (Jordan, 1996, p. 11).
In batch scheduling, a machine can be either a discrete processor or a batch
processor. A discrete processor is a machine that can handle only one job at a time while
a batch processor is capable of processing several jobs at once. The simple example of a
batch processor is an oven, which can bake several cookies simultaneously. The
distinguishing characteristic ofthe batch processor is that all jobs in the same batch are
processed during the same period of time. Therefore, a primary concem ofthe batch
processor is to determine the jobs to be processed together. For a discrete processor, the
difference between general setup matrix and family scheduling is that, in the general
setup matrix problem, setups are assigned to every pair of jobs, while in the family
scheduling case, some setups can be ignored under some constraints, which is discussed
next.
In family scheduling, jobs are partitioned into families according to their
similarities. A job does not require a setup when following another job from the same
family. A setup time, known as a family setup time, is required when a job follows a
member of some other family. Alternatively, any family scheduling model can be viewed
as a single machine model with a sequence dependent upon setup times. Furthermore,
one family can be split into several batches, resulting in several setups.
A simplifying assumption for family scheduling is the requirement of exactly/
setups in the schedule, where/is the number of families. This implies that each family
can have only one setup. This assumption, namely the Group Technology iGT)
assumption, makes the problem more tractable. Under the GT assumption, the jobs in a
family must be scheduled consecutively. However, without this GT assumption, splitting
the processing of families, while increasing number of setups, may lead to improved
6
timeliness ofthe schedule. The following example gives the advantage of partitioning
families into batches. The instance consists of three jobs and two families. The first two
jobs belong to the first family and the last job belongs to the second family. The
processing times of jobs 1, 2, and 3 are 2, 10, and 6 minutes, respectively. The setup
times of both families are 1. Under the GT assumption, the optimal sequence is 1-2-3,
resulfing in a total flowtime of 36 minutes. However, if the first family is partitioned into
two batches as in sequence 1-3-2, the total flowtime ofthe new sequence is 34 minutes,
w hich is an improvement. Although solving a problem without the GT assumption may
generate a better solution, the difficulty ofthe problem increases rapidly.
When due-date-based criteria are taken into consideration, there are two variants
ofthe family scheduling model depending on when the jobs become available. Under
batch availability, a job in a batch becomes available only when all jobs in the same
batch have been processed. For example, a job can be moved to the next process once all
jobs in the same batch are processed. Another variant is job availability, alternatively
known as item availability, in which a job becomes available immediately after its
processing is completed. The item availability type can be also classified into two
groups: preemptive batching and non-preemptive batching. In case ofthe preemptive
batching type, idle time is allowed between two consecutive jobs from the same family,
while the setup time is required between two jobs when the idle time exists, in case ofthe
non-preemptive batching type.
The applications ofthe family scheduling model are introduced as follows. The
first application was in the manufacturing of steel pipes, presented by Ahn and Hyun
(1990). The manufacturer receives several specifications for an order such as KS (Korean
7
Standards), ASTM (American Society for Tesfing and Material), JIS (Japanese Industrial
Standards), or BS (British Standards). The task is to develop a rolling schedule that can
minimize the setups (usually between 3 to 20 hours) causing a bottleneck at the rolling
operation. The second example, presented by Potts and Van Wassenhove (1992),
involves a producfion line of colored plastics. Customer orders can be divided into color
groups. Setup times between color groups are necessary. Avoiding the setup fime process
can be done by processing all jobs in each color group together. However, a long
production run for one color group may result in lateness of jobs in other color groups.
Therefore, the schedule must be planned carefully to balance between production
efficiency and customer satisfaction. The last example is motivated by a situation in
which the labor force is a limiting resource and the worker must operate several machines
concurrently. The time that a worker takes to move from one machine to other machines
represents the setups, and jobs on each machine represent jobs from the same family. The
problem of one worker and two machines is studied by Sahney (1972).
Research Objectives
Scheduling against due dates has been a popular research topic in scheduling
literature for many years, h attracts both OR researchers and practitioners for two
reasons. First, the combinational nature ofthe due date scheduling problems poses a great
theoretical challenge to researchers to develop time efficient algorithms to solve such
problems in an elegant manner. Second, the results of due date scheduling problems have
significant practical value in the real world. It is obvious that failure to complete a job by
its promised fime gives rise to various penalfies.
This study aims to investigate the single machine family scheduling problem with
the objective of minimizing total tardiness. Tardiness value of a job is defined as 7, =
ma.xiO, C - di), where C, is the job's completion time, and di is the due date of job /.
According to the total tardiness criterion, there is no benefit gained from completing jobs
eariy and the tardy jobs incur penalty. The objective is to determine the sequence of jobs
when the setups depend on the job families. Note that the proposed problem is a
deterministic family scheduling problem with item availability type. The problem
description will be introduced in detail in Chapter 111. Since the total tardiness problem is
considered a NP-Hard problem (Du and Leung, 1990), the primary goal of this research is
to develop heuristics to obtain good solutions within a reasonable time.
The research outline is presented as follows. Recent literature related to tardiness
criteria and family scheduling problems is reviewed in Chapter 11. In Chapter III, the
single machine family scheduling problem is investigated with respect to the sequence-
independent setup time. The problem's formulation, description and proposed heurisfics
are presented. The proposed heuristics can be classified into two groups: the sequence
constructive heuristics, and the sequence improving heuristics.
In Chapter IV, additional analysis ofthe proposed problem is accomplished by
considering the sequence dependent setup case. This problem is more complicated than
the problems investigated in Chapter III. A hybrid genetic algorithm for this problem is
implemented. Hybrid genetic algorithms have been proven to be very effective in solving
NP-Hard problems. First, an integer programming model will be presented in Chapter IV,
and then the details ofthe implementation ofthe hybrid genetic algorithm are discussed.
The performance of all heuristics proposed in Chapters 111 and IV are examined in
Chapter V. The comparisons of heuristics are performed along with the analysis ofthe
effects of parameters, such as the due date tightness values and setup ranges, on the
performance of each heuristic. Conclusions and suggestions for future research are
provided in Chapter VI.
Notations
The following notations will be used throughout this study unless stated
otherwise.
n = total number of jobs = ni + n2+ ...+ «/
Pij = processing time of/' job in family /.
dij = due date of/'' job in family /.
C, = completion time of job /.
Q = completion time of/ ' job in family ;.
Tk = tardiness of job at position k, defined by Tk = maxiO, Ck - dk),
where Ck and dk are completion time and due date of a job at
position k.
s^ = setup fime of family i (sequence independent setup).
s.. = setup time when a job in family i precedes a job in family;
(sequence dependent setup).
Introduction
Currently, a major thrust in scheduling research is directed towards improving
performance with respect to due dates. Most ofthe literature on due-date criteria deals
with static deterministic scheduling problems. In other words, all jobs are known in
advance and are simultaneously available at time zero. Furthermore, the majority ofthe
literature on eariiness and tardiness problems has been involved with both single machine
and parallel machine problems, hi the last decade, the trend ofthe eariiness and tardiness
studies has been a concentration on problems with a common due date or common due
window. That is, all jobs have the same due date. However, from a practical point of
view, it is meaningful to have distinct due dates for every job. Unfortunately, the
problems with distinct due dates are very complicated.
A widely used performance measure in scheduling research is total tardiness.
Tardiness of job / is defined as T, = maxiO, C, - d,), where C, and di are completion time
and due date of job /', respectively. Under the tardiness criterion, there is no benefit
gained from completing jobs early, and a delay penalty incurs when a job is tardy. In this
chapter, we focus our literature survey on deterministic scheduling problems with total
tardiness criteria. Attention is limited to single machine scheduling only. This survey can
be grouped into two main parts: optimization algorithms and heuristic approaches. Then,
the literature review ofthe total tardiness problems with sequence dependent setups is
presented. Next, the family scheduling problems with respect to several criteria, such as
11
minimizing total flowtime, minimizing maximum lateness, minimizing number of tardy
jobs, and minimizing total eariiness and tardiness about a common due date are
presented.
Single Machine Total Tardiness Problems
One example of well known due date related criteria is lateness, Z,,. The lateness
of a job / can be defined as L, = C,. - J , . A lateness value can be posifive or negative,
depending on whether a job is completed before or after its due date. It is commonly
known that total lateness, L = '^L^ , can be minimized by using the Shortest Processing
Time (SPT) rule, and maximum job lateness and job tardiness is minimized by the
Earliest Due Date (EDD) order (Baker, 1974). Furthermore, tardiness of job / can be
defined as T, = maxiO, C, - d,). This implies that tardiness only occurs when a job is tardy.
A single machine total tardiness problem can be stated as follows: there are n
jobs, which all are available at time zero, to be processed without preemption on a
continuously available single machine. A machine can handle one job at a time.
Processing times and due dates of all jobs are known in advance. The objective is to
n
determine a sequence of the jobs in which total tardiness, V ^ / , is minimized. 1=1
Furthermore, if jobs have different priorities (weights), the job with a higher priority may
n
be sequenced first. Such a criterion aims to minimize total weighted tardiness, ^ " ' , / •
1=1
Minimizing total tardiness is often a more reasonable criterion than minimizing
total lateness, especially when the priority is to get jobs done on time, or as soon as
12
possible after their due dates. However, total tardiness is a much less tractable criterion,
and there is no simple rule known which can minimize total tardiness, ahhough some
special cases are known. These special cases are that the SPT schedule minimizes total
tardiness if all jobs are tardy, and the EDD sequence minimizes total tardiness when at
most one job has a positive value of tardiness. However, in other cases, many researchers
ha\e proposed algorithms and heuristics. Such approaches have demonstrated significant
improvement over exhaustive searches, in terms of computational time and problem size.
An excellent review of total tardiness has been provided by Koulamas (1994). He
surveyed algorithms and heuristics to minimize total tardiness with an emphasis on single
and parallel machine problems. New effective heuristics for single and parallel machine
cases were proposed. Furthermore, the worst-case analysis of a single machine case was
included in this survey.
Many researchers have provided excellent reviews ofthe scheduling problem with
due dates. In addition to Koulamas' (1994) outstanding reviews, Graham et al. (1979),
Anderson et al. (1997), and Lee, Lei, and Pinedo (1997) have given comprehensive
reviews of deterministic scheduling problems. Abdul-Razaq et al. (1990) have provided a
survey of dynamic programming and branch and bound algorithms for single machine
scheduling problems subject to minimize total weighted tardiness.
Optimization Algorithms
Total tardiness problems have been extensively studied. The single machine total
tardiness problem was first introduced by McNaughton (1959). The complexity ofthe
problem remained open until Du and Leung (1990) proved that the total tardiness
13
problem is NP-Hard in the ordinary sense. Furthermore, the single machine total
weighted tardiness problem was proved to be the unary NP-Hard problem (Lawler, 1977;
Lenstra et al., 1977). One major theoretical development for the total tardiness problem is
that ofthe dominance properties developed by Emmons (1969). Emmons' properties
determine the precedence relationship of some jobs in an opfimal sequence. The
properties restrict the size ofthe search in implementing effective algorithms, such as
branch and bound, or dynamic programming. His dominance properties establish
precedence relationships among jobs in an optimal schedule. The first and third
properties give necessary conditions for a job with a shorter processing fime to precede a
job with a longer one in an optimal schedule, while the second property gives necessary
conditions for a longer job to precede a shorter one in an optimal schedule. However, he
noted that the third property is rarely used in practice. Furthermore, Emmons proposed
enumerative algorithms in which dominance rules are used to restrict the search. Since
Emmons' research, most algorithms have applied Emmons' properties to initialize job
precedence in order to limit the number of searches, and then have applied heuristics and
algorithms. Later, Tansel and Sabuncuoglu (1997) presented a geometric view of
Emmons' properties.
The most effective branch and bound algorithm is that of Fisher (1976). Fisher
performed computational experiments for problems with up to 50 jobs. However,
Fisher's algorithm is not as effective as the dynamic programming algorithm of Schrage
and Baker (1978) which can also solve 50 job problems using much less computational
fime. Computational experience indicates that dynamic programming is more effective
than branch and bound algorithms for total tardiness problems. However, one
14
disadvantage of dynamic programming algorithms is that of storage requirements, which
make the algorithms impractical for large problems. To conclude, branch and bound
algorithms are limited by computational time and dynamic programming algorithms are
bounded by space requirements. Sen et al. (1983) proposed a more efficient algorithm
which only requires Oin') of computer allocation. The experiment showed that the
proposed algorithm is preferable to the dynamic programming approach of Scharge and
Baker (1978), in terms of limited memory resources. In addition to the tardiness penalty,
De et al. (1992) included the due date penalties in their study. A due date penalty is
incurred when a manufacturer quotes a long due date. The problem was proved to be NP-
Hard. However, under some special conditions, the problem can be solved in polynomial
time. The authors presented a mixed linear programming model, then solved the problem
with explicit enumeration, dynamic programming and an approximation method.
Koulamas (1994) commented that the most efficient optimal algorithm is the combined
dynamic programming/branch and bound algorithm developed by Potts and Van
Wassenhove (1982).
Sen and Borah (1991) proposed a branching algorithm based on the theories of
Rinnooy Kan et al. (1975). A branch of a tree is eliminated when the theories are
satisfied. The procedure in each branch continues until all jobs are included in a sequence
or the branch is eliminated; then, the total tardiness of each complete branch not being
eliminated is computed and the minimum is selected. They commented that Emmons'
rules cannot generate smaller sets of sequences than their proposed algorithm does. Ben-
Daya and Al-Fawzan. (1996) proposed a hybrid branch and bound algorithm to minimize
mean tardiness with subject to minimize the number of tardy jobs. The algorithm uses an
15
insertion algorithm to determine the optimal mean tardiness once the subset of tardy jobs
is specified. Kondakci et al. (1994) developed simple lower and upper bounds for
implementing a branch and bound algorithm. A lower bound is obtained by simplifying
the linear model into an assignment model. The experiment was performed with up to 35
job problems. However, Biskup and Piewitt (2000) criticized Kondakchi's work. They
noted that some aspects ofthe algorithm remain vague, and they presented a better
recursion to calculate lower bounds.
Lawler (1977) gave a powerful decomposifion theorem and used it to derive a
pseudo-polynomial dynamic programming algorithm which requires Oin'*Epi) time. To
explain the concept of decomposition, we assume that jobs are re-sequenced in EDD
order. A sequence is decomposed at joby in position k, wherey < k, resulfing in the
occurrence of two subproblems. What is important is to select the value ofk. A further
study showed a property which reduces a list of possible positions ofthe largest
processing time job in an optimal sequence. Chang et al. (1995) extended Lawler's work
by investigating additional decomposition properties. Potts and Van Wassenhove (1982)
furthered the decomposition approach by combining it with Schrage-Baker's dynamic
programming algorithm, which successfully solved problems up to 100 jobs with an
average CPU time of 27.07 seconds. A problem is partifioned into subproblems using the
decomposition concept, and then each subproblem is solved by Schrage-Baker's dynamic
programming algorithm. However, they commented that, first, the algorithm does not
generalize to solve the total weighted tardiness problem and, second, the decomposition
approach does not appear to be applicable to other scheduling problems.
Szwarc and Mukhopadhyay (1996) and Croce et al. (1998) developed new
decomposition rules and presented branch and bound algorithms. Both algorithms are
based on Emmons' conditions. The experiment showed that the algorithms can solve
problems with up to 150 jobs. Croce et al. (1998) referred to the combinafion of
Emmons' conditions (1969) and Lawler's decomposifion rule (1977). A new partifion
theorem based on Emmons' conditions is given. This algorithm also generalizes Lawler's
decomposition rule. With this theorem, a new decomposition rule applied to the smallest
due date job is derived and a double decomposition procedure is developed. This
algorithm is embedded into a branch and bound method which applies a new lower bound
based on the due date reassignment. This modified branch and bound method was tested
on problems with up to 150 jobs. Furthermore, the recent work by Tansel et al. (2001)
claims to solve problems with up to 500 jobs. The proposed algorithm is a depth-first
branch and bound algorithm under three major phases: the sequence construction,
decomposition, and fathoming test. Additionally, Szwarc et al. (1999,2001) proposed
new effective algorithms for problems with up to 300 jobs and 500 jobs, respectively.
The total weighted tardiness problem is known as a strongly NP-Hard problem
(Lenstra et al., 1977). To reduce the size of search, Rachamadugu (1987) presented the
key property for minimizing total weighted tardiness. He pointed out that, in any two
consecutive jobs, J and k, in an opfimal sequence, either the following condition holds or
there is an aUemative optimal solution which can be generated by interchanging two jobs.
The condifion is shown as follows:
^ l y ] / ^^^M -r-r, n^^ w^i^^[^ max((in|-C-pj^pO)
Pi,\ 1 -
Pw
17
1 _ . ' '*!
Pi
where [/] denotes the index of the job in position /. w, is the weight of job /, and C is the
complefion time ofthe last scheduled job before job / and 7.
There are several studies in branch and bound algorithms conceming the total
weighted tardiness problem. Shwimer (1972) presented a branch and bound algorithm to
minimize the total weighted tardiness. He presented a theorem based on Emmons'
conditions to consider the tardiness penalty in the order. Rinnooy Kan et al. (1975)
proposed another branch and bound algorithm in which a lower bound is obtained by
solving an assignment problem. The algorithm starts by performing an enumerative
search tree, and then eliminating some sequences using properties. The experiment was
performed on problems with up to 20 jobs. Picard and Queyranne (1978) considered the
problem a time dependent traveling salesman problem. They proposed a branch and
bound algorithm and tested it on 20-job problems. Potts and Van Wassenhove (1985)
proposed another branch and bound algorithm for the total weighted tardiness problem.
They used the multiplier adjustment method to generate a lower bound. Although their
lower bound is not as good as that of Picard and Queyranne's (1978), it is obtained very
quickly, that is, 0(«) steps. The algorithm is successfiil in solving problems with up to 40
jobs.
Arkin and Roundy (1991) formulated a problem to minimize the total weighted
tardiness. They assumed that tardiness penalties are proportional to processing time of a
job. They showed that the problem is NP-Hard and proposed a pseudo-polynomial time
algorithm for it. The proposed approach first decomposes jobs into subproblems, and then
puts them together later. Szwarc and Liu (1993) extended the work of Arkin and Roundy
(1991). A new decomposifion method was introduced and was found to be more efficient
18
than Arkin and Roundy's method. The algorithm was used to solve, optimally, 155 out of
320 problems with job sizes varying from 20 to 150. Akturk and Yildirim (1998)
presented a new lower bound for the total weighted tardiness problem. Akturk and
Ozdemir (2001) furthered their study by considering the unequal release date constraint.
Heuristics
As mentioned earlier, the complexity ofthe single machine total tardiness
problem is proved to be NP-Hard in the ordinary sense (Du and Leung, 1990), while the
total weighted tardiness is NP-Hard in the strong sense (Lenstra et al., 1977). Scheduling
a small number of jobs can produce an optimal solution. However, solving for optimal
solutions for the problems with a realistically large number of jobs is not pracfical in
industries. The problems seem to be noticeably difficult to deal with when problem size
is sufficiently large. Seeking good heuristics has become essential. From a practical
viewpoint, working on large-sized scheduling problems clearly demonstrates the need for
heuristic approaches.
Some well-known, quick and simple construction heuristics, which require at
most 0(« log n) computational time, are the Shortest Processing Time (SPT), the Shortest
Weighted Processing Time (SWPT) and the Eariiest Due Date (EDD) heuristics. The
SWPT rule sequences jobs with respect to non-decreasing values ofpt/wi. Baker (1974)
showed that the SPT (SWPT) sequence minimizes total (weighted) completion time.
Furthermore, when all jobs are tardy, the SPT (SWPT) rule also minimizes total
(weighted) tardiness. Therefore, if several tardy jobs exist, the SWST and SPT rules
should provide good solufions. In case ofthe EDD rule, it minimizes total tardiness when
19
there is only one tardy job. Therefore one might expect that the EDD sequence should
provide good solufions if there are only a few late jobs. Montagne (1969) proposed
sequencing the jobs in non-decreasing order of p. / ( ^ " p,. -d •) This rule usually
applies to the weighted tardiness problem. Baker (1974) proposed a heuristic, which
consists of SPT, EDD and Montague's (1969) rules, and selects the best sequence. Baker
and Bertrand (1982) developed a very effective mle for the mean tardiness problem. This
rule is implemented from Corollary 2.3 in Emmons study (1969). The rule first
determines Modified Due Date (MDD) value,d.'= max(<5?,,r + /?,), where t is the current
time, and then the next job with the earliest MDD value is selected. Rachamadugu (1987)
presented an adjacent pairwise condition to the weighted total tardiness problems and
noted that the MDD rule is the special case of their study. Naidu et al. (2002) proposed a
decomposition heuristic and showed the similarities between the decomposition heurisfic
and MDD rules.
Wilkinson and Irwin (1971) presented a heuristic method that utilizes an adjacent
pairwise interchange strategy in an attempt to minimize total tardiness. Considering two
adjacent jobs, say / andj, it is preferable to schedule the job with the earlier due date first
except when C + max(p„ pj) > max(d,. dj), where C is the total processing time of all jobs
before jobs / andj. Baker and Martin (1974) performed extensive computational tests of
SPT, EDD, WSPT and WI heuristics. Their study concluded that WI performed faster
and provided solufions, on the average, close to the opfimal solution.
Carroll's (1965) COVERT (Cost OVER Time) rule relies on the precedence
relations between jobs by applying Emmons' dominance conditions. The priority index ;r,
20
estimates the probability that job / will be tardy. The complexity of this heurisfic is 0(«-).
The rule states that, at any time t, schedules the next job according to the largest index
given by:
0 for P < d.
v 'here P is the total processing time and C is the completion time of scheduled jobs
before job /'.
The next heuristic is the Apparent Urgency (AU) heuristic (Morton,
Rachamadugu and Vepsalainen, 1984). The method selects the job with the highest
priority to be scheduled next, where the priority is given by
A U, = (w, / p, ) exp{- niaxfo, d.~P-pJ /(k'^)}
where kisa look-ahead parameter with respect to the tightness of due dates, p is the
average processing fime and P is the total processing time of jobs. The complexity of this
heuristic is 0( / r ) . Potts and Van Wassenhove (1991) performed a comparison experiment
of some previous heuristics. The instances ofthe construction methods are the Shortest
Weighted Processing Time (SWPT), the Eariiest Due Date (EDD) rules, the COVERT
(Cost OVER Time), the Apparent Urgency heuristic and the WI heuristic. They
concluded that the simple heuristics performed poorly, compared to the results from a
simulated annealing algorithm. Alidaee and Ramakrishnan (1996) combined AU and
COVERT rules together, namely CONVERT-AU rules. At any time /, the rule selects the
next job with the smallest priority index, ;r„ given by:
21
^ ^ p,/^^',)[l + /(v)] if0<<. <P ' [co if d. > P
where P is the total processing time and/is the real valued ftjnction such that/0) =0, and
.V is one ofthe following:
[max{ 0, d.-t- p, )] /(P-d), [max(0, d.-t- p. )] / kp. or [max (0. d.-t- p.)] / kc
where c is the average processing time of unscheduled jobs, k is a look ahead parameter,
and / is starting time before scheduling job /. The experiment was performed to solve the
total tardiness and total weighted tardiness problems against 14 other rules.
Klein and Ventura (1989) presented a heuristic to minimize total weighted
tardiness. It was claimed that their heuristic would solve both single machine and m
machine flow-shop problems. Intuitive analysis ofthe problem indicates that a job with a
larger penalty should be processed as early as possible, a job with a larger due date can be
processed later and that it may be better to process a job with a shorter processing time.
The results ofthe heuristic showed that the solution from the heuristic yields 70 percent
ofthe optimal solutions.
The traditional API algorithm is also found useful in minimizing other criteria
such as mean flowtime, weighted flow^time, maximum tardiness, mean lateness, weighted
mean lateness and maximum lateness (Conway et al., 1967). However, one disadvantage
ofthe traditional API algorithm is that the local optimum is usually reached. Thus, a
switching strategy is necessary in order to reach the global optimum. Fry et al. (1989)
proposed the modified Adjacent Pairwise Interchange (API) algorithm to minimize mean
tardiness in a single machine problem. They introduced three different switching
22
strategies, S; (start fi-om fi-ont to back), S2 (start fi-om back to front) and S3 (start with any
pair). Three sequences, such as SPT, EDD and SLK are considered with switching
strategies to implement the solution. The results showed that the modified API algorithm
provides much better solutions than the WI heuristic algorithm. According to the
experiment, API provided solutions which had total tardiness approximately 0.78 %
greater than the optimal.
Ho and Chang (1991) presented the Traffic Priority hidex (TPl). They define the
traffic congestion ratio (TCR) as
TCR - •=— , where p = dm Y,P' /"'' = S '
V ;=i J
In. V 1=1 J
The present number of machines, m, indicates that this heuristic can be used in a parallel
machine problem. Using TCR as a measure of shop congestion, the TPI heurisfic
computes a priority index 7?,, for each job i, as
d. p R, = " r f — ' - + r i - i ' r f ^ — - — .
maxfd, } maxf p.}
where w. - max\ mini 0.5 + ,1.0 ko.O \, and AT is a constant. '' [ 1 TCR \ \
Jobs are sequenced in an increasing order of./?,. After a complete schedule is constmcted,
an attempt is made to improve the schedule using the Adjacent Pairwise Interchanges
method (API).
Holsenback and Russell (1992) used Net Benefit of Relocafion (NBR) of the job
to determine positions of jobs in a sequence. The H-R heuristic uses the benefit gained
fi-om moving a job to the last position, causing improvement in tardiness on other jobs
23
located after the moved job. The experiment showed that this H-R heuristic outperformed
the API heurisfic of Fry et al. (1989), in terms of solufion quality and computafional
requirements. The complexity ofthe proposed heuristic is 0(/r'). Panwalkar, Smith and
Koulamas (1993) presented another well-known heuristic, the PSK heuristic, to minimize
total tardiness for a single machine problem. Jobs initially are sorted in SPT order (tie
broken with EDD). The algorithm makes /; passes from left to right and in the A:"' pass, a
job is selected and is put in the k"' posifion. The performance ofthe PSK heuristic was
compared against the Wilkerson-Irwin (WI), the Adjacent Pairwise Interchange (API),
and the Holsenback-Rusell (H-R) heuristics. The experiment showed that the PSK
algorithm performed better than the other heuristics. Furthermore, when due dates
become tight, the PSK heuristic tends to perform substantially better than the other
methods, with respect to computational time. However, Russell and Holsenback (1997a)
disagree with this conclusion. They discussed the work of Panwalkar et al. (1993), then
performed another experiment to demonstrate that their NBR heuristic outperformed the
PSK heuristic. They further modified their NBR heuristic which provided a better
solution than PSK and their original NBR heuristics (Russell and Holsenback, 1997b).
Alidaee and Gopalan (1997) claim that the Modified Due Date rule is generally
considered to be an efficient heuristic that deals with the tardiness problem and the PSK
heuristic is an implementation ofthe MDD rules.
Fadlalla et al. (1994) presented another quick heurisfic which they claimed
outperformed the WI heuristic, in terms of computational time and solution quality. The
proposed greedy algorithm-based heuristic starts with generating anxn matrix to record
the tardiness of all job pairs for the last two positions in the sequence. The complexity of
24
the heuristic is O(n^). The distinguishing characteristic ofthe proposed heuristic over the
WI rule is that it perfomis increasingly better as the problem size increases. Furthermore,
the well-known Moore's algorithm (1968) has provided an optimal solution for
minimizing the number of tardy jobs on a single machine scheduling problem. Suer and
Czajkiewicz (1992) modified the Moore algorithm (1968) to minimize total tardiness
while maintaining the number of tardy jobs to a minimum. However, with this modified
algorithm, the minimum number of tardy jobs is not guaranteed. The results ofthe
proposed heuristic in terms ofthe number of tardy jobs and total tardiness penalty were
compared with optimal solutions obtained from Moore's algorithm. The results showed
that the heuristic can obtain much better solutions in terms of total tardiness with a
slightly higher number of tardy jobs than the optimal solutions. Gupta and Ramnarayanan
(1996) also proposed an 0(« ") heuristic to minimize maximum tardiness with subject to
the minimum number of tardy jobs. The heuristic is based on Moore's algorithm and the
EDD rule. Dominance conditions are presented. The results, compared to the branch and
bound solutions, showed that the heuristic performed excellently. Duffuaa et al. (1997)
considered the problem of minimizing mean tardiness with objecfive to minimize the
number of tardy jobs. Their algorithm starts by using Moore's algorithm to obtain an
inifial sequence with the minimum number of tardy jobs. Then, an insertion process is
used to move the tardy jobs forward to minimize mean tardiness while maintaining the
number of tardy jobs. This is accomplished by comparing the slack time of eariy jobs
with the slack time of tardy jobs. The author also proved that the proposed algorithm can
provide an optimal solution.
25
Lai and Kuo (1996) presented an 0(n log n) Modified Due Date (MDD) mle
which satisfies local optimality and shows that the worst case performance ratio is n/2.
They use the index, /,(?) = max (0, t + pi - di) + d„ to select the next job, where a small
index value has a high priority. If ties occur, a job with the larger processing time is
selected if jobs are not tardy. If all jobs are tardy, a job with a smaller due date is
selected. If one job is tardy and another is not tardy, the tardy job is selected. They noted
that the MDD rule can be viewed as a modified SPT mle. Huegler and Vasko (1997)
compared several heuristics for the total weighted tardiness problem. These heuristics
include quick and dirty heuristics (EDD, SWPT, AU), descent method with zero
interchange, and a dynamic programming based heuristic.
Volgenant and Teerhuis (1999) improved the efficiency ofthe heuristics by
implementing the priority rule of Rachmadugu (1987). Four exisfing heurisfics
considered in this study are the ATC heuristic of Vepsalainen and Morton (1987), the
EDD rule, the Greedy heuristic of Fadlala (1994) and the WSPT rule. The priority rule of
Rachamadugu (1987) is stated as follows:
{l-[max(0,^[.] -?-P;,|)]/P(,,i)}w[,] ^ {l-[max(0,t/[,,i] -t -p^,,,^)]/p^,^}w^.^,\
Pi,] P[,>i]
According to their numerical experiment, the authors observed that the ATC
showed improvement in results, although the ATC heuristic is closely related to the
priority rule. The EDD rule is appropriate to problems with small tardiness. The greedy
heuristic generates best or second best schedules on average, both before and after
applying the priority rule, while the computational time is the highest. The WSPT mle is
the fastest heuristic, yet provides the worst quality results.
26
or genetic algorithm, have attracted numerous researchers. These methods have been
used to solve many complicated optimization problems successfully. Potts and Van
Wassenhove (1991) and Ben-Daya and Al-Fawzan (1996) developed simulated annealing
to solve total tardiness problems and mean tardiness problems, respectively. The
proposed approach of Ben-Daya and Al-Fawzan (1996) was compared with the API and
the NBR heuristics. The experiment showed that simulated annealing provided much
better solutions than the H-R and API heuristics and the solutions are within 1% ofthe
optimal solutions. Ben-Daya and Al-Fawzan (1997) presented a tabu search algorithm to
minimize mean tardiness for single machine problems. Adenso-Diaz (1996) combined
tabu search and simulated annealing techniques together to obtain better solutions.
Simulated annealing is used to generate an initial schedule, and then is implemented by
tabu search. Franca, Mendes, and Moscato (2001) implemented a genetic algorithm and a
memetic algorithm to deal with the total tardiness problem. Crauwels, Potts and Van
Wassenhove (1998) extended the work of Potts and Van Wassenhove (1991). They
created a new binary presentation to enhance solution performance. Heuristics, such as
descent, simulating annealing, threshold accepting, tabu search, and genetic algorithm,
were compared in this study in response to the type of representation and characteristic of
mn (single run/multi-run). The resuhs showed that, with time limitations, the genetic
algorithm with binary representation appears to be the best method. However, when a
long time is possible, a multi-run tabu search with permutafion is a good alternative.
27
Problems with Sequence Dependent Setups
Problems with sequence dependent setups have been shown to be strongly NP-
Hard (Lawler, 1982). One common simplification made in scheduling studies is to either
combine setup into processing fime or setups are ignored altogether. Although this
assumpfion may be reasonable for some manufacturing systems, sequence dependent
setup fimes cannot be ignored in other systems. According to a survey of industrial
schedulers by Panwalkar et al. (1973), 70% ofthe schedulers reported that some
operations they schedule are subject to sequence dependent setup fimes.
According to Rubin and Ragatz (1995), Emmons properties are no longer valid
when the sequence dependent setup time constraint is considered. Furthermore, the
traveling salesman problems seem to have some characteristics similar to the tardiness
problems with sequence dependent setup times. However, a noficeable difference is that
the traveling salesman problems consider only the absolute distance, while the total
tardiness problems also consider the starting job in the sequence.
In this section, we present some existing studies related to tardiness criteria and
sequence dependent setups condition. Lee, Bhaskaran, and Pinedo (1997) presented the
ATCS rule, which modifies the ATC rule (Ow and Morton, 1989), to minimize total
weighted tardiness problems on single machine problems. Addifionally, Lee and Pinedo
(1997) presented a dispatching rule and simulated annealing procedure for the multiple
idenfical machine problems to minimize the total weighted tardiness. The proposed
dispatching rule performs well when the schedule is fight, and is used to generate initial
sequence for the simulated annealing. Sun, Noble, and Klein (1999) presented a
28
Lagrangean relaxation based approach for single machine problems with release dates,
due dates, and sequence dependent setup times to minimize total weighted squared
tardiness. Their experiment indicated that the quality of solutions fi-om the proposed
approach is comparable to that of simulated annealing results, but required less
computational time. Asano and Ohta (1999) considered single machine problems with
shutdown and release time constraints, in addition to sequence dependent setups
constraint, to minimize the maximum tardiness.
Meta-heuristics have also attracted many researchers recently. Rubin and Ragatz
(1995) investigate the single machine to minimize the total tardiness using a genetic
algorithm. Furthermore, Tamimi and Rajan (1997) implemented a genetic algorithm for
parallel uniform machines with the objective of minimizing the sum of weighted
tardiness. Tan and Narasimhan (1997) implemented simulated annealing for single
machine problems. The experiment showed that simulated annealing can find good
solutions quickly. Tan et al. (2000) compared the performance of branch-and-bound,
genetic search, simulated annealing and random-start pairwise interchange in their paper.
The experiments suggested that simulated annealing and random-start pairwise
interchange can yield good solutions to a large combinatorial problem.
Parthasarathy and Rajendran (1997) studied the flowshop problem to minimize
mean weighted tardiness. A simulated annealing based heuristic was developed to obtain
initial sequence for the simulated annealing approach. Sun and Noble (1999) investigated
the job shop scheduling problem with release dates, due dates, and sequence-dependent
setup fimes with the objective of minimizing the weighted sum of squared tardiness. The
problem is decomposed into a series of single machine scheduling problems, and is
29
solved by a Lagrangian relaxation based approach. Balakrishnan et al. (1999)
investigated a uniform parallel machine problem to minimize the sum of earliness and
tardiness. An integer programming was presented, and the experiment was performed on
small problem size problems.
Familv Scheduling
Lately, the research in family scheduling has come to address real-life
applications. The trade-off involves balance of cost of minimizing total tardiness penalty
of a sequence against the cost of minimizing the number of setups in the production line.
As mentioned before, family scheduling is a special case of batch scheduling. In other
words, family scheduling is batch scheduling with job type constraints. Research in
family scheduling began in the late 1980s. Although batch scheduling problems have
been researched widely, literature in family scheduling problems is quite limited. Potts
and Van Wassenhove (1992) and Webster and Baker (1995) summarized research on
single machine family scheduling models. Liaee and Emmons (1997) reviewed recent
scheduling theories conceming multiple families of jobs on single and parallel machines.
Potts and Kovalyov (2000) provided a recent review on batch scheduling. Based on the
collected literature, the current literature in family scheduling problems is involved with
total (weighted) flowtime/maximum flowtime, maximum lateness, the (weighted) number
of tardy jobs, and total eariiness and tardiness about a common due date.
30
Total (Weighted) Flowtime/Maximum Flowtime
It is commonly known that if there is only one family or setup times are all zero
for multi-family problems, the SPT mle minimizes total flowtime, and the SWPT mle
minimizes total weighted flowtime. In the case of multi-family problems, a job sequence
in a batch can be scheduled optimally by these SPT or SWPT rules. Furthermore, when
setup times are large, all jobs in each family tend to sequence together in the same batch
in order to reduce the number of setups. These SPT and SWPT rules may provide good
solutions to problems.
Under the group technology assumption, total weighted flowtime problems are
efficiently solvable if setup times are sequence independent. However, in sequence
dependent setup time cases, the problem is NP-Hard, even when each family contains
only one job and all jobs have the same weight (Liaee and Emmon, 1997). Hitomi and
Ham (1976, 1977) derived a two-phase branch and bound approach to determine an
optimal solution with minimum makespan for single and multi-stage problems. Webster
and Baker (1995) proposed dynamic programming algorithms to minimize total weighted
flowtime and maximum lateness, when setups are sequence independent. The jobs within
a family are rearranged in WSPT order, while the batches are sequenced in the WSPT
order ofpk I Wk, whenp^ = 5* + ^"'^ p^^ and WA = ^"^^ w^., wherep^ and u^ are the total
processing time and weight of family k, respecfively. However, when the setups are
sequence dependent and each family has only one job, the problem becomes an NP-Hard
problem (Rinnooy Kan et al., 1975). Liaee and Emmon (1997) showed that even if
processing times of all jobs are identical, the problem complexity remains NP-Hard.
31
Furthermore, in case ofthe problem of minimizing maximum flowtime, it is noted that a
job sequence within a family is not of essence.
Studies in group technology problems have also been invesfigated. Yoshida et al.
(1973) proposed a polynomial algorithm, which is based on Emmons' properties, to
minimize the weighted flowtime for a single machine problem. Ham et al. (1979)
proposed a branch and bound algorithm to minimize total flowtime with minimum
number of tardy jobs in a multi-machine flow shop problem. Sekiguchi (1983) proposed a
procedure to obtain an optimal sequence with minimum makespan for a two machine
flow shop problem under serial parallel precedence constraints. Vakharia and Chang
(1990) proposed a heuristic algorithm based on simulated annealing for the group
scheduling of a machine cell. Kleinau (1993) invesfigated two machine flow shop and
open shop problems to minimize makespan. He proved that the proposed problem are
NP-Complete. In the flow shop case, job sequence in a batch can be sorted optimally by
Johnson's rule, which effectively solves the traditional two machine flow shop problem.
Rana and Singh (1994) implemented several optimal properties for single machine
problems with the objective of minimizing mean completion fime. Furthermore, they
extended their study by including a holding cost, and presented an efficient approach to
determine an optimal schedule which minimizes mean completion time, makespan, and
holding cost simultaneously.
Logendran et al. (1995) developed single-pass and multiple-pass heuristics to
minimize makespan. Cheng et al. (1996) presented a polynomial time algorithm with the
aim of minimizing the maximum cost of a schedule subject to minimize total weighted
flowtime. Strusevich (2000) proposed a linear time heuristic algorithm, with the worst-
32
case performance ratio of - , for two machine open shop problems to minimize
makespan. Dao and Abou (2000) developed a neural network approach for a multi-
machine case. Yang and Chem (2000) proposed a heuristic for a two machine flowshop
problem with the objecfive of minimizing makespan. In case of sequence-dependent
setup time, Schaller et al. (2000) investigated the problem of a flow shop manufacturing
cell to minimize makespan. Schaller (2001) presented a new lower bound for a branch
and bound algorithm in a flow shop problem.
However, when the group technology assumption is relaxed, the difficulty
increases noticeably. Sahney (1972) considered the problem with two machines and one
operator. This problem is similar to the problem with two job families. The objective is to
minimize total flowtime, and a branch and bound algorithm was developed. Psaraftis
(1980) presented a dynamic programming algorithm to minimize total flow time for a
special case in which all jobs in each family are identical. The algorithm mnning time is
n ^ if+1)" and the storage requirement is n (f+1)". It is obvious that the algorithm is
preferable when the number of jobs is small. Gupta (1984) studied the problem with two
families. He proposed an 0(« log n) algorithm which initially sequences jobs in SPT
order, and then partial sequences are compared to improve the solution. However, Potts
(1991) presented a counter example to show that the heuristic fails to seek the optimal
solution. Potts proposed an 0(«^) dynamic programming algorithm for problems with two
families to minimize the total completion time. The key assumptions of his study are that
there is no setup before the first job and the family setup time is sequence-dependent. He
33
also presented an 0(«^) dynamic programming for total weighted completion time
problems.
Gupta (1988) presented a heuristic for single machine problems to minimize mean
flowtime. His heuristic is a modified SPT mle to generate an approximate solution for a
mulfi-family problem. The procedure ofthe heuristic starts with ordering jobs in SPT
order in each family, and then selecting a job with the lowest processing time plus family
setup time, and scheduling them one by one. The experiment showed that the heuristic
was quite effective in finding an optimal or near-optimal solution. Monma and Potts
(1989) discussed a family scheduling problem with sequence dependent setups satisfying
the triangle equality condition. That is, given family/ g and h, we have Sfg + Sgh ^ Sfh.
They presented a dynamic programming algorithm and used it to show that, under the
triangle inequality condition, problems of minimizing total flowtime, maximum
flowtime, maximum lateness, and the number of tardy jobs can be efficiently solved.
They commented that once an optimal sequence in each batch is known, a dynamic
programming algorithm can be used to optimally merge the ordered batches into a single
schedule; the time required is polynomial in the number of jobs but exponential in the
number of batches. However, their algorithm is not practical unless the number of
families is very small.
Ahn and Hyun (1990) presented an optimal condition for the total flowtime
problem with multi-families, which is called the intragroup shortest processing time
property. Using this property, Ahn and Hyun modified Psaraftis's (1980) dynamic
programming algorithm to implement a more efficient algorithm, which requires an
34
0(«^) time. However, their algorithm appears to consume much more memory as the
number of families increases. They developed an effective heuristic to diminish the
memory problem. The underiying idea ofthe heurisfic is a pairwise interchange approach
and is composed of two procedures: forward improvement and backward improvement
procedures. The experiment showed that the heuristic can quickly find the near-optimal
solution with an average of 0.07% deviation fi-om the optimal solution. Furthermore, the
worst solutions ofthe heurisfic did not exceed 3% deviafion ofthe optimum. The
experiment showed that their heuristic outperformed the Gupta's heuristic (1988).
Mason and Anderson (1991) considered problems to minimize the average
flowtime. In their study, setups are assumed to be sequence dependent. Note that setups
consist of setdown time from the previous job and setup times ofthe following job.
However, they showed that an optimal sequence does not depend on individual setup and
set down times, but on the sum of setup and setdown times. Therefore, all setdown times
are assumed to be zero. A branch and bound algorithm was implemented for a special
case to find the optimal solution. The experiment showed that the algorithm can solve
problems with up to 30 jobs within a reasonable time. They commented that the
algorithm can be used efficiently when the number of families is small. Liao and Liao
(1993) considered problems of minimizing the difference between maximum and
minimum order completion times and presented a dynamic programming algorithm. Two
heuristics were proposed to deal with large-size problems. Ghosh (1994) presented
Oif n^^) backward dynamic programming algorithms for a single machine problem to
minimize total weighted completion time and for a multiple machine problem to
minimize the total complefion fime.
35
Williams and Wirth (1996) considered the problem of minimizing mean flowtime.
They presented a new heuristic based on Mason and Anderson's (1991) optimal sequence
properties. They compared their heuristic with no class splitting and Gupta's heuristic
(1988) and the experiment showed that the new heuristic performed very well. However,
the computational complexity ofthe new heuristic, which is 0(«'^), is much worse than
that ofthe other two heuristics. Crauwel et al. (1997) developed several search heuristics
(descent, simulated annealing, threshold accepting and tabu search). Computational tests
showed that all local search methods generated solutions close to the optimal solution.
Crauwel et al. (1998) proposed branch and bound algorithms for total weighted
flowtime problems. Their lower bound is obtained by performing a Lagrangean
relaxation ofthe machine capacity constraints in a time-indexed formulation ofthe
problem. The first algorithm uses the forward branching mle that incorporates dominance
properties, and the multiplier adjustment method to obtain lower bound. The second
algorithm uses a binary branching mle that fixes adjacent jobs (with respect to WSPT
order) in the same family to be in the same or in different batches, and sub-gradient
optimization to generate the lower bound. The experiment showed that the first algorithm
solved instances with up to 70 jobs, and was more efficient than Mason and Anderson
(1991) and the second algorithm. Hochbaum and Landy (1997) studied a problem
involving family weights. The problem of two families was considered. All jobs in each
family have identical weights and identical processing times. The proposed two-weight
algorithm mns in 0( 4n log n) when the processing times and setup time are fixed.
Chen and Powell (2000) considered an identical parallel machine problem to
minimize the total weighted completion time. A setup time can be sequence dependent or
36
sequence independent. They proposed a column generation based algorithm to find the
optimal solution. The computational resuhs showed that the algorithm is capable of
solving the problems of medium size in a reasonable time. Webster and Azizoglu (2001)
studied parallel machine problems to minimize total weighted flowtime. Note that this
problem is considered NP-Hard in the strong sense. They proposed two dynamic
programming algorithms, a backward algorithm and a forward algorithm. The time
complexity ofthe backward algorithm and forward algorithm are less than
0(mf"'*'-f,Jw'"-') and Oimf'"^-'^ nJP+S) "*), respectively. Note that W, P and S are
defined by /^»'y , /IP'J ^^^ zl^i'^j ' respectively. Furthermore, m is defined as
number of machines. They noted that the backward algorithm is preferable when the sum
ofthe processing and setup times is greater than the sum of weights. Otherwise, the
forward algorithm is favored.
Regardless of job family constraint, the optimal sequence ofthe maximum
lateness problem can be found by sequencing jobs in EDD order. The implication of this
result for the family scheduling model is that when setup times are quite small, the EDD
sequence should provide a good solution. For family scheduling problems, it has been
proved that there exists an optimal schedule in which the jobs in each family or batch are
sequenced by the EDD rule (Monma and Potts, 1989). However, the EDD mle works
pooriy when it is used for sequencing the batches because the rule considers only due
dates and ignores the implication of family setup times resulting in many setups.
37
Under the group technology assumption, the optimal solution may be more easily
obtained than it is in the case where families can be split into several batches. Webster
and Baker (1995) gave sufficient condifions for the opfimality ofthe group technology
sequence solution in a general problem and two cases of special interest: when setup
times are quite large, or when due dates are identical.
When group technology sequence is ignored, Bmno and Downey (1978) proved
that the problem to minimize maximum lateness when the setup time is sequence-
independent is strongly NP-Hard. However, it can be solved within polynomial time if
the number of distinct due dates is fixed. Monma and Potts (1989) agreed with Bmno and
Downey 's conclusion and presented dynamic programming algorithms. Times required
for the maximum lateness problem with sequence independent setup times and sequence
dependent setup time are 0( f'n^'*^) and Oif' n '^), respectively. Schutten et al. (1993)
proposed a branch and bound algorithm for problems with distinct release dates and due
dates. The main contribution of their study is to present lower bound to deal with family
setup times. Ghosh and Gupta (1997) proved that the problem of minimizing maximum
lateness when setup times are sequence dependent is NP-Hard, even if either two distinct
due dates, two jobs per family, and arbitrary setup times, or three distinct due dates, three
jobs per family and equal setup times. They also implemented an effective backward
dynamic programming algorithm. The family setup times are assumed to be sequence
dependent and hold the triangle inequality property. The complexity of their algorithm is
Oif'nJ
38
Zdrzalka (1995) proposed a heuristic which starts with a schedule in which each
batch contains all jobs from a family, and allows each family to be split into at most two
batches. At each iteration, a job is removed from the first batch of its family and is
inserted into the second batch. The heuristic requires 0(« ) times and it generates a
schedule with maximum lateness that is no more than - times ofthe optimal value.
Hariri and Potts (1997) proposed a single batch heuristic in which all jobs are formed into
a batch, and a double-batch heuristic in which each family can be partitioned into at most
two batches. The key is to select the better schedule from both algorithms. Both
algorithms require 0(/! log n) time and the worst case ratio is no more than - times of
3
the optimal value. The results from both heuristics were compared to the results derived
from branch and bound algorithm. The initial lower bounds are obtained by ignoring
setups, except for the first job in each family, and solving the resulting problem by the
EDD mle. The lower bound is improved by the procedure of considering whether or not
certain families are split into two or more batches. The experiment showed that the
algorithm can solve problems with up to 60 jobs.
Schutten et al. (1996) developed a branch and bound algorithm for a more general
case when jobs have arbitrary release dates. The most significant contribution is a
procedure which creates dummy jobs that represent setups. This procedure is heavily
reliant on the presence of some jobs of a family with release dates which exceed the latest
complefion times of other jobs in the same family. Schutten and Leussink (1996)
extended the study to the parallel machine case. Dileepan (2000) proposed a branch and
39
bound algorithm for a problem with only two families. The algorithm uses the forward
branching mle, that is, the first considered job is placed at the first position in sequence.
Baker (1999) presented the GAP heuristic to minimize maximum lateness.
Assuming that the initial sequence is ordered by the EDD mle, the key ofthe heuristic is
that if two consecutive jobs from the same family have due dates sufficiently far apart,
we should consider putting them in different batches. However, the heuristic tends to
generate too many batches. The improvement step is to attempt to combine some batches
from the same family together. The GAP heuristic requires 0(«* log n) computational
time. The experiment showed that the heuristic seems to provide good solutions,
compared to other heuristics. Baker and Magazine (2000) proposed an algorithm for a
single machine case. They exploited a special stmcture to compress the problem size by
creating composite jobs; then they accelerated the enumerafion with dominance
properties and lower bound; then the problem is solved by a branch and bound algorithm.
The experiment suggested that an optimal solution for a 50-job problem is possible.
(Weighted) Number of Tardy Jobs
Without considering family constraint, the number of tardy jobs is minimized by
using Moore's algorithm (1968). Monma and Potts (1989) developed forward dynamic
programming for a problem of minimizing the weighted number of tardy jobs when the
setup times are sequence dependent. The algorithm is based on the optimal property that
the early jobs in each family are sequenced in EDD order. Crauwels et al. (1999)
proposed a branch and bound algorithm for the problem of minimizing the number of
tardy jobs when the setup times are sequence independent. They developed two lower
40
bounds. The first lower bound is obtained by relaxing the setup times. The setup time for
each family is distributed to the processing fimes of jobs in that family, and then the
traditional approach, Moore's algorithm, is applied for the lower bound. The second
lower bound is due date relaxation. All due dates are set to be equal to the maximum due
date, then solved with dynamic programming for a single machine problem about a
restrictive common due date. Crauwel et al. (1996) solved the problem of minimizing the
number of tardy jobs, when the setups are sequence independent, with several search
algorithms, including simulated annealing, genetic algorithm and tabu search. The
experiments showed the search algorithms performed well.
Total Earliness and Tardiness about a Common Due Date
Azizoglu and Webster (1997) noted that, before 1997, there was no previously
published work on a family scheduling model with earliness and tardiness penalty. They
discussed the problem with a common due date on single machine. Assume that each job
has arbitrary eariiness and tardiness penalty costs, they proposed a branch and bound
algorithm and Bean Search procedure along with a lower bound. Later, Webster, Jog, and
Gupta (1998) proposed a genefic algorithm to deal with this problem. The results ofthe
experiment showed that a genetic algorithm can generate good solutions, in comparison
to the results from a branch and bound algorithm.
Chen (1997) considered an earliness and tardiness problem when each family has
its own common due date. The family common due date can be determined either by
customers or by the manufacturers. Two problems are invesfigated. The first problem is
to minimize the total tardiness and eariiness when the due date is externally given. The
41
problem is proven to be NP-Hard even when there are only two batches of jobs and the
due dates are extremely large. The other problem is when due dates are decision
variables. Chen proposed the polynomial dynamic programming algorithm to solve the
problem with two batches.
In the case of parallel machine problems, Webster (1997) showed the complexity
ofthe m parallel machine problem with job families and an unrestricted common due date
to minimize the total earliness and tardiness. He proved that the parallel machine problem
with job families to minimize the total completion time is unary NP-Hard, even when
jobs in each family are identical. He also proved that a parallel machine problem to
minimize the total earliness and tardiness about a common due date is unary NP-Hard. In
addition, he summarized some complexity results of common due date problems.
Working on the total tardiness performance measure in a family scheduling model
is quite innovative. To the best of our knowledge, there is no published work on family
scheduling to minimize total tardiness. In the next chapter, effective heuristics which can
obtain good solutions within reasonable time are proposed. Furthermore, addition of a
sequence dependent setups constraint is incorporated into the proposed problem. A
hybrid genetic algorithm will be introduced and discussed in Chapter IV.
42
FAMILY SCHEDULING PROBLEMS:
SEQUENCE INDEPENDENT CASE
When setup times are not involved, a total tardiness problem can be solved using
the existing total tardiness approaches. Well-known job dominant properties, namely
Emmons condifions (1969), can be applied to obtain precedence relationships of jobs in
an optimal sequence. However, not all jobs follow Emmons' condifions. Thus, using
Emmons' conditions may provide merely partial schedules. Furthermore, the single
family total tardiness problem is considered a NP-Hard problem in the ordinary sense
(Du and Leung, 1990). Nevertheless, there are several effective heuristics that can
provide good solutions within a reasonable time. Examples of these heuristics are the WI
heuristic, NBR heuristic, and PSK heuristic. We already covered the details of these
heuristics in the previous chapter.
Adding the family constraints into the problem makes the problem more
complicated. If two consecutive jobs are from different families, a setup is required
before the second job can start processing. Otherwise, the following job starts
immediately once the preceding job is finished. Moreover, jobs in a family may be
partitioned into several batches, if necessary. Since there is no past research in the total
tardiness criteria in the family scheduling problems, the complexity ofthe problem still
remains open. However, it can safely be said that the problem must be at least NP-Hard
in the ordinary sense since the total tardiness problem for a single machine is already a
binary NP-Hard problem (Du and Leung, 1990).
43
If the family setup times are large, it is reasonable that all jobs from the same
family be sequenced together to minimize the number of setups. In this case, the number
of batches is identical to the number of families. Such sequences are called/a/»/7v
sequences ox group technology sequences. However, if the setup times are small, splitting
a family into several batches might improve the solution. If the number of batches is
more than the number of families, the sequences are called batch sequences. The
difficulties of these sequences are in determining the sequence of batches and the
sequence of jobs in each batch.
A completely enumerative approach is an intuitive method of solving n job
problems. However, the method has to generate n\ schedules in order to find an optimal
solution. With an optimistic assumption that one uses a very fast computer that can
generate 1,000,000 schedules per second, it would take at least 15 days to solve a 15-job
problem or at least 77,146 years to solve a 20-job problem. In this chapter, an integer
programming model will be developed and executed using GAMS/CPLEX. The
GAMS/CPLEX solver is considered one ofthe fastest commercial solvers available.
Although it is much faster than an enumerative search, it still requires tremendous
computational time. In this research, 180 problems with 20 jobs and 6 families were
solved and only 34 problems could be solved optimally within 30 minutes. The difficulty
of a problem rises when the number of jo