Optimal Scheduling of Complex
Batch Processes
By
HENRY X. SWANSON
A DISSERTATION PRESENTED TO THE GRADUATE COUNCIL OF
THE UNIVERSITY OF FLORIDA IN PARTIAL
FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF
DOCTOR OF PHILOSOPHY
UNIVERSITY OF FLORIDA
1972
73-15,601
SWANSON, Henry Xenophon, 1945-
OPTIMAL SCHEDULING OF COMPLEX BATCH PROCESSES.
The University of Florida, Ph.D., 1972
Engineering, chemical
University Microfilms, A XEROX Company, Ann Arbor, Michigan
1973
HENRY XENOPHON SWANSON
ALL RIGrTS RESERVED
PLEASE NOTE:
Some pages may have
indistinct print.
Filmed as received.
University Microfilms, A Xerox Education Company
ACKNOWLEDGMENTS
The author wishes to express his appreciation for the
assistance and support of:
Professor F. P. May, who served as chairman of his supervisory
committee, first introduced the author to the problems of batch
scheduling, and who was his principal research advisor;
Associate Professor A. W. Westerberg who introduced the
author to systems design and optimization and served on his research
proposal committee;
Professor H. E. Schweyer who served on the author's supervisory
committee and who helped him define his problem;
Assistant Professor J. B. Wallace who served on his supervisory
committee;
Professor R. D. Walker, Jr. who served on his supervisory
committee;
The Department of Chemical Engineering for support and for the
educational contributions of its faculty and staff;
The University Computing Center which provided support.
TABLE OF CONTENTS
ACKNOWLEDGMENTS.............................................
LIST OF TABLES.............................................
LIST OF FIGURES............................................
LIST OF SYMBOLS.............................................
ABSTRACT ..................... .......... ..............
CHAPTERS:
I. THE PROBLEM................... ....................
II. INTEGER PROGRAMMING...............................
Problem Formulation..........................
History....................................
III. INTEGER PROGRAMMING USING DUALITY AND THE
REVISED SIMPLEX METHOD...........................
IV. PURE SCHEDULING PROBLEMS........................
Balas'Enumeration ..........................
Branch-Bound Enumeration..................
A Solution to the Storage Problem...........
Optimization Strategies.....................
V. ENUMERATION OF MIX/SCHEDULING PROBLEMS ...........
VI. RESULTS, CONCLUSIONS, AND RECOMMENDATIONS........
Solution Efficiency.........................
Results..... ................................
Conclusions and Recommendations .............
APPENDICIES ........................................ .......
A. THE INVERSE MATRIX FOR PURE SCHEDULING PROBLEMS.,
ii
v
vi
viii
xi
1
8
8
12
16
24
25
38
43
44
48
60
60
64
70
73
74
I
TABLE OF CONTENTS .(Continued)
Page
B. PROGRAMS ......................................... 86
BIBLIOGRAPHY............................................... 147
BIOGRAPHICAL SKETCH ......................................... 149
LIST OF TABLES
Table Page
1 Table of Data for Sample Problem .................. 30
2 Optimal Schedule for Sample Problem............... 38
3 Batch Costs for Sample Batch Product Mix Problem.. 54
4 Batch Characteristics for Large Batch Product
Mix Problem......................... ............. 55
5 Chemical Inventories and Batch Sizes.............. 56
6 Feasible Schedule Found for Batch Product Mix
Problem................................... ....... 57
7 Computational Results Using Several Integer
Programming Methods............................... 61
8 Optimal Product Mix and Schedule for Sample
Problem 2. ......................................... 65
9 Schedule for Two Time Periods..................... 66
10 A Set of Scheduling Decisions..................... 69
11 Best Schedule Found for Sample Problem 3.......... 71
LIST OF FIGURES
Figure Page
1 A Simple Batch Processing Problem................. 3
2 Flow Chart for First Two Linear Programs........... 26
3 Flow Chart for Last Four Linear Programs........... 27
4 Final Flow Chart for Sample Problem................ 28
5 Flow Sheet for Intermediate Inventory............. 29
6 Early Stages in Solution of Sample Problem......... 34
7 Flow Chart Showing First Four Decisions Made
in Solving Scheduling Problem..................... 35
8 Flow Chart Showing Backtracking After Sixth
Linear Program............................. ...... 36
9 Continuation of Sample Problem to First
Feasible Schedule................................. 36
10 Flow Chart for First Step in Solving Sample
Problem Using a Branch and Bound Enumeration
Procedure.................. ....... ................... 39
11 Flow Chart for Branch-Bound Procedure up to
Fourth Partial Solution........................... 40
12 Flow Chart Including Fifth Partial Solution....... 40
13 A Partial Solution with Three Remaining Either/Or
Choices............................................ 46
14 A Partial Solution Where Three Either/Or Choices
Can Be Made at Once............................... 47
15 Second Batch Product Mix Problem.................. 59
16 Three Possible Forms for Columns of B.............. 78
17 Flow Sheet for Subroutine PIVOT................... 89
18 Flow Sheet for Subroutine LINEAR .................. 92
19 Flow Chart for Subroutine DEMINF................. 98
20 Flow Sheet for Subroutine BACKTR.................. 112
LIST OF FIGURES (Continued)
Figure Page
21 Vector LF Before and After Control Point 1........ 118
22 Vector LF After Iteration Loop 104................. 119
23 LF After Iteration Loop 105....................... 119
24 LF After Control Point 11......................... 120
25 LF After Variable LL Constrained to Zero and
Variable L Freed................................... 120
LIST OF SYMBOLS
A matrix which defines constraints to scheduling problems.
a column i of matrix A'.
AA a matrix used by computer programs to determine nonzero
components of A'. A(1,J) gives the number of nonzero
components of the first column of A'. For A(1,J) = I,
A(Z,J) through A(I+1,J) give the location of the nonzero
components of the Jth column of A'. For A(1,J) = I,
A(I+2,J) through A(2I+1,J) give the corresponding nonzero
components of the Jth row of A'.
B the basis matrix of A'. (See Chapter III.)
BB The basis matrix for the results of first dual linear
program where all of the dual variables are constrained
to zero.
BI a matrix used by computer programs which is the inverse
of B.
Bl the product of -CC times B.
B1F Bl for the result of the first dual linear program.
cijk cost of producing the kth batch of chemical i in
production unit j.
cjk coat per hour of storing kth batch of chemical i in
production unit j.
Ci completion time of a particular job i.
CC cost vector used by computer programs. CC(i) is the
cost corresponding to dual variable i.
d cost vector for the dual to scheduling problems.
ei the vector which has all zero components except for the
ith component which is one.
IK a matrix used by computer programs to locate information.
If a variable I represents a scheduling decision then
IK(1,I-NBM) locates the row of IMP which contains infor-
mation about decision I.
For a particular N2, IK(2,N2) locates the list IK(3,N2)
through IK(IK(2,N2),N2). IK(3,N2) through IK(IK(2,N2,N2)
are parameters used along with subroutines DEMIN or DEMINF
to reduce the size of scheduling problems.
viii
IMP matrix which locates production decisions and scheduling
decisions for the computer programs. For a particular
Il, IMP(II,1) will locate production decisions. Let
I = IMP(Il,1). In this case variables IMP(II,2) through
IMP(Il,I) will correspond to decisions to produce some
batches. Let J IMP(I1,I+1). In this case variables
IMP(Il,I+2) through IMP(I1,J) will correspond to decisions
about scheduling the batches.
IX vector which is used by computer program to locate freed
variables. A dual variable I is constrained to zero if
IX(I) .FALSE. The decision to free a variable I on a
particular branch of a decision tree (see Chapter IV.) is
made by setting IX(I) .TRUE.
IXB let I be a dual variable representing a production
decision. If the decision is implied by another decision
then one need not free variable I. (see Chapter IV.)
The computer programs indicate that a production decision
is redundant by setting IX(I) .FALSE. and IXB(I) .TRUE.
If variable I represents a scheduling decision then the
variable is constrained to zero on a branch of the decision
tree by setting IXB(I) .FALSE. IXO(I) .FALSE. and
IXB(I) .TRUE. indicate that variable I is currently
constrained to zero but may eventually be freed if the
decision is made to produce the batch which is scheduled
by variable I.
IXO For production decisions IXO(I) .FALSE. indicates variable
I is constrained to zero on the current branch of a solution
tree.
For scheduling decisions IXO(I) = .FALSE. means that a
variable is temporarily constrained to zero but may be
freed if the decisions are made to produce the batches
scheduled and IXB(I) .TRUE.
IX1 a vector used by computer programs to determine which
variables are in the basis. The variables IX1(1) through
IX1(M) are in the basis.
IN equivalent of n for computer programs.
LF a vector which contains a list of numbers used by computer
programs and described in Chapter IV. For a particular I,
the absolute value of LF(I) is a variable which has been
either freed or constrained to zero. If LF(I) is negative
the program has eliminated the opposite decision from
consideration. The first member of the list is LF(2) and
the last member is LF(LF(1)).
m the number of constraints to the dual of a scheduling
problem.
M equivalent of m for computer programs.
MIMP number of rows of matrix IMP.
n number of variables in the dual to a scheduling problem.
NBM number of production decisions similar to Equations (41)
through (44).
R a reactor used in a sample program.
S a separator used in a sample program.
t the time that a particular batch is started.
v a variable which can take a value of either 0 or 1.
w the vector of dual variables to a scheduling problem.
x vector of variables for a product mix or scheduling
problem.
X vector containing the value of the basis variables for the
written programs.
z objective function.
z objective function for an incumbent solution.
T the time period over which a scheduling problem is to
be optimized.
Abstract of Dissertation Presented to the
Graduate Council of the University of Florida in Partial Fulfillment
of the Requirements for the Degree of Doctor of Philosophy
OPTIMAL SCHEDULING OF COMPLEX
BATCH PROCESSES
By
Henry X, Swanson
June, 1972
Chairman: Professor F. P. May
Major Department: Chemical Engineering
The chemical industry performs a number of its operations
as batch processes. This paper presents a method of scheduling batch
processes,and the techniques developed are especially efficient for
solving batch scheduling problems found in the chemical industry.
Two related problems are unique to batch processes. One has
the problem of scheduling operations if more than one chemical can
be processed in the same machine. Sequential batch operations usually
require intermediate inventory. The beginning intermediate inventory
over any period determines which schedules are feasible and the final
intermediate inventory is a function of the schedule used. One has
the problem of determining which schedules should be used and how much
intermediate inventory should be maintained.
The author modeled batch scheduling problems using linear
production and inventory costs and linear constraints. Other researchers
have presented methods of solving such problems but the author's method
proved more efficient for chemical batch scheduling problems.
The models of scheduling problems were written as a linear
objective function and a large number of linear constraints. A subset
of the constraints would apply for any feasible schedule. The dual
problem was also linear with a large number of variables. Only a
subset of these variables would take on nonzero values for any
feasible solution. The solution algorithm used the revised simplex
method and a novel method of identifying which variables were held to
zero. This solution method allowed one scheduling decision to Imply
another which turned out to be an important feature for improving
solution efficiency.
Sample scheduling problems were solved where the objective
was to find how many batches should be produced and then to schedule
them. The author could not find a case where such problems were
attempted by other researchers.
The solutions to simple problems indicated that machine slack
time is an inherent feature of batch scheduling problems. The
solutions also indicated that intermediate inventory costs frequently
cause one to produce a more varied product mix than if there were no
inventory costs.
xii
CHAPTER I
THE PROBLEM
It was the purpose of this work to develop a method to
schedule the operation of fairly complex batch chemical processes.
Actually a method was developed to optimize a fairly large class of
problems. The solution procedure was developed to be most efficient
for the chemical processing problems because of the structure of such
problems.
Batch chemical processing units are designed so that various
chemicals can be fed into them and after processing the resulting
products are removed. We will look at the problem created when a
chemical plant can produce a variety of products in the same batch
production units. Typically there are a number of operating units
in a chemical plant and the units can, in general, be used to produce
a number of different products. The products from some units are
used as feed to other units and one has to decide how each unit should
be operated.
The oil industry has had some success in using linear pro-
gramming to optimize continuous production rates when a variety of
possible products can be produced. If one assumes that there is a
fixed cost per pound of chemical made in a production unit one gets
a linear objective function.
minimize cijxi (1)
S
Here xij is the number of pounds of chemical i produced in
production unit j and cij is the fixed cost per pound of chemical
produced. Profit is treated as a negative cost.
One also has material and energy balance constraints which are
of the form
Ax **
**
Here we are using matrix notation where A is a matrix, x is
the vector with components xij and b is a vector.
These constraints together with the linear objective function
form a linear programming problem. This linear programming problem
becomes an integer programming problem if the chemicals are to be pro-
duced in batches. Batch processes differ from continuous processes
in at least two important aspects. Production occurs only as an
integer number of batches and successive production units do not
necessarily operate at the same average production (or use) rates.
Equations (1) and (2) with xij integer might not be too difficult
an integer programming problem. This product mix problem might even
be solved by linear programming especially if it has a lot more variables
than constraints.1 One might not be able to schedule the result of
this product mix problem.
The scheduling problem can be seen by looking at a very simple
batch processing problem. Suppose a chemical process uses two batch
units, R and S, to produce a final product. Suppose that R produces
300 pounds of product and that it takes 500 pounds of product from R
to feed S. Suppose further that it takes three hours to produce a
batch in R and four hours to produce a batch in S.
300 pounds 500 pounds feed
produced/batch needed per watch
R Intermediate
R Inventory S
three hours four hours
per batch per batch
Figure 1. A Simple Batch Processing Problem.
With sufficient intermediate inventory, it is possible to
produce 5 batches in R and 3 batches in S over a fifteen-hour period.
If there is no intermediate inventory, the first batch of S cannot
begin until after the second batch of R is completed. Thus, only
two batches of S can be produced in a fifteen-hour period with no
intermediate inventory.
One should notice that R is capable of producing 100 pounds
per hour and S is capable of consuming 125 pounds per hour if there is
sufficient feed. One should consider multiple uses for S since it is
slightly oversized for the process shown in Figure 1.
Uriostie2 considered the product mix problem given by
Equations (1) and (2) together with xij integer. This product mix
problem did not include scheduling constraints. Next Uriostie
considered scheduling the problem in a second step. If one adds
restrictions on the number of batches produced to Equation (2)
eventually one will get a product mix that is schedulable.
Thus far we have not considered any inventory costs in our
problem formulation. In general we will be concerned with the problem
where the cost of each product in inventory is proportional to the amount
of product and to the time that this product is in inventory.
The real product mix problem for batches should include
Equation (1) and a cost for inventory. The constraints should include
Equation (2) and scheduling constraints. An efficient method will be
presented for solving this batch product mix problem. Actually the
solution procedure turns out to be useful for solving a larger class
of problems than the batch operation problems which are considered in
detail in this thesis.
We want a solution procedure that will be very efficient for
solving certain problems found in the chemical industry. Three
different types of problems are considered in this work.
The petroleum industry uses the product mix problem in order
to set yearly production goals and sales goals for continuous processes.
The author would like to be able to solve the batch product mix problem
for the same reason. Sales and production goals are useful and the
batch product mix problem can provide this information.
The author would like to be able to solve the batch product
mix problem and two other related problems. The other two problems are
caused when sales goals are not met exactly. The production department
could use the result of the yearly batch product mix problem if sales
goals were met exactly.
Actually sales vary from month to month and sales departments
are encouraged to exceed the sales' goals for the most profitable
products. The production department has to be able to fill whatever
sales commitments are made each month.
The production department can use a modified batch product
mix problem for monthly operations. This problem would again use
costs for making each batch and inventory costs. The batch product
mix problem would have the same form as the yearly batch product mix
problem except for some additional constraints. These constraints
would force production to fill the existing sales orders.
The last problem the author would like to be able to solve
is simply a scheduling problem. The pure scheduling problem is formed
when one decides what operations should be performed and one merely
needs to schedule the operations. This is the type of problem
Urioatie2 solved for the case of two machines and two products.
Uriostie also assumed he had sufficient intermediate inventory to begin
any operation.
In reality the inventory left over from one month's production
affects production in the next month. We will only be interested in
optimizing operations over a fixed time period and will ignore the
effect of these operations on some sequential time period.
Our scheduling problem is related to another problem called
in the literature "the job-shop problem."3 The job-shop problem comes
from the problem of scheduling production in a machine shop where pieces
of metal have to be worked on different machines. The problems are
different however in that in our problem there is in general no unit
of chemical that has to be worked on. Three-sevenths of one batch
might be needed to make a batch of feed for the next processing unit,
for example, and frequently a batch separation process will produce
some odd fraction of material to be recycled.
One may have to do a number of operations on a piece of metal
before the job of working the metal is completed. Other authors
reported work on scheduling problems but interest has most often
centered on a regular measure of performance for the job-shop problem.
A regular measure of performance can be expressed as a function of
the job completion times.
M = f(C1,C2,....,C) (3)
C, is the time that job i is completed and a regular measure
of performance also has the characteristic that the measure increases
only if at least one of the completion times increases. That is, if
M' = f(C,C2,...,C), then M' > M only if C' > Ci for at least one i.
3
Conway, Maxwell, and Miller suggest one of the real reasons
that so much interest has centered around minimizing the completion
time of the last job (a regular measure of performance) is that a
simple algorithm was developed for minimizing this completion time in
a two-machine job-shop. Researchers, however, have not found a
simple algorithm for more complex cases. We will be using an inventory
cost which is proportional to the amount of each material in inventory
and the time it is stored. This is not a regular measure of performance
since the cost is minimized if we start jobs creating inventory as
late as possible. One reason why this inventory cost makes sense is
that if a product cannot be shipped and sold until a certain due date,
there is no reason why the company should spend its resources completing
the job early.
Some heuristic procedures have been developed for solving the
job-shop problem. Actually heuristic procedures are a fairly good
idea for scheduling problems. The job-shop scheduling problem can be
formulated as a 0-1 programming problem but as late as 1963 realistic
problems could not be solved. Lasdon has some encouraging results
for large scale problems but his scheduling problems are not as difficult
as the ones this work will attempt to solve.
In one way, our scheduling problem is harder than the job-
shop scheduling problem; we do not have a fundamental unit of the
chemical product which has to go through a certain sequence of machine
operations. Our scheduling problem is easier because usually one
has a number of batches of the same type and this reduces the
dimensionality of the problem. (Knowing that batch 1 of type E
proceeds batch 1 of type F implies that batch 1 of type E proceeds
all uf the batches of F and reduces the size of the problem.)
Multiple batches (that is, continuing use of the process)
are the rule in the chemical industry because of the high development
coats of a chemical process. The high costs involved justify a fairly
elaborate effort to find a good product mix and a good schedule.
Graham also looked at a similar scheduling problem. No
inventory costs were assessed but costs were included for setting up
each type of batch. A modification of dynamic programming was used.
There are computer storage problems for dynamic programming problems
of any complexity and Graham circumvented some of them by an
approximation technique. The author questions whether the storage
problems can be avoided for more complex problems than Graham attempted.
The author's enumeration scheme also looks more promising than Graham's
because of the simplifications caused by multiple batches.
CHAPTER II
INTEGER PROGRAMMING
A solution procedure is needed for product mix problems with
or without sales commitments and for pure scheduling problems. An
enumeration procedure similar to integer programming is developed in
this work. Some of the nomenclature of integer programming will be
useful for explaining the new enumeration procedure. First our problems
will be formulated as integer programming problems and then some of
the history and terminology of integer programming will be discussed.
Problem Formulation
The cost of producing batches is expressed in Equation (1)
for a product mix problem. For a pure scheduling problem the number
of batches of each type to be produced is fixed so this summation is
a constant. We can express the number of batches produces as a sum
of 0-1 variables.
xij = Xijk
x x ijk (4)
where xijk = 1 if the kth batch of i in j is to be produced
= 0 otherwise
0-1 variables will simplify later discussion.
We will need to include inventory costs in our investigations.
Let us look at the contribution to the inventory cost over a fixed
period, T, caused by one batch. Let tijk be the time that batch k of
i is started in unit j. Suppose it costs cijk per unit time to store
the feed for the batch in inventory. If we do not start the batch
until T the cost for storing the feed is Cijkr. The cost for feed
inventory will decrease by Cijk(T tijk) as a consequence of starting
the batch at tijk. Suppose that it costs cijk per unit time to store
the product from the batch in inventory and the batch has a processing
time of pijk in the unit. The overall affect upon inventory cost due
to starting the batch at tijk is
cijk(tijk + Pijk T) + ijk(tijk ') (5)
The inventory costs given by Equation (5) summed over all i,
j, and k is a linear objective function which we need in order to have
an integer program. The total objective function for our problem is
the sum over i, j, and k of Equation (5) and the costs given by
Equation (1). Next we need to formulate our constraints.
Material Balance
A material balance gives a simple linear constraint between
batches.
S Wijkxijk Wijkxijk (6)
ijkcPI ijkcCI
where wijk is the amount of chemical produced or used by batch k of
i in j
PI is the set of batches producing a kind of chemical
CI is the set of batches consuming the same kind of chemical.
Completion Time
We are to optimize operations over a fixed time period. A
simple constraint will make sure that there is enough time to produce
the batches in each production unit.
Pk ijkijk (7)
ik
We need to assure that batches are completed by the due date
if sales commitments are made. For the pure scheduling problem every
product batch has a due date.
tijk + Pijk dijk (8)
where dijk is the due date for producing batch k of i in j.
We need to use some tricks with our problem formulation to make
sure that no inventory cost is assessed if we make the decision not
to make a batch. We can use a synthetic device that will schedule any
batch which will not be made (xijk 0) to start at the final time T.
We do not want a contribution to the inventory cost if xijk = 0. This
can be done by the constraints:
tijk T (9)
tijk + rxijk T (10)
and adding the constant cijkPiJk to the objective function.
When xijk = 0, Equations (9) and (10) force tijk = T. One can
look at Equation (5) to see that the contribution to the inventory
cost when tijk = T is 0.
Equation (10) is nonrestrictive when xijk = 1.
Scheduling
This work is primarily concerned with scheduling different
operations on the same piece of equipment. The equipment can only
operate on one thing at a time so one has the constraints;
tajb + ajb tcjd
either/or (11)
tcjd + Pcjd tajb
Equations (11) are concerned with two batches to be made in
the same piece of equipment. Equations (11) say that one of the batches
has to be finished before the other begins. This either/or choice can
be expressed using a 0-1 variable.
tajb + ajb tcjd + (tajb + Pajb)v
tcjd + cjd tjb + (tcjd + Pcjd)(1 v) (12)
v 0 or 1.
To form an integer program we also would have to put some
constraints on our variables like v in Equations (12). For example,
we would need constraints to force a batch of A before all the batches
of B if the decision is made to schedule A before the first batch
of B. Equations (12) only hold if one has decided to produce batch b
of a in j and batch d of c in j. One may or may not decide to produce
a batch in the product mix problem, therefore Equations (12) are not
correct for the product mix problem. A more complex set of equations
has to be written for the product mix problem.
In general it is difficult to correctly formulate integer
programming problems. One of the most frequently encountered discrete
problem, the traveling salesman problem,8 was recognized and solved
years before someone saw how to formulate it as an integer programming
problem. The actual enumeration procedure developed later avoids much
of the difficulty of problem formulation.
History
A great deal of work has been done on integer programming.
Reviews of the literature8 have been done by others and a general
review will not be attempted here. Rather we will look at some of the
major types of solution procedure and their limitations. As the new
enumeration procedure is developed in a later chapter the relationship
will be shown between the new method and some of the more successful
methods of integer programming.
One of the earlier integer programming methods was developed
for the all-integer problem by Gomery.9'10 In this method all the non-
integer constraints are written. This problem is solved by a linear
programming method and new constraints are added to the problem. These
new constraints reduce the constraint set to a smaller set containing
the valid integer solutions. Constraints are added until an all-integer
solution is found. A great deal of work was done refining this cutting
plane method but unfortunately the method never proved to be very useful
because of the large number of constraints which had to be added to
the problem.
One of the most recent integer programming methods is also
due to Gomery. Again in this method an integer programming problem
is written without the integer constraints and one wants to reduce
this convex set to find the integer solutions. Group theory is used
and some refinements have been made in the method but it also doesn't
work very well because of computer storage problems.
Most, if not all, of the currently more successful algorithms
for solving integer programming problems are implicit enumeration
12 13
schemes.1 Land and Doig3 were the first to look at this method. For
implicit enumeration one first solves the problem using linear programming
without the integer constraints. One then looks at the effect of
adding integer constraints to the problem. One might, for example,
look at adding the constraint x7 4 to the problem where x7 must be
an integer variable. If x7 4 makes the problem infeasible one need
not look at any more integer solutions with x7 = 4. If x7 = 4 gives a
feasible solution one might solve the linear programming problem with
x7 4 and the original constraints and then look at adding additional
integer constraints to this result.
14
An additive algorithm due to Bales is similar to one of the
enumeration schemes in a later chapter. Suppose one has a problem with
0-1 variables. Equation (4) shows how to change a problem with integer
variables into one with 0-1 variables. One enumeration scheme starts
by first solving the linear programming problem without integer
constraints. If the solution is all integer then you are finished. If
not the scheme adds integer constraints one at a time. One chooses a
first variable, v1, and constrains it to be zero. The problem is
solved with all noninteger constraints and v1 = 0. If the problem is
infeasible then one need never look at solutions with v1 0 and one
need only look at v1 = 1. If the problem has a solution with v. 0
we call this a partial solution. We next need to find if there are
any feasible solutions to the original problem with v1 0. We do
this by adding more integer constraints to our partial solution. Suppose
we add the consecutive constraints v2 0, v3 0, ..., vn 0 and get
an infeasible solution. We say that there are no feasible completions
to the partial solution v1 0, v2 = 0,...,v 0. We next backtrack
and look for feasible completions to the problem v1 = 0, v2 = 0,...,
vn1 0, vn 1.
The process of adding constraints to the problem until one finds
a solution or proves there is no feasible completion is called
fathoming.14 Once one finds a solution to the original problem the
fathoming and backtracking procedure can be made more efficient. We
can use the objective function, z of the solution to the original
problem. We need not look for any solutions which do not have objective
functions better than z since we are trying to find the best possible
solution. We only keep the objective function from the best solution
we have found so far. If we find a new solution with a better objective
function we use it for the new z Suppose at some stage of our
fathoming procedurL we reach a partial solution which has an objective
function which is not as good as z At this point we can backtrack
because adding constraints will not improve the objective function of
15
the partial solution and we are only looking for feasible completions
with objective functions better than .
In order to implement an efficient enumeration scheme to solve
an integer programming problem, one needs information on the effect of
adding a constraint to a linear programming problem. An integer
programming method is developed in Chapter III which gives a great
deal of information on the effect of adding constraints to a problem.
In Chapters IV and V the integer programming method will be shown to
be very efficient for batch scheduling problems.
CHAPTER III
INTEGER PROGRAMMING USING DUALITY AND THE
REVISED SIMPLEX METHOD
A new method has been developed to solve integer programming
problems. The method is especially efficient for solving scheduling
problems. In Chapter II scheduling problems were shown to have two
general types of constraints. The first type of constraint includes
the material balance constraints and the completion time constraints.
Any feasible schedule has to satisfy all of the material balance
constraints and all of the completion time constraints. A feasible
schedule only satisfies one of the scheduling constraints from each
pair of scheduling constraints of the second kind. The new
solution method solves the dual of the scheduling problem. The
dual problem contains paired variables corresponding to the paired
scheduling constraints in the primal problem. One variable from
each pair of variables is constrained to zero. The new solution
method first solves the dual problem without any paired variables
and later successively adds variables to the problem. The dual
problems are solved by means of the revised simplex method15 which
greatly reduces the amount of work required for scheduling problems.
The new integer programming method will be explained by means
of a sample scheduling problem. Suppose we have to schedule three
operations, E, F, and G, on a particular machine. Suppose that E
produces inventory that costs 30 units of value for each unit of time
stored in inventory, F produces inventory that costs 40 units for
each unit of time in inventory, and G consumes inventory that costs
30 units of value for every unit of time in inventory. The objective
function will be of the form
minimize 30tE 40tF + 30tG + K (13)
t, tF and tG are the times that batches E, F, and G are started. As
shown in Equation (5) K will be a constant if we are to optimize our
scheduling over a fixed time period.
We will suppose G has to start before 60, F has to start
before 40 and E has to start before G. Suppose further that E and F
take 20 and G takes 10 units of time. We have three fixed constraints.
t < 60 %14)
G -
tF < 40 (15)
tE + 10 < tG (16)
We also need to have scheduling constraints that do not allow
two batches to be produced concurrently in the same machine.
tE + 20 tF
either/or (17)
tF + 20 < tE
tF + 20 < tG
either/or (18)
tG + 10 < tF
The scheduling problem is now formulated as a set of linear
programs. The programs can be written in a compact form.
minimize K (30, 40, -30)t
0 0
0 -1
-1 0
auch that -1 1
1 -1
0 -1
0 1
-60
-40
20
t > 20
20
20
10
t > 0 (19)
We have four possible linear programs depending on which
constraints are included from the last two pairs of constraints.
Corresponding to each of these linear programs there is a dual linear
15
program.
minimize c't
primal A t > d
problem t > 0
maximize d'w
dual A' w < c
problem w > 0
The objective function of the solution to a dual problem has
the same value as the objective function of the solution to the
corresponding primal problem. In fact, the same information can be
retrieved from a solution to the dual problem as can be retrieved from
a solution to the primal problem.
The dual problems corresponding to (19) can also be written in
a compact form.
maximize (-60, -40, 20, 20, 20, 20, 10)w + K
0 0 -1 -1 1 0 0 -30
such that 0 -1 0 1 -1 -1 1 w < -40 w > 0 (21)
-1 0 1 0 0 1 -1 +30
If a constraint is used in a primal problem the corresponding
variable will be used in the dual. If a constraint is not used in the
primal then the corresponding variable will not be found in the dual.
In order to use linear programming we first rewrite Equation
(21) in terms of equality constraints.
maximize (-60, -40, 20, 20, 20, 20, 10, 0, 0, 0)(w1s) + K
0 0 -1 -1 1 0 0 1 0 0 -30
0 -1 0 1 -1 -1 1 0 1 0 w = -40 (22)
-1 0 1 0 0 1 -1 0 0 1 s +30
> 0
s -
The first step of the solution procedure will be to solve (.2)
without any of the either/or variables. There are a number of algorithms
for solving linear programming problems but the revised simplex method
is especially useful for our needs.
Linear programming algorithms use a stepwise method of finding
an optimal solution. Primal simplex methods first find an extreme point
of the convex constraint set. One then pivots between adjacent extreme
points to the optimal solution. If a linear programming problem has n
variables and m constraints, the extreme points are characterized by
n-m of the variables having a value of 0. The m remaining variables
are called basis variables and one moves from one extreme point to
another by changing the variables in the basis. One needs to know how
much the objective function will change if a new variable is put in
the basis. One uses a vector yj for each variable, j, in order to
determine the change in the objective function. Suppose we are doing
the dual problem of Equations (20). For each variable n1 let a
n1
be the corresponding nth column of A'. Let b be the set of basis
variables, yj expresses the jth column of A' in terms of the basis
columns of A'
aj = Yija (23)
i c b
iEb
Equation (22) can also be expressed in matrix notation
aj B y (24)
Here B is the matrix formed from the basis columns of A'.
In the normal simplex method a new yj is generated for each j
for each step of the solution process. The revised simplex method
generates an inverse matrix, B-1, with each step of the solution
-l
process. The vectors, yj, can be generated by multiplying B times
the columns of the original constraint set.
Now we are going to first solve problem (22) without any of
the either/or variables. While we are solving the problem without the
either/or variables we do not need the information, yj, about them.
If the revised simplex method is used, the information, yj, does not
have to be generated during the first part of the solution process.
The enumeration process will be carried out in the dual. At
first the problem will be solved without oither/or variables and later
some of these variables will be added to the problem. The necessary
information for adding vectors tothe problem can be generated when
needed by the revised simplex method. Other linear programming methods
need to generate the information at every step of the solution process
which is a lot of unnecessary work.
It should be noted that there is no need for integer variables.
Greenbergl6 also noted that you don't need integer variables with
either/or constraints like Equations (17) and (18). However, Graznberg
did not solve his problem in the dual and had to solve a new linear
program every time he added a constraint.
The solution to Equation (22) without the either/or variables
has an objective function of K-1000. Information from the revised
simplex method shows that two of the either/or variables can be added
without increasing the objective function. These two variables
correspond to the first of Equations (17) and the second of Equations
(18). From this solution of Equation (22) without the either/or
constraints we can find the primal solution (tA 0, tB = 40, tC = 20).
The either/or constraints scheduling A before B and C before B are
satisfied by this solution.
We will develop several enumeration procedures in the next
chapter. In all of the procedures we will use the dual and the revised
simplex method. Variables corresponding to either/or constraints will
be added to existing solutions to linear programs in the dual. In
order to make decisions, one needs information on the effect of adding
new variables to an existing solution. It takes work to generate infor-
mation and one has to decide how much information is needed.
There are three types of information available on the effect of
adding a variable to a problem. One can solve the linear program with
the.new variable. This takes some work and we will need information
on a large number of variables. Moat integer programming algorithms
use much less information. In the simplex method one improves a
solution by moving from one extreme point of the feasible solutions to
another. One moves along an "edge" of the region of feasible solutions
from one extreme point to another. The simplex method will move along
the "edge" that has the largest feasible gradient to improve the
objective function. Most integer methods use this gradient to make
decisions. In the revised simplex method one has to multiply two
vectors together in order to determine the gradient. If the problem
has m constraints then the vectors have m+l components. One can also
determine how much the objective function will increase as a result
of moving from one extreme point to another. In the revised simplex
method, one has to multiply a matrix times a vector in order to
determine the cost of moving from one extreme point to another. We
will use this information.
We will be multiplying a m+l dimensional square matrix times a
2
vector and this normally involves (m+l) multiplications and the same
number of additions. For scheduling problems most of our vectors will
come from constraints like Equations (17) and (18) which means
they will have only two nonzero terms, plus and minus one. Our
multiplication will consist only of subtracting the components of one
row of the matrix from another. This simplification decreases the
difficulty of determining the cost of moving to a new extreme point.
There is another reason for determining the cost of moving to
a new extreme point when a vector is added to a problem. Suppose we
are to solve problem (19) with a different objective function. We
might solve the problem without any of the either/or constraints and
then consider adding the constraint that forces F to be completed
before E. Since E has to start before G, adding this constraint also
forces F to be completed before G. We are essentially making two
decisions at once if we decide to force F to be completed before E.
For the enumeration procedures in the next chapter one decision
will frequently have multiple consequences. The importance of these
decisions justifies additional work in addition to simply calculating
gradients of the objective function. This will be shown in later
chapters.
CHAPTER IV
PURE SCHEDULING PROBLEMS
In Chapter III a method was developed to solve integer
programming problems that was particularly well suited to solving
scheduling problems and the method was illustrated by means of a
sample scheduling problem.
In this chapter we will be concerned only with scheduling
batch processes. We will not be concerned with how many batches are
to be made. We will assume we know how many batches are to be made
in each unit over a fixed time period and will try to find the best
schedule. This problem will be called the pure scheduling problem.
In Chapter III we solved a pure scheduling problem by adding
constraints one at a time to linear programming problems. At this
point we want to find the best of all possible schedules. One has to
find this optimal schedule and prove that it is optimal. One does
this by proving that no other schedule has an objective function better
than the objective function of the optimal schedule.
We also want to be able to find the best schedule and prove
its optimality in as few steps as possible. The amount of work
involved is a function of the order in which constraints are added
to our linear programming problems. We will look at two general
methods of adding constraints. One enumeration method developed by
14
Balas may not be as efficient as the other method but does not
require much storage of information when implemented on a computer.
The other method, the branch-bound method, was essentially developed
by Land and Doig.13 The branch-bound method requires more storage
of information than the Balas enumeration method but it usually
requires enumeration of fewer schedules. We will first look at the
Balas enumeration method.
Balas' Enumeration
In solving a scheduling problem constraints are applied
one at a time. We want to find all the possible schedules or find
some of the schedules and then prove that none of the remaining
schedules are better than one of the schedules we have already found.
A systematic way of investigating or eliminating all the possible
schedules is needed.
An example will be useful to show the Bales enumeration method
of finding the optimal schedule. We will use the example that was
developed earlier.
minimize
either/or
either/or
-30E 40F + 30G
E + 20 < F
F + 20 < E
F + 20 < G
G + 10 < F
such that
G < 60
F <40
E + 20 < G
I
Here we have a problem with seven constraints. The feasible
schedules will satisfy either Equation (25) or Equation (26). They
also have to satisfy Equation (27) or .Equation (28). Suppose we
solve the problem with none of the first four constraints applied.
Next we might solve the linear programming problem with the first
constraint added. Finally, we might find the schedule is optimal
when Equation (27) is also added. In our example for these first
three linear programming problems, the objective function is -1000.
One method of drawing a flow chart for these three steps is given
below.
(1) (2) (3)
25 28
1000 -1000 I-1000
(E before F) (G before F)
Figure 2. Flow Chart for First Two Linear Programs.
Using a computer it is necessary to store the same information
given in the above graph. A computer could store the list of numbers
(26, 25) when it started the second linear program. This would
signify that Equation (25) was the only either/or constraint in effect
during the program. Then the machine could store the list of numbers
(26, 25, 27, 28) when it started working on the third linear program.
One would want to store the results of the first feasible schedule
obtained.
The third linear program gives the best possible schedule that
satisfies Equations (25) and (28). We need to find the best of all
the possible schedules with Equation (25) satisfied that also solve
the original problem. In the language of integer programming we say
that we need to fathom all the solutions obtained from the partial
solution satisfying Equation (25).
When we start the linear program to solve the linear programming
problem satisfying Equations (25) and (27) the corresponding flow
chart might be drawn as below.
(2)
(1) (2)(3)
25 28
-1000 -1000
(E before F) 1 (G before
Figure 3. Flow Chart for Last Four Linear Programs.
We could store the same information in the computer in the
form of the list of numbers (26, 25, -27, -28). The negative sign
indicates Equations (27) and (28) have both been tried. We only did
enough work on the solution satisfying Equations (25) and (27) to prove
that the solution cannot have a value for the objective function smaller
than for the objective function for the feasible schedule we have already
obtained. Actually the best schedule satisfying Equations (25) and (27)
has an objective function of -400, but since the optimization procedure
did not find this schedule Figure 3 does not have -400 in the fourth
circle and the circle is not completed.
After we have fathomed all solutions from the partial solution
satisfying Equation (25) we need to look at solutions satisfying
Equation (26). The phrase used in integer programming is that we back-
track and find the partial solution satisfying Equation (26). Actually
we only need to prove that no solution satisfying Equation (26) is
better than the solution we have already found. When we backtrack
we would store the list (-26, -25) in the computer since the only
information we need is that we have fathomed the solutions satisfying
Equation (25) and we are working on fathoming the solutions satisfying
Equation (26). The best schedule satisfying Equation (26) has an
objective function of -200. The final flow chart is given below and
the computer would no longer have any numbers in the list it was
storing.
lQ 25 28
r-1000 --- -101000
. (E before F) (G before F)
Figure 4. Final Flow Chart for Sample Problem.
Other pure scheduling problems can be solved in a similar
manner. One needs only to apply a constraint from each of the either/or
pairs and then solve the linear programming problem. One then back-
tracks and fathoms until all schedules are either found or eliminated.
This Balas enumeration method of solving the problem has the advantage
that we never have to store more than one solution and one list.
Other advantages and disadvantages will be discussed when we look at
another method of solving the problem. The Balas enumeration method
used here fathoms partial solutions until the entire problem is solved.
The other method (branch-bound) of solving the problem may run into
storage problems and then we can use the method developed here to
fathom partial solutions found by the other method.
A program has been developed and implemented in the Fortran
language to solve problems in the manner illustrated by the previous
sample problem. The linear programs are solved in the dual in a
manner similar to that given in Chapter III. To show some of the
details of how the program works we will again look at an example.
We will suppose that two products, E and F, can each be made
in two reactors, Rl and R2, and that the product from each reactor is
held in intermediate inventory until it is processed by a separator.
For the purposes of the problem we will suppose that output from the
separator can be sold immediately so there is no inventory created by
the separator and in this problem that we do not have to keep feed for
the reactors in inventory.
Ri
S Intermediate
Inventory
R2
Figure 5. Flow Sheet for Intermediate
Inventory.
We will be concerned with batch units and suppose that we know
the time it takes to produce each batch and the amount it costs to
store a batch of feed for the reactors or the separator.
Table 1
Table of Data for Sample Problem
Batch ER1 ER2 ES FR1 FR2 FS
Time to produce batch 3.7 4.2 2.1 4.6 4.7 2.6
Cost of keeping batch one
unit of time in inventory 5.0 5.1 5.0 6.2 6.4 6.0
Let's assume that we produce a batch of E in each reactor
over a period of time and a batch of F in each reactor over the same
period. Also assume that we are to process two batches of E and two
batches of F in the separator. Let the variables be:
tER1 the time we start the batch of E in reactor 1
tER2 the time we start the batch of E in reactor 2
tElS the time we start the first batch of E in the separator
tFR1 the time we start the batch of F in reactor 1
etc.
We will have the constraints that the first batch of either
kind through the separator will precede the second batch of either
kind.
There are the constraints that two batches cannot be processed
through the separator at the same time. For instance, either the first
batch of E through the separator has to be completed before the first
batch of F begins or the first batch of F has to be completed before
the first batch of E begins.
tEis + 2.1 < tIS
either/or t + 2.6 < tElS (32)
tFLS i 2S6 ( tEIS
There are six pairs of either/or constraints of this type.
We will suppose that all of the batches are completed by the
time 9.5. This gives the constraints:
tER1 +3.7 9.5
tER2 + 4.2 9.5 (33)
tESl + 2.1 < 9.5
etc.
Assume also that there is not enough inventory to feed the
second batch of either chemical through the separator until we have
finished making some of the chemical in a reactor.
tER1 + 3.7 < tE2S
either/or tER2 + 4.2 < tE2S
(34)
tFR1 + 4.6 tF2S
either/or
tFR2 + 4.7 < tF2S
Of course the first batch of E has to be completed in the
separator before the second batch begins. The first batch of F in
the separator has to be completed before the second batch ends.
tS1E + 2.1 tS2E
(35)
tSlF + 2.6 < tS2F
Our problem is a minimization problem minimizing
(-5.0tERI -5.1tER2 +5.0tE1S +5.0tE2S -6.2tFR1 -6.4tFR2 +6.0tElS +6.0tE2S)
subject to constraints like Equations (33) and (35). In addition the
optimal schedule satisfies one constraint from each pair of constraints
from Equations (32) and (34).
As was done earlier our problem is solved in the dual. The
dual problem has some variables associated as pairs.
Primal
minimize c.t such that
either/or constraints Alt < b
A2t b (36)
2 -2
t > 0
Pairs of constraints from Equations (32) and (34) make up the set
At < bl' Only one constraint from each pair has to be satisfied.
Dual
maximize blx1 + b2x2 such that
Aix + Ax2 > c
minimize (36)
x > 0 x2 > 0
and one member of each set of paired variables
if x1 has to be constrained to 0.
We minimize by finding the set of variables of xl which can be con-
strained to 0 and the maximization problem will have a minimum value.
In the dual the pairs of associated variables correspond to
the pairs of associated constraints from Equations (32) and (34).
The final solution in the dual will have one member of each pair of
associated variables free to take on any nonnegative value and one
member of the pair constrained to zero.
First, the problem is solved with all the pairs of associated
variables constrained to zero. This corresponds to solving the primal
problem without constraints from Equations (32) and (34). The linear
programming problem resulted in an objective function of -91.03.
The result of a linear programming problem with n variables
and m constraints will be that n m of the variables will be zero
and, except for a trivial case, some of the m basis variables will
be nonzero and positive since required by the problem. Linear
programming provides a rather simple method of removing one variable
from the set of basis variables and finding a feasible solution to
the problem with a different variable in the basis. The program uses
this method to find how much the objective function will change if one
variable is removed from the basis and one of the either/or variables
is put in the basis. For example the variable corresponding to the
constraint,
tER1 + 3.7 tS2E (37)
can be put in the basis and the objective function will increase to
-54.03. Actually the dual problem (Equation (36)) was formed and
Equation (37) was represented by variable one in the dual. We can
find how much the objective function will increase by putting any one
member of the either/or pairs in the basis. The program found that
putting variable 12 in the basis would increase the objective function
more than putting any other member of the either/or pairs in the basis.
As the problem was formed variable 12 corresponded to the constraint;
tS2F + 2.6 s tS (38)
The other member of the either/or pair, variable 11, corresponded
of course to the constraint;
tS1E + 2.1 tS2E (39)
The objective function increased to -39.03 when variable 12
was put in the basis so there was a good chance that a solution to
the problem would be found with a smaller value of the objective
function. The linear program was solved with variable 11 free and
variable 12 constrained to be zero.
-39.03 Putting variable 12 in basis will
increase objective function to -39.03.
(1) o'0(2
-91.03 -91.03 Optimal schedule with SlE
(SlE before before S2F. Result of
S2F) linear program gave objective
function of -91.03 with
variable 11 free and variable
12 constrained to zero.
Figure 6. Early Stages in Solution of Sample Problem.
The linear program with all either/or variables except 11
constrained to zero gave an objective function of -91.03. We repeat
ourselves by finding how much the objective function will increase by
adding one more member of the either/or set to the basis. We again
find the variable, x13, which will increase the objective function the
most if it is added to the basis. We find that x13 and x14 make up an
either/or pair and we allow variable x14 to be free while constraining
x13 to be zero.
The computer initially stored the numbers (12, 11) in a list
to record that solutions with variable 11 free were to be fathomed and
that solutions with variable 12 free were to be fathomed next. A
flow chart of the first several decisions is shown and the list is
given.
Computer list (12, 11, 13, 14, 3, 4, 7, 8)
44
(1) (2) 14 (3) 4 (4) (5)
(S1E before (SiF before -- (FR2 before (FR2 beforeO
S2F) S2E) F2S) ER2)
Figure 7. Flow Chart Showing First Four Decisions Made in Solving
Scheduling Problem.
On the next step we find that variable xl will increase the
objective function the most if it is added to the basis. We constrain
variable xl to be zero and solve the linear programming problem with
variable x2 free. This linear programming problem turns out to have an
unbounded solution so we backtrack and look at solutions with x1 zero
and x2 free. An unbounded solution in the dual corresponds to
infeasibility in the primal.
SV v v (AR2 be--
fore A2S)
Figure 8. Flow Chart Showing Backtracking After
Sixth Linear Program.
This linear
program had un-
bounded solution
so backtrack
We continue our solution procedure until we arrive at the
first feasible solution and then we start to backtrack. The first
feasible solution had an objective function of 10.65.
Figure 9. Continuation of Sample Problem to
First Feasible Schedule.
Feasible
Schedule
We find a solution with the tenth linear program and we need
to backtrack. The solution we obtained for the tenth program had
variable 16 constrained to zero and variable 15 free. We can backtrack
and solve the linear program with variable 15 free and variable 16
constrained to be zero but this is not necessary. The objective
function for such a problem would reach 13.89. We only need to start
the linear programming algorithm and then we can backtrack again as
soon as we obtain an objective function above 10.65. The running list
the computer uses would be (12, 11, 13, 14, 3, 4, 7, 8, -1, -2, 6, 5,
10, 9, -16, -15) as we start the linear programming algorithm for the
eleventh time and afterwards would be (12, 11, 13, 14, 3, 4, 7, 8,
-1, -2, 6, 5, -10, -9).
The program continued to fathom and backtrack in this manner
until the problem was solved. Whenever one deals with real numbers
there is the possibility of round-off errors. The inverse matrix of
the pure scheduling problem has all integers and will not develop
errors. Along with the objective function, there is also a vector of
real numbers which are used and altered by the linear programs. These
numbers can be generated correctly from the inverse matrix but the
corrections take time. The program generates the correct values at
every solution. Allowances for round-off can be made by estimating the
maximum round-off error. Backtracking will not take place from a
partial solution unless the partial solution has an objective function
greater than an earlier solution plus the maximum error estimate.
Another feature of the program can be seen by the way the given
problem was actually solved. Eventually the program fathomed all the
solutions with variable 11 free and variable 12 constrained to be
zero. Next the solutions had to be fathomed with variable 12 free and
variable 11 zero. Variable 12 corresponds to the constraint which
forces the second batch of F in the separator to be finished before
the first batch of E begins. This constraint is not consistent with
the constraint which would force the second batch of E to begin before
the second batch of F. The variable corresponding to the inconsistent
constraint must be zero for a feasible solution on this branch of the
tree. Also, if the second batch of F begins before the first batch of
E we do not need the constraint which would force the second batch of
F to begin before the second batch of E. We might as well constrain
the variable corresponding to the unnecessary constraint to be zero
on a branch if we decide to free one particular variable.
The optimal schedule is given below. It had an objective
function of 7.19. Without the program one would have to set up and
solve 96 linear programs. The machine solved the problem with a C.P.U.
time of 2.89 seconds on an IBM 360/65 computer.
Table 2
Optimal Schedule for Sample Problem
Batch ER1 ER2 E1S E2S FR1 FR2 F1S F2S
Starting time 5.8 .5 0 4.7 1.2 4.8 2.1 6.8
Branch-Bound Enumeration
Earlier the Balas enumeration method was used to schedule
operations in a process where the product from two reactors fed a
separator. Next we will use branch-bound enumeration to solve the
same problem. Again we will look at how the specific problem was
solved using a particular solution procedure.
Once more we solve the problem with none of the either/or
constraints applied. Again we use the dual and find that putting
variable 12 in the basis would increase the objective function more
than putting any other member of the either/or pairs in the basis.
Again we want to look at the result of having variable 11 free.
Variable 12 corresponds to finishing the second batch of F in the
separator before starting the first batch of E. Variable 11
corresponds to finishing the first batch of E in the separator before
starting the second batch of F.
The objective function increases to -39.03 when variable 12
is put in the basis. This time the solution procedure will tell the
computer to store the number -39.03 and enough information to generate
the partial solution with variable 12 in the basis.
Putting variable 12 in basis will
increase objective function to
-39.03 -39.03. -39.03 stored in computer
along with enough information to
regenerate solution.
(1) j/ (2)
-91.03 -91.03 Optimal schedule with S1E before
S1E before S2F has objective function of
S2F -91.03.
All either/or variables
constrained to zero
Figure 10. Flow Chart for First Step in Solving Sample
Problem Using a Branch and Bound Enumeration
Procedure.
Next the solution procedure looks at putting an either/or
variable in the basis in addition to variable 11. Again we find the
variable, 13, which increases the objective function the most. Except
for the storage of additional information, the branch-bound procedure
is the same as the Balas enumeration procedure until the fourth
partial solution is found.
-39.0 -40.6 -47.1
(1) (2) (3) (4)
.11 n 14 /4
91.0 -91.0 -------- 88.5 -----46.1
Figure 11. Flow Chart for Branch-Bound Procedure
up to Fourth Partial Solution.
Figure 11 shows the results up to the fourth partial solution.
Enough information was saved to find the partial solution obtained
by freeing variables 11, 14 and 3. The objective function of this
partial solution will be larger than -47.13 but it may be smaller than
the objective function of the fourth partial solution.
In the branch and bound method, enough information is stored
to reproduce the fourth partial solution and the partial solution with
variables 11, 14, and 3 free is found. (5)
n-6.3
Figure 12. Flow Chart Including Fifth Partial
Solution.
The question to be faced next was whether to branch back to
the fourth partial solution or to continue working on the fifth partial
solution. There is a certain amount of work the computer has to do
in order to switch consideration from one partial solution to another.
On the other hand, by adding constraints to the fourth partial solution
we might find a solution which has an objective function smaller than
-46.39. In that case any work done on the fifth partial solution would
be wasted effort for no solution derived from the fifth partial solution
can have an objective function smaller than -46.39.
Some research is needed on when a solution procedure should
switch attention from one partial solution to another. The computer
program written uses a number, zb, to make its decisions. If the
program is working on a partial solution with an objective function, z,
then the program will switch consideration to another partial solution
if and only if the other partial solution has an objective function
less than z zb.
The program was run with an arbitrary value of zb = 1.0 so
the program switched from the fourth partial solution to the fifth
partial solution but did not switch back again until later. If zb
is very large a program will spend a large amount of time looking at
nonoptimal solutions. zb shouldn't be any smaller than the possible
error in the data. One shouldn't try any optimization that can't be
justified by the original data.
The branch-bound procedure takes advantage of the structure
of the problem as did the earlier method. Eventually the partial
solution with variable 12 free had to be investigated. This corresponds
_ ~~~~
to the second batch of F in the separator being completed before the
first batch of E in the separator. The algorithm never considered
adding constraints forcing the first batch of F in the separator to
be completed before or after the second batch of E.
The linear programming and branching algorithms ignore the
ith constraint if the ith member of a vector of logical variables is
set free. The computer has to do some work to set up the proper
linear program when the partial solution with variable 12 free is
investigated. This work is not done until the machine investigates
the partial solution. Sometimes information is stored on partial
solutions which are never investigated. Any extra work on such partial
solutions is unnecessary.
If an incumbent feasible schedule is found with an objective
function, zi, then no work need be done on partial solutions whose
objective functions are larger than zi. The program which was written
stopped work on a partial solution whenever the objective function
got larger than such a zi. Partial solutions with large objective
functions were removed from storage whenever a new feasible schedule
was found.
One advantage of the new branch-bound algorithm is that fewer
partial solutions have to be investigated than by the Balas enumeration
method. If the number, zb (previous page), is set at zero we will not
look at any partial solution whose objective function is larger than
the optimal solution. This will happen for the Balas enumeration method
only in the lucky case where the optimal solution is the first feasible
solution found. Nineteen partial solutions were investigated using
the branch-bound method and thirty-four partial solutions were
investigated using the Bales method.
Some extra work was required in storing and retrieving information
for the branch-bound method. It took 4.85 seconds for the computer to
solve the problem using branch-bound and 2.89 seconds using Balas
enumeration. Balas'enumeration had been compiled to produce only 278
lines of output as compared with 391 lines of output for the newer
method. Storage of information and output takes some C.P.U. time.
The branch-bound method also required more storage space. 2034
bytes of information had to be in common storage for the branch-
bound method and 1518 bytes of information had to be in common
storage for the other method. Actually one doesn't know how many
partial solutions will have to be stored for the branch-bound method.
A Solution to the Storage Problem
One problem with the branch-bound just developed earlier is
that an enormous number of partial solutions have to be stored in a
realistic problem. There is no way, short of solving the problem,
to tell how many partial solutions will have to be stored.
A large problem might have so many partial solutions that the
branch-bound method cannot be used on a particular computer. It is
possible to use auxiliary storage devices but retrieval of information
becomes slow. On some computers the rate of retrieval of information
in core storage is affected by the amount of information stored.
A method which has been programmed is to assign a fixed number
of storage locations for partial solutions. As long as.the storage
space is not exceeded, the program uses the branch-bound procedure on
a scheduling problem. Once the storage space is filled the program
completes the best partial solution by fathoming and then returns to the
branch-bound method until fathoming has to be used again or the problem
is solved.
The same problem was solved that was solved earlier by two
different methods. When we used the branch-bound method storage
locations for ten partial solutions had to be used.
The problem was run using only the storage space for four
partial solutions. When the program had four partial solutions stored
it fathomed the partial solution it was working on. Luckily the
optimal solution was a result of fathoming this partial solution. 25
partial solutions were investigated as compared to nineteen using
pure branch-bound and 34 using pure fathoming. The third solution
procedure took 4.19 seconds for 684 lines of output.
Optimization Strategies
In the latter part of Chapter III we looked at the information
available on the effect of adding a variable to a linear programming
problem. The value of this information can be evaluated now that we've
developed some enumeration techniques.
We could use the gradient of the objective function in order
to make our scheduling decisions. The gradient is easy to obtain but
it does not show how much the objective function will increase if a
variable is added to a linear programming problem.
One can determine how much the objective function increases
when a given variable, L, is added to the basis. If the objective
function will be larger than the objective function for a known
schedule then one knows adding L cannot be part of an optimal strategy.
In the example of Chapter III we saw how one decision could
have multiple effects. We knew that process E had to be completed
before process G was begun. This meant that the decision to begin
process F before E also meant that F would begin before G.
We will frequently encounter multiple batches in chemical
scheduling problems. If one schedules a batch E before the first of
many batches F then one has scheduled E before all of the batches of F.
The multiple effects of one decision should justify the effort of
finding how much the objective function increases when a variable is
added to the basis. Also this lower bound of the objective function
makes possible our branch-bound method of enumeration.
In the branch-bound method we switched our attention from one
partial solution to another. One would like to be able to reproduce
a partial solution without having to solve the linear program formed
by the variables used in the partial solution. The partial solution
can be reproduced if one has the inverse of the matrix formed from
the basis vectors. Storage of an entire matrix for every partial
solution is difficult. One could merely store information on which
vectors were in the basis. Then one has to invert a matrix in order
to reproduce a partial solution. For matrices used in the pure
scheduling problem, a simple method for matrix inversion has been
developed in Appendix A.
Thslanumeration methods developed reduced backtracking by
finding the vector which would increase the objective function the most.
This strategy is especially effective if one has a good incumbent
solution. Suppose one examines a partial solution and has an incumbent
solution with an objective function of -60. Suppose the partial
solution has an objective function of -5. Suppose one has to add
three either/or decisions to the partial solution and the effect of
adding each vector to the basis is as given below by Figure 13.
zi = -60
z = -80 -40 -10
-5 z -65 5 -20 -5 -5
Effect of putting Effect of putting Effect of putting
vector Al or A2 in vector Bl or B2 in vector Cl or C2 in
basis, basis. basis.
Figure 13. A Partial Solution with Three Remaining
Either/Or Choices.
Our enumeration methods would find that adding vector Al to
the basis would cause the objective function to exceed zi. Al would
be eliminated from consideration and then A2 could be eliminated for
the same reason. No further work would have to be done on the partial
solution.
Let us look at another example of a partial solution with an
incumbent solution.
zi -60
-80 -65 -60
A2 -30 -5 -20 -5-10
Figure 14. A Partial Solution Where Three Either/Or
Choices Can Be Made at Once.
For the example shown in Figure 14 we would eliminate vector
Al from consideration. One need not solve the problem with A2 but
could also use the lower bounds on adding Bl and Cl to the problem.
With vectors Al, Bl, and Cl eliminated, one need only solve the
problem with vectors A2, B2, and C2 in order to fathom the partial
solution given in Figure-14.
CHAPTER V
ENUMERATION OF MIX/SCHEDULING PROBLEMS
In Chapters I and II a product mix problem for batches was
formulated. In order to solve the batch product mix problem one must
decide which batches are to be made and how they should be scheduled.
All of the enumeration techniques developed in Chapters III and IV
also will be used for solving batch product mix problems. Some
additional enumeration techniques are developed in this chapter in
order to take into account the special structure of batch product mix
problems.
In Chapter III scheduling decisions were written as a set of
either/or choices. The decisions for batch product mix problems can
also be written as a set of either/or choices. Suppose we are to make
between two and four batches of a particular type and let xij be the
number of batches to be made. The decisions can be written as
either/or choices.
x 4 (40)
either/or
x 3 (41)
x i 3 (42)
either/or J
xij < 2 (43)
Equations (40) through (43) together with bounding
(2 < xij < 4) express the fact that xij is integer. Variables for
the number of batches made over a time period are bounded because
only a certain number of batches can be made in a fixed time period.
Since integer variables can be expressed as either/or choices the
techniques of Chapter III can be used for the batch product mix
problem.
In Chapters III and IV one decision would sometimes have
multiple consequences. This feature is also present for variables
such as xij since the decision to use Equation (40) is inconsistent
with the decision to use Equation (43). Equation (40) also makes
Equation (42) redundant. It is obvious that if xij is greater than
an integer n that it is greater than an integer m if n > m. This fact
13,17
has been used before in solving integer programs.117 Actually
Trotter17 used only this fact in addition to the enumeration schemes
of Balasl4 and found he could solve the same integer problems faster
than with the Balas enumeration scheme.
Trotter's17 programs are written for integer variables so he
would have to add integer variables to a problem in order to express
either/or choices such as Equations (11). Additional variables make
a problem more complex. Our problems are solved in the dual using
the revised simplex method. In the dual Equations (40) through (43)
would be represented as variables. In the dual, the choice corresponding
to Equation (40) will imply that the variables corresponding to
Equations (41) through (43) are constrained to zero. By using the
revised simplex method, one can ignore any information about variables
which are constrained to zero.
The batch product mix problem optimizes operations over a fixed
time period T. In Chapter II (see Equations (9) and (10) and
discussion) we showed that the mathematically correct objective function
could be obtained if the decision not to produce a particular batch
is expressed with this particular batch having a starting time of T.
It is desirable to have a method where one either/or decision
can imply another. This feature is implemented in the optimization
methods of Chapters III and IV. If one decision can imply another,
it is easy to integrate the scheduling and production rate decisions of
batch product mix problems. Since one decision can imply another, one
only needs two either/or choices to integrate Equations (40) through
(43) with scheduling decisions
tij4 i (44)
either/or
tij4 7 (45)
tij3 Pi3 i tij4 (46)
either/or
tij3 (47)
Equations (44) through (47) together with bounding
(0 < tij3 1 tij4 1 ) express the equivalent scheduling decisions as
the production decisions of Equations (40) through (43). Equation (40)
should imply Equation (44) and vice versa since batch 4 of i in j has
to be scheduled in the time period if it is to be made. Equations (42)
and (46) imply each other since the third batch of i in j is finished
before the fourth batch if it is to be made.
In Chapter III we struggled with formulating scheduling
constraints correctly so that the batch product mix problem could be
written as an integer programming problem. The scheduling constraints
come from the fact that a batch production unit can only operate on one
batch at a time.
For one of the batch product mix problems a product, W, could
be made in two separators, S2 and S3. SW2 represented the number of
batches of W made in S2 and SW3 represented the number of batches of W
made in S3. A batch of S2 produced 12.74 pounds of W and a batch of
S3 produced 13.44 pounds. At least 23 pounds of W were needed over a
fixed time period. A simple material balance is given by Equation (48).
12.74 SW2 + 13.44 SW3 > 23.0 (48)
SW2 and SW3 are integer for any feasible product mix since
we only consider an integer number of batches. For integers SW2 and
SW3 Equation (43) is equivalent to Equation (49).
SW2 + SW3 > 2 (49)
Any integer solution which satisfies Equation (49) also
satisfies Equation (45). Any integer solution excluded by Equation (45)
is also excluded by Equation (49). Equation (49) was used instead of
Equation (48) since Equation (49) can be used to eliminate some either/or
choices from consideration. For example if the decision is made that
SW2 < 0 then Equation (49) will force SW3 > 2. With SW3 > 2 Equations
(50) and (51) can be eliminated from consideration
SW3 > 2
either/or (50)
SW3 < 1
SW3 > 1
either/or (51)
SW3 < 0
Equations similar to (48) were simplified wherever possible
in order to eliminate some either/or choices from consideration.
The enumeration schemes were implemented on a computer and the computer
was able to store the information that the decision SW2 > 0 eliminates
Equations (50) and (51) from consideration. Storage and retrieval of
information takes time. One has to decide how much effort should be
expended in order to eliminate some either/or choices from consideration.
Trotter6 has shown that some effort should be expended to eliminate
either/or choices.
So far we have only shown how one decision can eliminate some
either/or choices from consideration. Sometimes two decisions can imply
a third decision. For example, look at Equation (52).
D + E + F > 3 (52)
If D, E, and F are integers the decisions E < 0 and F < 0 imply
that D > 3. In other words, the decision D < 2 is eliminated from
consideration. General programs were written so that any number of
decisions could be made to eliminate an either/or choice from
consideration. For the smaller of the two example problems formulated,
the author tried to find all instances where one or two decisions would
imply a third decision. For the larger of the two problems, the author
only tried to find those instances where one decision would imply
another. This information is fed into the written computer programs as
data. A subprogram could be written to generate this data from
equations similar to Equations (48) and (52).
The smaller of the two problems formulated involved producing
and scheduling the same type batches as were scheduled in Chapter IV
(see Figure 5). The process involved two reactors and a separator.
Two products, E and F, could be processed in either reactor and then
processed through the separator. The batch times and inventory costs
are the same as those given in Table 1. Again we are to optimize
operations over a time period of 9.5 but this time we have to decide
both how many batches are to be made and how to schedule them.
Once more we assumed that there was enough beginning inventory
to feed either a batch of E or F to the separator. Feed for any
additional batches in the separator had to be made by the reactors.
It is not too difficult to schedule sufficient inventory for
the second batch of E in the separator. One merely needs constraints
to say that one of the batches in the reactor must proceed the second
batch in the separator.
ER11 + 3.7 1 tES2 (53)
tER21 + 4.2 tES2 (54)
It is more difficult to schedule the third batch of E in S.
The problem assumed two batches had to be produced in a reactor before
the second batch could be made in the separator. One really has four
choices for producing feed for the third batch of E in S.
either tER11 + 3.7 < tES3 (55)
/or tER12 + 3.7 < tES3 (56)
/or tER21 + 4.2 < tES3 (57)
/or tER21 + 4.2 < tES3 (58)
~ ~
Feed for the third batch of A could be produced by either the
first or second batch of either reactor. Again we need the ability
for one decision to imply another. The solution procedure could not
choose both Equations (53) and (55) since the same batch from a reactor
could not be used to feed two batches in the separator. Similar equations
to Equations (53) through (55) were formulated for chemical B.
The costs used in this small batch product mix problem are
given in Table 3. A total of 121 equations were written to formulate
this fairly simple batch scheduling problem. One hundred of the
equations were of the either/or type. The optimal schedule and an
interpretation of the results are given in Chapter VI.
Table 3. Batch Costs for Sample Batch Product
Mix Problem
Batch E in R1 E in R2 E in S F in RI F in R2 F in S
Cost 27.0 29.0 -197.0 27.0 29.0 -243.0
A large batch product mix problem was formulated to incorporate
the features of a realistic chemical engineering problem. The problem
included recycle streams due dates for some materials, different
starting inventories and available time for as many as 20 batches on
one machine. The flow sheet for the large batch product mix problem
is given by Figure 15. Information on the batch characteristics
and beginning inventories is given by Tables 4 and 5. The inventory
costs are the difference between the cost of storing product minus the
Table 4. Batch Characteristics for Large Batch
Product Mix Problem
Batch Cleanout Batch Inventory
Process Unit Time Time Cost Cost
1 R1 2.5 0.0 525 -9.70
1 R2 3.0 0.0 500 -8.82
1 S1 3.2 0.0 225 .52
1 S2 3.1 0.0 225 .14
2 S1 4.1 0.0 -873 -2.25
2 S3 3.9 0.0 -1109 -2.62
3 R2 3.0 0.5 135 -.88
3 R3 2.5 0.5 150 -1.10
3 S2 1.1 0.0 -2369 -.96
3 S3 1.0 0.0 -2509 -.68
4 Rl 2.1 0.0 90 -2.94
4 R3 1.8 0.0 100 -3.23
4 S1 6.2 0.0 -501 -5.14
4 S3 6.6 0.0 -560 -8.00
5 S1 5.1 0.0 -201 -1.54
5 S2 5.4 0.0 -129 -.68
Table 5. Chemical Inventories and Batch Sizes
Beginning Inventory
Not limited
Consumers
Unit Amount
R11 10
R21 9
Producers
Unit Amount
L 0.0 S11 12 Rll 9.7
S21 14 R21 8.82
E 25.0 S12 9 S11 6.60
S32 11 S21 8.40
R23 4
R33 5
Q 37.0 R14 7 S11 3.84
R34 8 S21 4.20
S14 1.00
S34 1.05
S15 2.80
S25 3.75
D 32.0 S15 14 S12 .81
S25 15 S32 1.32
S15 5.60
S25 5.25
K 0.0 S23 13 R23 4.4
S33 14 R33 5.5
U 0.0 S12 8.10
532 9.57
W 0.0 23 12.74
S33 13.44
G 25.0 S14 20 R14 6.65
S34 21 R34 7.52
S14 2.40
S34 2.94
H S14 14.00
S34 15.54
Chemical
F
Table 6. Feasible Schedule Found for Batch
Product Mix Problem
Batch
R11
Batch Number
1
2
3
Starting Time
S3.4
5.9
8.8
R23 1 0
2 3.0
3 6.0
4 9.0
5 13.0
6 16.0
R34 1 2.2
2 4.0
3 5.8
4 10.2
5 12.0
R33 1 16.5
514 1 7.6
2 13.8
515 1 2.5
S21 1 8.4
2 11.5
S25 1 14.6
S33 1 12.0
2 19.6
S32 1 15.1
S34
1
cost of storing feed. Operations were to be optimized over a time
period of 20. A shipment of 10 units of W was due at 13.0 and a
shipment of 13 units of W was due at 20. A shipment of 40 units
of H was due at the final time but no additional H could be sold.
The author found that it took 548 either/or equations to force the
inventory of L positive over the whole time period regardless of
how many batches were made. For this reason the author left out
constraints to keep inventory positive over the whole time period.
The approximation used assumes that some inventory could be
bought if needed and resold at the end of the period with negligible
cost.
Both of the batch product mix problems were solved using the
Balas enumeration procedure of Chapter IV. The enumeration procedure
works better with a good incumbent solution and the author found a
feasible schedule to the large batch product mix schedule. This
feasible schedule is given in Table 6. The feasible schedule was
used as an incumbent solution which increased the efficiency of the
solution procedure. The solution procedure loola for objective
functions which were at least $10 better than the incumbent solution.
A discussion of results is found in Chapter VI. The results are
compared with work by other authors in order to make them more
meaningful. This comparison is done in the first section of
Chapter VI.
Process 1
E
U (Product)
D
Process 2
Process 3
W (Product)
Process 4
Process 5
N (Product)
C
Q
U (Product)
Q
D
Figure 15. Second Batch Product Mix Problem.
CHAPTER VI
RESULTS, CONCLUSIONS, AND RECOMMENDATIONS
The purpose of this work was to find a method of scheduling
batch chemical operations. The method found takes large amounts of
computer time if one wants to find optimal schedules for normal sized
chemical scheduling problems. The method can find near optimal solutions
with a moderate amount of computing time and has the advantage that
the limit of suboptimality is expressed in dollars. That is the program
can find a solution such that the objective function is within at
least a certain number of dollars of being the optimal solution.
Solution Efficiency
The quality of the new scheduling method can be seen by
comparing results with other methods of solving discrete optimzation
problems. Table 7 shows published results of solving integer programming
problems by a number of methods.
As mentioned earlier, Trotter7 uses the Balas enumeration
method but reduces the size of the problem by using integer variables
instead of 0-1 variables. Trotter reduces the size of a problem by
realizing that x > 4 implies x 3,2.... Our program can do that in
addition to reducing the size of a problem by other methods.
Trotter's programs only solve problems where all of the
variables are integer. These problems are simpler than scheduling
problems because there is a method of solving pure integer problems
without using linear programming. One has to check each constraint for
feasibility and use a method which guarantees feasibility while optimizing
the problem.
I
0--
'a
0 V
o d o
41l *ri
40
40 0
H (
0
1 4
(2
to
M l
14
I
0
(A
14 -4
S.
1
f0Ln N -o mo
AI
n4 10
,r n% II
0Ouo 0n in VN n Iin o iniL
cmmn NN Cn NIT Va 0 cn n r,
Sr-l vv N
N4 N4 If u-I -4
NN n -l i4
O0 CON M 4M M4
o Go N N4 .-
M r -i n oo
emn I Nr-I
knC Otn ooooo-cnm
v -1- -Is- NO
aoN Prn N M CnOoo00 soo o0r-2m
Ns NC 4-I i4 n Lu .. 4 m.-.-4 C N
cn -T NO a- a0% 4 ,T 1 -I4 cn
0
N
%0 CM
00 -.4
4 CO v-
c T< enrn
M4 Nn 0% 00 co
H1-4 N C4 4 -
1-
A
INm ONO N 0 U N0( 1 n
CN M aCO10 N
T -: 1- 0
SI I I - N-4
1-
-l
I.-
r
0 -4
14 01
0 A-I
.5 A-i
AI 0
Trotter uses more than one method to optimize his problem and
the best and worst results are listed in the table. Trotter's
solution methods are highly dependent on how many constraints are
present and he did not solve a problem with as many constraints as
two of our problems. Trotter used a CDC 6600 computer for his programs.
18
Shareshian8 has presented a program to solve mixed integer
problems by the branch-bound method. Unfortunately the program was
only for some pure integer problems. Shareshian's results look
comparable to ours except for the number of constraints and the way
the problems are formulated.
In Chapters III, IV and V we found a method of formulating
decisions as either/or choices without using 0-1 variables. Every
solution method listed on Table 7 except the method of Greenberg would
have to use these 0-1 variables. For the other methods our example
problem would have 16 (8 + 8) variables, Problem 2 would have 55
(21 + 34) variables and Problem 3 would have 363 (93 + 270) variables.
Both Shareshian's work and this work solve a number of linear
programs in the dual. The difficulty of solving these problems is
proportional to the number of variables in the primal. Shareshian's
results were calculated on an IBM 360/50 computer.
Shareshian's program would also have to add an additional set
of variables to integrate production decisions with the scheduling
decisions of the second and third sample problems. In Chapter II we
first saw that some scheduling decisions do not apply if one decides
not to make the batches scheduled. It would take 32 additional
variables to write the second sample problem for a normal integer
programming algorithm and 116 additional variables to write the third
problem. Shareshian's test problems were solved on an IBM 360/50.
Driebeckl9 developed an algorithm for mixed integer problems
that is somewhat similar to the method developed here. Driebeck uses
a lower bound on the cost of making a decision and uses this bound to
determine his solution strategy. Driebeck also has to solve a new
linear programming problem at each iteration as we did. Driebeck's
method does have a very bad flaw. Driebeck uses a table which initially
contains information on every possible integer solution. Driebeck's
table has a vector for each integer solution. The 2540 vectors
necessary for our third sample problem would certainly be too much
for any present day computer to handle.
Greenberg6 was the only other author found who also realized
that 0-1 variables are unnecessary for scheduling problems. Greenberg's
results do not look very good because he used a random method of adding
constraints to a problem and he did not take advantage of the structure
of the problem as this author did. Greenberg used a G.E. 265 Time-
Sharing System.
20
Dzielinski found a method of approximating a restricted class
of scheduling problems by a linear program. Dzielinski formed a linear
program which contained a cost and set of constraints for every possible
schedule. Dzielinski, like Greenberg, would run into serious problems
with a scheduling problem like sample problems two and three.
Dzielinski did not write all his constraints but used the decomposition
principle to handle the problem. Dzielinski's iterations are each
simple linear programming iterations but he has to perform a huge
number of iterations to solve the program. Dzielinski used an
IBM 7090 computer.
21
Trauth21 solves some pure integer programming problems using
several cutting plane methods. His best and worst results are listed
for several problems. His best solution times were on a CDC 3600
computer and the worst were on an IBM 7090 machine.
All of the author's work was done on an IBM 360/65.
Results
The results given in Table 7 indicate that the method developed
here for solving scheduling problems is a better method than other
integer programming techniques. Unfortunately most of the work on
integer problems has been on problems of the size of our second sample
problem and realistic chemical engineering problems are at least the
size of the third sample problem. The reader should remember that only
eight extra 0-1 variables will increase the number of integer solutions
by more than one hundred if all the solutions are feasible.
The optimal schedule for the small batch scheduling problem
described in Chapter IV is given by Table 8. There are several
interesting features of this schedule. For one thing one should note
that the product mix result is to produce two batches of each type in
the separator. The operating units could produce more F and less E
which is more profitable, if there were no inventory costs. A batch
product mix problem would get the wrong answer if it ignored inventory
costs.
Table 8. Optimal Product Mix and Schedule for Sample
Problem 2
Chemical Unit Batch Starting Time
E R1 1 1.1
F R2 1 2.2
E S 1 0.0
E S 2 4.8
F S 1 2.1
F S 2 6.9
There is very little slack time in the separator but there is
some slack time in both reactors. This slack time could be used for
building up inventory for future operations.
Suppose one decides to use the slack time in RI to produce a
batch of E and the slack time in R2 to start producing product F. The
next production period would have a batch of E for feed to the separator
and a batch of F for the separator 2.2 hours after the start of the
second time period. If the batch of F was available by 2.1 the
optimal schedule for the second time period would be the same as the
schedule for the first time period. This schedule for two time
periods is given by Table 9. The result on Table 9 may not be the
optimal product mix and schedule over two time periods but it is
feasible for the beginning inventory and the schedule can be duplicated
for any number of time periods. Thirty-five seconds' computer time is
certainly a cheap way to get a feasible schedule for any number of time
Table 9. Schedule for Two Time Periods
Chemical Unit Batch Starting Time
E R1 1 1.1
E R1 2 5.8
E R1 3 1.1 + 9.5
E R1 4 5.8 + 9.5
F R2 1 2.1
F R2 2 6.8
F R2 3 2.1 + 9.5
F R2 4 6.8 + 9.5
E S 1 0.0
E S 2 4.8
E S 3 0.0 + 9.5
E S 4 4.8 + 9.5
F F 1 2.1
F F 2 6.9
F F 3 2.1 + 9.5
F F 4 6.9 + 2.1
periods. The schedule would only have a 1% slack time in the
separator.
There is no easy way to account for the inventory needs of a
future period when optimizing operations over an earlier period.
One could form a scheduling problem and use slack time by giving some
value to producing intermediate inventory during this slack time.
The optimization techniques of this paper could solve such a problem.
The difficulty lies in assigning a value for intermediate inventory.
Actually it costs to store intermediate inventory and creation of
intermediate inventory is the wrong policy if there is no need for it
in the future.
Unfortunately the author did not have enough computer time to
solve the large batch scheduling problem of Chapter V. The author
attempted to find a schedule that was within $10 of being the optimal
schedule. This objective turned out to be very difficult to achieve.
If one looks at Tables 4 and 5, $10 may seem like a strong constraint
on the solution when some batches are worth over $2000. The author
chose $10 because some batches only cost $.70 an hour to store in
inventory.
Two weeks was spent finding a schedule for the third sample
problem. The schedule that was found made a profit of $4925 which
can be compared to the optimal profit of $8500 for the continuous
solution. The computer looked for solutions with profits above $4935
and found a schedule with $5449 profit after 22 minutes of work.
The computer found another schedule that made $5464 after twenty-seven
minutes of computing. The machine had not found a schedule with a profit
of more than $5474 after 90 minutes of computing. The author spent
28 more minutes of computer time trying to prove there was a schedule
with an objective function value of at least $5964 ($5464 + $500).
The author proved that there was no solution with an objective function
value as great as $6964 ($5464 + $1500) by spending an additional
57 minutes of computing time. All computing was done with an
IBM 360/65 computer.
Perhaps the branch-bound method would have proved better for
solving the large scheduling problem. For the smaller problem of
Chapter IV, branch-bound used more computer time than the Balas
enumeration method. Perhaps branch-bound is the best method for
larger problems.
Of course, now it is easy to see that we should have started
with an objective which was easier to obtain than getting within $10
of the optimal solution. The strategy was tested by starting the
program over with the objective of getting to within $500 of the optimal
schedule. The algorithm first eliminated a decision because of high
costs after 17 iterations. With an objective of getting within $10
of the optimal solution the computer did not eliminate a prior decision
until after the thirty-third iteration. Since there were 270 decisions
to be made eliminating a decision after 17 decisions eliminates 227017
possible schedules and waiting until the thirty-third decision
eliminates 2270-33 schedules.
There is another method of improving the efficiency of the
solution procedure. Today's computers cannot look at 2270 possible
schedules in any reasonable length of time. This solution procedure was
developed so that a large number of schedules could be eliminated from
consideration. The cases were found where one or more decisions
implied other decisions and this was included as input data to the
computer. Needless to say the last sample problem was too complex
for one person to find all the cases where one or more decisions imply
other decisions. However, one could write a computer program to find
this information.
The author found a number of cases where one decision would
imply another and gave this information to the machine. If the machine
had more information then the solution would probably have been
obtained more quickly. One set of poor decisions is seen in Table 10.
The computer made these decisions while trying to find the first schedule.
Table 10. A Set of Scheduling Decisions
Maximum Minimum
Unit Process Batches Batches
Rl 1 3 3
R2 1 1 1
S1 1 0 0
S2 1 3 2
R2 3 5 3
R3 3 7 6
The author looked at the solution output and found that the computer
was repeatedly finding that both the possible values of 521 were
impossible and then the computer would backtrack. The problem with the
~ __
decisions was that there was only enough chemical L produced by
process 1 to feed two batches of the separator. Two batches in the
separator did not create enough feed for the third process. The
computer spent over eight minutes backtracking and fathoming in order
to discover the last erroneous decision. Since computer time was at
a premium the author gave the computer the information that the last
erroneous decision was the decision to make only one batch in reactor
2 of process 1.
The reader should note that eight out of the twenty-two minutes
spent in finding the solution was spent in finding information that
could have been fed into the machine as data. The author did not attempt
to find other poor decisions due to a lack of data but it is probable
that other poor decisions were made.
The best schedule found by the computer is given in Table 11.
This may not be the optimal schedule but it is better than one found
with much difficulty by hand. The reader should note that, as before,
we have a schedule which makes some inexpensive product (Process 5).
Process 5 also makes some recycle.
Conclusions and Recommendations
The solution method was developed to solve scheduling problems
more efficiently than other integer programming methods. The efficiency
of solution method depended on information about the consequences of
decisions. This information proved very important and future work
should involve systematic methods of generating this information.
The solution method had some difficulty solving a realistically
Table 11. Best Schedule Found for Sample Problem 3
Process Unit Batch Starting Time
1 R1 1 12.5
1 R1 2 15.0
1 R1 3 17.5
2 R2 1 17.0
2 S2 1 0.0
2 S2 2 9.3
3 R2 1 5.0
3 R2 2 8.0
3 R2 3 11.0
3 R2 4 14.0
3 R3 1 3.4
3 R3 2 5.9
3 R3 3 8.4
3 R3 4 10.9
3 R3 5 15.7
3 S2 1 8.2
3 S2 2 17.8
3 S2 3 18.9
4 R1 1 6.2
4 R1 2 8.3
4 Rl 3 10.4
4 R3 1 13.4
4 R3 2 18.2
4 S1 1 7.6
4 S1 2 13.8
4 S3 1 13.4
5 S1 1 2.5
5 S2 1 12.4
sized chemical batch scheduling problem. A fairly good schedule
could be obtained with a limited amount of computer time.
Future work should be involved with solving realistically
sized problems instead of the small problems, which were the focus of
attention in the past.
Of interest to chemical engineers is the result that some
batch product mix problems should produce a wider variety of products
than they would if inventory costs were not included. It is also of
interest to note that scheduling considerations cause a moderate
amount of slack time chemical batch units. In the past, one might
have supposed that this was due to poor performance by chemical
operators.
Also, obviously of interest is the fact that we now have a
method of determining both how many batches should be produced and
how they should be scheduled.
APPENDICES
APPENDIX A
THE INVERSE MATRIX FOR PURE SCHEDULING PROBLEMS
The branch bound enumeration method of Chapter IV involved
the storage and retrieval of a number of partial solutions to the
optimization problem. Since the revised simplex method is used, an
inverse matrix, B-1, is needed in order to reproduce partial solutions.
The matrix, B, to be inverted (see Equation (24)) is made up of
columns of the matrix A' which defines the dual problem. It is
easier to store information on which columns of A' define B than
it is to store the entire matrix B-1. The branch-bound algorithm
developed here stores information on which columns define B and then
invert the matrix B.
Matrix inversion is normally fairly difficult but a simple
method is developed here for inversion of the matrix B found in pure
scheduling problems. We will first use the method to invert a
matrix formed from the first, third and fifth columns of the matrix
A' in Equation (21).
0 -1 1
B 0 0 -1 (59)
1 0
The third component of the first row of B- must be -1 since
-l
the first row of B- times the first column of B must give 1. Thus
we know one component of B-1
11 B12 -1
i -B -I
B B21 B2 B (60)
-1 -1 -1
31 32 33
Since the first row of B-1 times the second column of B must
-l
give zero, the first component of the first row of B- must be a
minus one.
-i B- -1
12
B-1 -1 B 31 -161)
B 1 22 23 (61)
-1 -1 -1
31 32 33
-L
Since the first raw of B- times the third column of B must
-1
equal zero, B12 must be -1.
12
B-1 equals zero because the second row of B-1 times the
f23 equals zero because the second row of B times the
first row yields 0. B-1 equals -1 because the second row of B1
-1
times the second column of B yields one. B23 must equal -1 since the
-l
second row of B- times the third row of B equals 0. Similar arguments
-1
can be made for the values for the third row of B-1
-1 -1
B-1 -1 -1 0 (62)
0 -1 0
A good deal of work is involved in inverting this matrix but
no more work is involved in finding the first three rows of a much
larger inverse matrix.
o 0 0 -1 -1 -i 0 0 0 1 0 0
0 0 0 -1 -1 0 0 0 0 -1 0 -1
0 0 0 0 -1 0 0 0 0 0 -1 1
x x x x x x 0 -1 1 0 0 0
x x x x x x 0 0 -1 0 0 0
x x x x x x -1 1 0 0 0 0
(63)
In Equation.(63) I is the identity operator. The first three
rows of the first matrix of Equation (63) can be found by the same
methods used in finding B-1 of Equation (62).
The procedure for finding B-1 in Equations (59) through (63)
can be used for all.pure scheduling problems. Some characteristics of
B for pure scheduling problems will be proven in order to show the
validity of the matrix inversion procedure.
Structure of B
Here, we are considering only the pure scheduling problem.
We know how many batches of each product to produce over a fixed time
period. The cost of a particular schedule, z, will be given by
Equation (64).
k + c*t = z (64)
where ti are the times that a particular batch starts. We will want
to minimize c*t. Our constraints will be of the form:
t t < d (65)
either/or
-ti + t 2
t < k (66)
where Equations (65) say that batch ti is to be started either dl
units of time before tj or d2 units of time after tj. Equation (66)
says that batch i has to be started by time ki.
We will be doing linear programming problems given by
Equations (20).
minimize c't maximize d'w
primal such At > d dual such A'w < c (20)
problem that t > 0 problem that w > 0
where A includes some set of constraints like Equations (60).
We are going to use the revised simplex method of solving the
dual problem. First, we will write the dual in Equation.(67).
max d'w
-1 0 . 0
such 0 -1 0 .... 0 w w > 0 (67)
that ... w
0 ... 0 1
If the matrix in Equation (67) has m rows we will be using m
linearly independent columns of Equation (67) at a time. These m
columns form a basis matrix B. It will be helpful to know the
structure of B-1. Each column of B has one of the forms given by
Figure 16.
0
0 0
0
1
0 0
or or -1
0 0 0
-1
0
0 0
Figure 16. Three Possible Forms for Columns of B.
A simplified notation will be used in the following analysis.
A column of B with all zeros expect a one in the ith row will be
written as ei. A row of B-1 with all zeros except a one in the ith
column will also be written as ei. When a proof is given which will
hold for ei or -ei the notation ()ei will be used. The notation
(-) (+)
+ ei ej means that discussion is valid for either ei ej or
-ei + e.
Proof 1
The vectors e e e -e ...e e
01 02 2 03 n- n n 1
are linearly dependent.
This can be seen to be true because they can be added together
to give 0.
Proof 2
(-) (+) (-) (+) (-) (+)
The vectors + e e + e e ,.... + e e
() (e ) 1 2 2 3 n-l n
+ e e are linearly dependent.
n ~1
~
If we multiply each of these vectors by a plus or minus one,
(-) (+)
we will have a vector of Proof 1. Let xl + e e ,
(-) (+)
x + e2 e etc. By Proof 1 we thus have constants a (all
2 2 "3
n
plus or minus one) such that aixi 0. By definition the vectors
i-1
are dependent.
In the following we will be using some proofs and terminology
of graph theory. The proofs will be given in terms of our system and
hopefully the proofs will be easier to follow when presented in this
manner.
Definition
Among the columns of B we will have a path between e and
e if there are n columns of B of the form
n-l
(-) (+) (-) (+) (-) (+)
+ e e2 + e e ,.., + e e
1 2 2 3 n n+l
Definition
The path between the vectors of P-2 will be said to form a
loop, since there is a path between e and itself.
Proof 3
Suppose we have a set S, of columns of B of the form;
(-) (+)
+ e e Suppose that there is no loop formed by members of
oi j
this set. Suppose further that in this set, S, there is no path
(-) (+)
between ek and e We may add the column + ea e. to the set
S and still not have any loops.
There is no path between e and e in the set S. Thus
(-) (+) oh a1
with the addition of + e e to S there will only be one path
fk e
between e and e and neither e nor e can be part of any loop
k a f e
in the new set. Any path not involving e or e will not be
1a 0
affected by the new addition to S.
Definition
Suppose we have a set, S, of columns of B of the form;
(+) (-)
- e + e A unit vector, e found in the set will be called an
0 0
(-) (+)
extreme point of S if it is only found in one column, + e e ,
of S.
Proof 4
(+) (-)
Any set, S, of columns of B of the form; e + e
oL j
without a loop, has an extreme point.
Suppose n unit vectors, e are used in the set S. Choose any
.i
vector e , used in the set. Either e is an extreme point of the
set or it is not. If e is an extreme point we are finished. If
0 2
e is not an extreme point we can find two columns of S of the form
(-) (+) (-) (+)
+ e e , + e e Either e is an extreme point of
the set or it is not. Suppose we have found -1 members of the set
(-) (+) (-) (+) (-) (+)
of the form; + eo, e,2, + e,2 e,,..., + e, e ,
where e ,2 through e are not extreme points. Since e is not
(-) (+)
an extreme point there must be column of S of the form + e e ,
0 +1
e ,+1 cannot belong to the set e ,l, e, ,2...,e or we would form
a loop. Suppose we eventually find that S consists of a path through
n vectors without forming a loop and eo,2 through e ,n1 are not
(-) (-) (-)
extreme points. We would have the columns, + e,1 + ea 2, + e,'2
(+) (-) (+)
- e ,..., + e a , and e through e are the only
a 3 n-1 n 1 n
unit vectors forming the set. If we have another column of the set
(-) (+)
of the form; + e, e , we will have a loop. There will thus
n (-) (+)
be only one column of S of the form, + ea, ei and e is
n 4. n
an extreme point.
Proof 5
(-) (+)
No more than n-l independent vectors of the form + e e
can be formed from n unit vectors e .
Now Proof 4 is true for n=2 because there can be only one
(-) (+)
independent vector of type + eo eo Suppose Proof 4 is true
1 2
for n-. Suppose we have a set S, of independent vectors of form
(-) (+)
+ e e formed from +l vectors e.. From Proof 2 the vectors,
(-) (+)
+ e e, of S cannot be independent if there is a loop. From
4. j
Proof 3, if there is no loop, there must be an extreme point, e .
(-) (+)
Elimination of the vector + e a from the set S will create a
ao ok
set formed from only I unit vectors e ik, which can have at most
(-) (+) H i
1-1 vectors of the form + e e. Our set formed from e+1 unit
o j
vectors must therefore have at most (-1) + 1 -= vectors. Q.E.D.
Proof 6
If B has a column of the form e e , then there must
a 1 a 2
be a path between either e or e and some vector e where
1 2 n
(+)
a column of B is of the form e, .
n
For this proof one has to remember that B has m rows and m
(+) (-) (+)
independent columns which are either of the form ei or + ei ej.
Proof 5 will be proved by contradiction. We will prove that if
Proof 5 were false then the columns of B would be linearly dependent.
Suppose B has a column of the form e e and let S
1 2
be the set of all vectors e where there is either a path between
e i and eo, or a path between eo and e Suppose Proof 5 is
false. Then there is no column of B of the form e where eo,
is a member of S.
Let S be the set of all columns of B of the form
c
C-) (+)
+ eo, e where e and e are in S. Let n be the number
i 0 i
of vectors, e , in S and n be the number of columns of B in S .
Either n < n or n > n.
c c -
If n < n then the m n columns of B which are not in S
c c c
are generated by the m-n vectors ei which are not in S.
There are m unit vectors ei in the vector space we are working
with. The m-n columns of B which are not in S are generated by the
c c
m-n vectors, ei, which are not in S.
By Proof 5 if n > n then the columns of S are dependent.
If n < n then the m-n columns of B which are not in S are
c c c
dependent because there are generated by only m-n vectors ei. Q.E.D.
Proof 7
(+) (-) (+)
If the columns of B were of the form e ,+ e e ,
01 01 02
(-) (+) (-) (+) (-)
+ e e ,..., + e e + e they would be linearly
2 3 n-1 n n
dependent.
Here we have n+l columns of B generated by n unit vectors.
No more than n independent columns can be generated by n unit vectors
so we have that these n+l columns must be dependent.
Generation of the Inverse Matrix
Now that we have shown the characteristics of B if it has
independent columns, it is not too hard to deduce the properties of
--l
B1. We can write each row of B as I aiei.
The inverse matrix will be generated one row at a time. The
characteristics of the jth row of B-1 depend on the characteristics
of the jth column of B. A column of B can have either one or two
nonzero components and we will see how to generate a row, j, of B-1
depending on the properties of the corresponding jth column of B.
The Jth Column of B Has Two Nonzero Components
Here the jth column of B, bi, is given by Equation (63) and
we want to find the jth row of B-.
(-) (+)
b = + e e (68)
First we find all of the vectors, e , where the columns of
B form a path between e and e By Proof 6 there is a column, k,
(+) i
of B of the form e By Proof 7 there is only one such column, k.
k
The jth row of B-1, b 1 is given by Equation (66) since the jth row
of B-1 times the kth row of B must be zero.
b 1 k Yiei (69)
Next we find the path between e and e There can be two
types of paths, P1 and P2, between an extreme point and e These two
types of paths are given by Equations (70) and (71).
(+) (-) (+) (-) (+) (-)
Pl e ,+ e e ,+ e e ,...,+ o
x x x1 x1 x2 xn
(+) (-) (+)
ea, + ea e (70)
(+) (-) (+) (-) (+) (-)
P2 e + e e + e e ...+ e
x x x1 x1 x2 xn
(+) (-) (+)
e + e e (71)
If the extreme point ea of Equation (69) belongs to a path of
type P1 then y (Equation (69)) is zero if et belongs to a path of type
(+)
P1 and yi is 1 if ei belongs to a path of type P2. If the extreme
point e of Equation (69) belongs to a path of type P2 then yi is
ak (+)
zero if ei belongs to a path of type P2 and yi is 1 if ei belongs
to a path of type Pl. yi is zero if ei does not belong to a path of
type P1 or P2.
Here the jth column of B, bj, is given by Equation (67) and
The ith Column of B Has One Nonzero Component
we want to find the jth row of B-.
(+)
bj = e (72)
Since the jth row of B-1 times the jth column of B is one, the
jth row of B bI is given by Equation (68).
(+)
-1
b + ea+ iYie 1 (73)
(+)
The vector e may be an extreme point of one or more
paths, P, formed by the columns of B. If a vector e is part of any
(+)
such path P (Equation (74)), then yi of Equation (73) must be 1
since the jth row of B-1 times any column ilj of B must yield zero. If
a vector, ek, does not belong to any path given by Equation (74)
then yk of Equation (63) must be zero.
(-) (+) (-) (+) (-) (+)
P = + e e + e e ,..., + e e (74)
1 1 2 n-1 n
The inversion procedure developed earlier has to find paths among
the columns of B. One needs to find the nonzero components of B in
order to find these paths. The programs described later store the
location of nonzero components of the columns which make up B. The
programs also store the value of the nonzero components. Since the
columns have few nonzero components it is easier to store their
locations and values than it is to store the entire matrix B.
We have a fairly easy method of generating each row of B-1
merely by knowing the structure of B. therefore, we can store which
columns of A' are used in a matrix B and invert B in order to obtain B-1
APPENDIX B
PROGRAMS
The solution procedures developed earlier were implemented
in the Fortran language. The programs used are given in this
section.
The Balas enumeration procedure is implemented by subprogram
FATHOM. The branch-bound enumeration procedure is implemented by
subprogram BRANCH. Subprogram LINEAR performs the linear programming
for both enumeration procedures and subprogram COST calculates the
cost of freeing a variable for both enumeration procedures.
Both enumeration procedures diminish the size of a problem as
a consequence of one decision implying another. Subroutine FATHOM
uses subroutine DEMINF and subprogram BRANCH uses subprogram DEMIN.
Flow charts are given for the first few subprograms. Listings
are given for the other subprograms. A reader who is interested in
understanding and using the programs should first read the description
of the flow charts.
The major variables are found in these flow charts. Hopefully
the flow charts will be useful to future programmers.
**
** |