• TABLE OF CONTENTS
HIDE
 Title Page
 Front Matter
 Acknowledgement
 Table of Contents
 List of Tables
 List of Figures
 List of symbols
 Abstract
 The problem
 Integer programming
 Integer programming using duality...
 Pure scheduling problems
 Enumeration of mix/scheduling...
 Results, conclusions, and...
 Appendices
 Bibliography
 Biographical sketch














Title: Optimal scheduling of complex batch processes
CITATION PDF VIEWER THUMBNAILS PAGE IMAGE ZOOMABLE
Full Citation
STANDARD VIEW MARC VIEW
Permanent Link: http://ufdc.ufl.edu/UF00098199/00001
 Material Information
Title: Optimal scheduling of complex batch processes
Physical Description: xii, 149 leaves. : illus. ; 28 cm.
Language: English
Creator: Swanson, Henry Xenophon, 1945-
Publication Date: 1972
Copyright Date: 1972
 Subjects
Subject: Chemical plants -- Automation   ( lcsh )
Mathematical optimization   ( lcsh )
Chemical Engineering thesis Ph. D
Dissertations, Academic -- Chemical Engineering -- UF
Genre: bibliography   ( marcgt )
non-fiction   ( marcgt )
 Notes
Thesis: Thesis -- University of Florida.
Bibliography: Bibliography: leaves 147-148.
General Note: Typescript.
General Note: Vita.
Statement of Responsibility: by Henry X. Swanson.
 Record Information
Bibliographic ID: UF00098199
Volume ID: VID00001
Source Institution: University of Florida
Holding Location: University of Florida
Rights Management: All rights reserved by the source institution and holding location.
Resource Identifier: alephbibnum - 000577495
oclc - 13983199
notis - ADA5190

Downloads

This item has the following downloads:

PDF ( 3 MBs ) ( PDF )


Table of Contents
    Title Page
        Title Page 1
        Title Page 2
    Front Matter
        Page i
    Acknowledgement
        Page ii
    Table of Contents
        Page iii
        Page iv
    List of Tables
        Page v
    List of Figures
        Page vi
        Page vii
    List of symbols
        Page viii
        Page ix
        Page x
    Abstract
        Page xi
        Page xii
    The problem
        Page 1
        Page 2
        Page 3
        Page 4
        Page 5
        Page 6
        Page 7
    Integer programming
        Page 8
        Page 9
        Page 10
        Page 11
        Page 12
        Page 13
        Page 14
        Page 15
    Integer programming using duality and the revised simplex method
        Page 16
        Page 17
        Page 18
        Page 19
        Page 20
        Page 21
        Page 22
        Page 23
    Pure scheduling problems
        Page 24
        Page 25
        Page 26
        Page 27
        Page 28
        Page 29
        Page 30
        Page 31
        Page 32
        Page 33
        Page 34
        Page 35
        Page 36
        Page 37
        Page 38
        Page 39
        Page 40
        Page 41
        Page 42
        Page 43
        Page 44
        Page 45
        Page 46
        Page 47
    Enumeration of mix/scheduling problems
        Page 48
        Page 49
        Page 50
        Page 51
        Page 52
        Page 53
        Page 54
        Page 55
        Page 56
        Page 57
        Page 58
        Page 59
    Results, conclusions, and recommendations
        Page 60
        Page 61
        Page 62
        Page 63
        Page 64
        Page 65
        Page 66
        Page 67
        Page 68
        Page 69
        Page 70
        Page 71
        Page 72
    Appendices
        Page 73
        Page 74
        Page 75
        Page 76
        Page 77
        Page 78
        Page 79
        Page 80
        Page 81
        Page 82
        Page 83
        Page 84
        Page 85
        Page 86
        Page 87
        Page 88
        Page 89
        Page 90
        Page 91
        Page 92
        Page 93
        Page 94
        Page 95
        Page 96
        Page 97
        Page 98
        Page 99
        Page 100
        Page 101
        Page 102
        Page 103
        Page 104
        Page 105
        Page 106
        Page 107
        Page 108
        Page 109
        Page 110
        Page 111
        Page 112
        Page 113
        Page 114
        Page 115
        Page 116
        Page 117
        Page 118
        Page 119
        Page 120
        Page 121
        Page 122
        Page 123
        Page 124
        Page 125
        Page 126
        Page 127
        Page 128
        Page 129
        Page 130
        Page 131
        Page 132
        Page 133
        Page 134
        Page 135
        Page 136
        Page 137
        Page 138
        Page 139
        Page 140
        Page 141
        Page 142
        Page 143
        Page 144
        Page 145
        Page 146
    Bibliography
        Page 147
        Page 148
    Biographical sketch
        Page 149
        Page 150
        Page 151
        Page 152
Full Text

















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.




University of Florida Home Page
© 2004 - 2010 University of Florida George A. Smathers Libraries.
All rights reserved.

Acceptable Use, Copyright, and Disclaimer Statement
Last updated October 10, 2010 - - mvs