HEURISTICS FOR THE FAMILY SCHEDULING - Repositories
285
HEURISTICS FOR THE FAMILY SCHEDULING PROBLEMS TO MINIMIZE TOTAL TARDINESS by SAMARN CHANTARAVARAPAN, B.E., M.S.I.E. A DISSERTATION IN INDUSTRIAL ENGINEERING Submitted to the Graduate Faculty of Texas Tech University in Partial Fulfillment of the Requirements for the Degree of DOCTOR OF PHILOSOPHY Approved December, 2002
HEURISTICS FOR THE FAMILY SCHEDULING - Repositories
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