.'~nnals of Operations Research 5511995r439 452
439
How to make OR-results available:
a proposal for project scheduling
Rudolf M tiller*
tlumhohtt ~'niversitdt in Berlin, hlstitut /i'ir H'irtschafts mformatik. Berlin, Germany
E-mail: rmueller,a wiwi.hu-berlin.de
Dirk Solte
~rs~'hungsinstitut liir anwemlungsorientierte l t ' i s s e n s t ' e r a r h e i t u n g ( F.4 H').
D-89081 Uhn, German v
E-mail: soltcea faw.uni-uim.de
This paper addresses the question of how to make avadable and how to get realistic
insight tnto the behavior of hard algorithms for application fields such as scheduhng. A
typical situation in this context is the availability of hundreds of algorithms for special
subclasses of certain problems where one of the mare difficulties is to handle these
algorithms simultaneousl) and make available knowledge about when and how to
appl) a particular algorithm, using statistical tnformation on the suitability of certain
algorithms under appropriate conditions. Major questions concern "accounting problems" when particular algorithmic tasks are required to apply specml methods but
mtght also be useful for other methods, In particular, the question of finding adequate
software-engineering strategies and software-development environments for such
work is addressed. Also, the paper revtews recent developments at the Research Institute for Applied Knowledge Processing (FAWt in UIm and describes a method base
for ~heduling algorithms built within the framework of a cooperative effort between
FAW and the Technical University of Berlin
1.
Introduction
The application of mathematical models to support experts in solving real
v~orld problems has generated significant interest in both the research and development communities. Unfortunately, the use of these results is not yet as established as
it should be [9]. One of the reasons is that too much muttidisciplinary knowledge
about operations research~management science, mathematical programming, computer science and cotnmunications is simultaneously required to implement solvers and
integrate them into applications. Moreover, academia still does not put sufficient
emphasis on doing research on real world applications. Looking to the fields of
"The first author acknowledges support from the Deutsche Forschungsgemeinschaft under grant
Mo446 I-3 and Sonderforschungsbereich 373.
J C Baltzcr AG. Sclence Publishers
440
R, .~fiilh'r~ D. Solte Proposal tor project scheduling
operations re.~earch, mathematical programming and parts of theoretical computer
science, many papers have been published whose abstracts contain the words: liar
the prohh, m ... we ,eive a ... al.eorithm. How many of these algorithms have been
implemented'? And if implemented, how man,,' implementations have been published'? And hov, many of the published implementations are used in practice'?
Assuming open competition, good algorithms survive and had algorithms disappear. But what is the measure for the quality of an algorithm'? Possible criteria
may be:
•
•
~,
The quality of the underlying theory (generality, complexity, optimality of
the solution, etc.).
The quality of the implementation (perl\-wmance, openness, etc.),
How easy is the theory (easy to understand, easy to implement, easy to use).
Normally, there is a trade-off between these criteria. One will rarely find a
general algorithm with a good performance rate that is easy to implement, because
good perlk~rmance is gained by exploiting the structure of a problem and using
advanced data structures. The first point contradicts generality, the second requires
a lot of implementation eft\~rt. A reasonable combination for the survival of an
algorithm on the software market seems to be generality with an acceptable performancc, as for the simph'x algorithm and the interior point method for linear programminx. Here, a whole industry is concerned with developing efficient codes. Even
more, at lot of research is done to map all kinds of optimization problems into
this framework, Moth,ling hmguages like SML [7, 8] already free the user to a considerable extent from doing this mapping himself.
However, there are many combinatorial optimication prohh'ms arising in
applications, which cannot be modeled as linear programs because they require,
e.g.. integer solutions, at least for some of the variables. But even for these problems. general ~and ineflicicnt) mixed integer linear programming (MILP) solvers
arc the most frequently used. To get better performing algorithms one has to
exploit the mathematical structure of the problem class. For example, in branch
and cut algorithms for the travelittg suh'smatt prohlem one combines the pure
linear programming approach with problem-oriented combinatorial algorithms,
which serve to compute heuristic solutions and to separate non-integral solutions
by sets of l~wets of the convex hull of integer solutions. This approach requires
an extensive research effort: however, it leads to non-general solvers. The only
generality lies in the experience one gains, which might be used for similar problems. But almost no company invests money and personal resources to gain such
experience, so the major thrust for further improvements comes from mathematical
curiosity.
The application domain for the concepts described in this paper is a subarea
of combinatorial optimization where linear programming is not adequate: to model
a sche~hding probh,m as M ILP results in an excessive number of linear constraints.
The polyhedral approach seems to be promising only for very special problem
R. Mfflh'r. D. Solte Proposal h~r prolect scheduling
441
classes, as, for example, single machine scheduling [25, 27] and job-shop scheduling
[I. 3]. For general classes, like scheduling project networks with resource constrahlts
and tinw windows [4], pure combinatorial approaches are favored. Such approaches
require deep mathematical insight. This may be the reason why commercial solvers
l\~r project scheduling restrict themselves to quite simple heuristics, which makes
them disappointing to some extent [see, e.g. the elaborate comparison of available
commercial packages in [30]).
It is obvious that one has to find or build a bridge between real world problem
solving on one side and algorithmic mathematical research on the other side. A
good bridge should free the application expert from the burden of requiring a
deep understanding of the theories and algorithms he should use. instead, the
expert should be allowed to formulate his application problem within an appropriate
m,,deling language. The mathematical specification, the choice of appropriate algorithms, and their execution should be done by the system.
However, even a much less ambitious goal is not yet reached: providing an
environment in which a researcher in OR or mathematical programming can integrate new algorithms in a comfortable way. "Comfortable" means that the environment provides a normed system of data structures to which the researcher connects
his algorithm by implementing an interface only once. After that he obtains a complete experimental environment for free: menus to invoke his algorithms, graphical
editors, connections to data-bases and to other algorithms in the library. Herb
Shultz and William Pulleyblank state in their essay Trends m Optimi:ation that
this kind of support is one of the three major aims for mathematical optimization
l_ st.
A project that is ongoing at a research group centered at the FAW ( Research
Institute for Applied Knowledge Processing), with partner groups in Berlin and Los
Angeles, has as one focus the aim to realize such an environment. Project MIDA,
which stands for Model Oriented Integration of Data and Algorithms, brings
together researchers from the fields of AI, knowledge based systems, computer
.wwm'e, modclhlg languages, decision support systems and combinatorial optimi'.ati, m. In this project each group contributes to the design of the whole software architecture, including new specific research and development aspects. The main blocks
of the architecture are a model-base, a library of algorithms and data structures for
project scheduling, a high level interface, and an administration system for distributed computational resources. A first discussion of the aims and requirements
involved in MIDA was given in [5], and some details on the modeling part are discussed in [I 2]. The technical details of the kernel of the system are illustrated in [11]
and [14]. For a mathematical discussion of the problem domain project scheduling
a e recommend [23, 24].
In this paper, we discuss mainly our chosen approach to solve the problem of
the integration of algorithms and of communication, in section 2 we give a detailed
overview of the kind of scheduling problems we want to handle. This section argues
t\)r the need to integrate many algorithms in one system. In section 3 we outline the
442
R. Mfiller. D. Solte/ Proposalfor project scheduling
whole architecture of the system. Section 4 tells how to integrate software into
MIDA. We conclude with an overview of future research topics.
2.
The application domain of the prototype
A scheduling problem is concerned with how to process a set of tasks, that
usually involves temporal aspects and resource aspects, in order to optimize an
objective. This definition subsumes project scheduling, sequencing and various
kinds of shop schethdmg problems. All of these have been the topic of intensive
rcsearch in computer science, mathematical programming and operations research.
A project scheduling problem as discussed here deals with a finite set of jobs,
which have to be processed non-preemptively. For the processing of the jobs a finite
set of reusable resources is available. Each job has a demand for one or more of
these resources, and for each resource, there is a certain supply. Demand and
supply are given by piecewise constant functions of time. In case of the demand,
the value of the function at a time point t is the amount of the resource needed
by the job t time-units after its start. In case of the supply, the function value
gives the supply t time-units after the start of the project.
Each job may have a reh'ase-thne and a deadline. The interpretation of these
values is that the job has to be scheduled within the time interval [release-time, deadline].
Furthermore, each job has a positive duration. We may have in advance full
information on the duration (deterministic duration) or only stochastic information
(stochastic duration), where we know for example a (joint) density of a random variable describing how the durations of jobs are distributed.
Further there may exist time constraints on the processing intervals of pairs
of jobs. Such a constraint forces a minimal or maximal delay between the start or
end of one job and the start or end of the other.
Given these resource and time constraints we look for rules to schedule the
jobs. Such a planning ruh, produces a feasihh, schedule if all time constraints are
satisfied and at each time the total amount of used resources does not exceed the
supply. A planning rule may be given by an explicit list of starting times or may
contain hints about how scarce resources should be allocated (for example in the
form of a priority list). We measure a realization created by such a rule by nondecreasing real-valued functions of the completion times of the jobs. Nondecreasing means that if one schedule leads for each job to a completion time smaller or
equal to the completion time given by another schedule, then its objective value is
not worse. In other words, to plan as early as possible never worsens the objective.
Let us illustrate everything said so far by giving three examples of classes of
project scheduling problems:
( 1) Take an acyclic directed graph with a single source node s and target node
t. Take each arc as a representative of a job, and a directed (eventually empty)
R. Mffller. D. Solte Proposal ]br project scheduling
443
path from the head o f o n e arc to the bottom o f a n o t h e r arc as the constraint that the
second job may not start before the first is finished. Further, assume that the length
of each arc (processing time of each job) is given by a random variable. This defines
a stochastic project network, also known as P E R T network in the literature. If there
are no resource constraints, one can give a simple rule how to schedule optimally:
start each job as soon as all its predecessors are finished. However, this is not
expressible by a list of starting times, because the durations of the jobs are not
known in advance. Consequently, one also does not know the value of the objective
in advance; instead, it is a random variable. In this case, one wants to have algorithms that compute some information about this random variable, for example,
its mean.
The algorithmic approach combines decomposition theory of partially ordered
sets with transformation techniques on the network structure, and numerical operations on one-dimensional random variables. Especially the possibility to decompose
complex network structures into smaller units argues for experiments with combinations of standard algorithms: on small units costly algorithms could do precise
computations, whereas large units could be treated by fast, but less precise approximation algorithms.
(2) The second example is from the field of machine scheduling problems. The
time constraints for machhle scheduling prohlems are given by a partial order on the
set of jobs (poser): the resource supply is a set of m identical machines, and the
demand of each job is one unit of these machines. The processing of a job on a
machine may again not be interrupted and so also not divided among several
machines.
The research done in ma¢'hine scheduling in recent decades is enormous. The
reason for this is mainly a mathematical one: the border between polynomial solvable and NP-hard problems (so far there is one) crosses this domain of combinatorial optimization problems. There is even a no maws land: nobody knows so far
the complexity of the 3-machine problem. The result of this exhaustive research are
hundreds of exact and approximate polynomial or exponential algorithms for all
kinds of combinations of conditions on the problem. The respective combination
of conditions is less guided by a practical application, but by the mathematical
.
[ 11
41514 I ~ ~ 6 1 2 1 3 ~
Figure1. A nearly'seriesparallelproject.
"-J
444
R. Mfiller. D. Solte Proposal.lor project scheduling
1,121
,
t3
161
5
171
Figure 2 0 p t , m a l schedule ffjob 3 has to precede job 6.
I,
I
4
1+1
1
I
5
Figure 3. Optimal schedule if lob 4 has not to precede job 5.
question, what parts of the structure do make the problem hard to solve. Nevertheless, this work may have big practical relevance if it is integrated in a scheduling
problem solving system in an appropriate way. This is true, e.g., because the application of a specialized algorithm to a more general class of problems could serve to
generate good approximative solutions, or to compute tight upper and lower hounds
for the optimal value of the objective, thus providing a quality control for heuristics.
Take the example of figure 1. It shows a set of 7 jobs, each represented by a
rectangle. The first number in the rectangle is the i d o f the job, the second represents
its duration, and the third the weight of its completion time in the objective, which is
the sum of the weighted completion times. Each arc represents the constraint that
the job at the target may not start before the job at the source is finished. Our
aim is to lind a schedule on a single machine which minimizes the weighted sum
+~/ comph'tion times. The instance of figure 1 is not a member of any class for
which a polynornial time algorithm is known. So we can only use a general tool
such as a branch and bound algorithm to lind an optimal schedule.
However, if we add the constraint/oh 6 has to he a successor q/ijoh 3, the situation changes. This constraint makes every schedule which plans job 6 before job 3
infeasible. So it reduces the space of feasible solutions and hence the objective value
of an optimal schedule worsens. But on the other hand. it makes the partial order on
the set of jobs series paralh'l. Given a series parallel partial order on a set of jobs.
we can compute the minimum weighted flowtime schedule on a single machine by a
fast algorithm of Lawler [19]. This algorithm computes an objective value of 246 for
the example (see figure 2).
instead of adding a precedence constraint, we may also drop one, for example
the constraint that job 4 has to precede job 5. Again, we obtain a series parallel
partial order and kawler's algorithm in this case gives an o p t i m u m of 241, which
is a lower bound (see figure 3), More than that, the generated optimal schedule
plans job 3 before job 6, so it respects all original constraints and is thus an optimal
solution for the problem we started with.
(3) A third class of project scheduling problems which we have in mind are socalled time cost trath'-of/prohh, ms+ Here, the only scarce resource is mottel' which
can be used to control the duration of each job to some extent. The time costtrade-off relation of a job is given by a decreasing piecewise linear convex function
of time. The value of this function at a time point t gives the amount of money,
R. Mt~ller. D. Solte Proposal for project schedulinR,
445
which one has to spend for this job in order to finish it within t time units. The precedence constraints are given by an activity-on-arc diagram (as in example ! ). Suppose we want to guarantee a certain project duration. Then the question which
arises is, what is the minimal a m o u n t of money which has to be spent for this
aim and how should the money be divided among the jobs. The problem can be
solved by transforming it to a rain cost/h~w prohh, m or, for variable t, to a sequence
of rain cut problems.
Consequently. this is an example where one can use a standard comhmatorktl
,ptm~ization algorithm (rain-cut or max-flow) to solve a scheduling problem. A similar situation arises in 2-machine sche~hding o.f partialO' ordered unit tmw johs. This
class of problems can be solved by a weighted matching algorithm applied to the
incomparahi#ty graph of the partial order. Having the matching algorithm available, one only has to implement a procedure to initialize and interpret its input
and output data.
To summarize, we argue that an efficient environment to solve project
scheduling problems has to support the user at least in:
•
Handling many of different data structures, ranging from representations of
random variables (to represent stochastic durations), over weighted graphs
(to represent time constraints) to nondecreasing functions of real vectors
(to represent objectives) (examples 1, 2, and 3).
•
Combining algorithms into new algorithms (example 1).
,,
Using algorithms for special cases as heuristics for more general cases (example
2).
Integrating standard combinatorial algorithms as subroutines (example 3).
•
The next section describes how M I D A organizes solver communication and
integration.
3.
The overall architecture
MIDA stands for model-oriented integration of data and algorithms. The
following scenario describes the basic environment that M I D A addresses. Suppose
one has several different hardware platforms in a network, running under different
operating systems. On each platform one has installed a lot of software to solve
combinatorial optimization problems or to perform other helpful tasks. Most of
the software is not easily portable to the other platforms in the network. Furthermore, there are several data bases installed in the network, each containing a
large amount of data in its specific style. In a company this could mean that for
specific domains (e.g. personnel, finance, production, etc.) one uses heterogeneous
autonomous databases. In a planning process one very often needs data from some
of these databases to get an integrated view, which means that the most comfortable
446
R. Mt)lh'r D. Solte Proposal lor project scheduling
t
User Interface
Integration
If
I
1
Implementation
t-lgurc 4 Data structure~, and algorithms.
solution would be distributcd access over a network to get the desired data. in a
decision process like this it could bc that the current problem is essentially a
machine .sc/u'duline prot,h,m. But, maybe, one is not an expert in this ticld. A userfriendly computer-based tool would supervise a user in such a situation, guiding
him through a library of nlodcls written m the user's favorite modeling language
until one tinds a model applicable to the problem. Then one edits the data with a
comlbrtable graphical interface or it will be accessed over the network. Based on
the current problem instance the tool would offer a list of applicable solvers
available somewhere in the network. One invokes some of them, without worrying
about where the solvers arc located, in which programming language they are implemented, or how the data have to bc prcparcd t\~r input to a particular solver. Some
seconds later tor hours, if the problem is hard) one is offered the solutions.
Hos~ to go a tirst step towards such a comfortable environment? M I D A does
this by integrating a number of quite simple concepts. Despite this simplicity, the
lirst implementation of the system, which is running now, demonstrates that the
concept is quite powerful. Most of the concepts used are not new. They have.
c.g., bccn realized in programming languages such as ('LOS {sec [201t or Smalltalk-,~'O {sec [ 10]).
The M IDA-system has three levels I tigurc 4): the user interlkwe, the integration, and the iml~h'mentation level. Corresponding to that, the M I D A architecture
........modeling envtronments
..
A M BA S
.....
]
i,
Figure 5. MIDA architecture
............t
R. Mfflh,r. D. Solte Proposal for pr~ject sche&ding
447
is divided into three levels: a high level user interface based on modeling hmguages, a
kernel, called AM BAS, handling representations of data structures and algorithms
in a model-base and connecting them to the modeling environment, and solver
libraries with code implemented in various programming languages (figure 5).
A M B A S (A&lptive Method Base Shell), developed al the FAW, is the heart of
MIDA. It is an interpreter of user requests to manipulate a set of objects of data and
method classes stored in the model-base which is implemented using Object Store an
object oriented database management system. A data chlss is a C + + class carrying
a collection of data in a structured form. A method class is a C + + class carrying
algorithms and functions. Every method is supposed to map objects of an input
~hlss )', onto objects of an output class Y,,. Method ch~sses are completely characterized by their input and output classes: each function mapping from Y, to Y,, is
a feasible instance of the method class Y, toY,, (a detailed description can be
found in [14] or [29]).
Based on this simple and deliberately restrictive concept concerning the
design of interfaces of data and method classes, it is possible to handle all algorithms (functions), including those algorithms with more than one input parameter
and functions which change the values of one of their input parameters, i.e. where
input and output are mixed. The specification of AMBAS allows their integration
by providing a frame to enclose them: the method class. In this frame the shape
of a function is hidden Icf. the concepts of K A R A M B A [13]). Surely this is a
strong restriction, but making AMBAS or any other system so general that it can
handle all kinds of parameter syntax directly seems currently to be out of range.
In heterogeneous environments one also would have hard problems to realize
an administration system like AMBAS based on an object-oriented approach
instead of a purely functional approach as in MIDA. Object orientation would
mean that each function is a memher/imction of a class. It either transforms the current values of Ihe object, or it sends a message to another object. This would mean
for AMBAS that it must know all about the internal organization of the integrated
data classes (i.e. knowledge about the compiler). And AMBAS would have to know
the current states of all objects, because this may determine the feasibility of a
method. With a functional approach, however, the feasibility of each function is
guaranteed by the type of the input parameter. This can be ensured by the programmer of the function instead of the administrator of AM BAS. The programmer
should know what happens inside his code and has to model this by specifying the
c~rrect input output behaviour.
This means, e.g., thai in cases where the feasibility of a function cannot
always be guaranteed by the correct input type but Ihe feasibility test is part of
the function, this has to be expressed by the interface specification. For example,
a function invert to calculate the inverse of a matrix could test for singularity of
the input matrix during its computation. In such cases the singularity has to be
an element of the output class Y,,. For example, Y,, may be a frame (see below)
448
R. MOiler, D. Solte/ Proposal Jor project scheduling
with attributes matrix and determinant. If the matrix is singular, invert returns
"nothing" in matrix and a zero in deternlinant.
Another option would be that such a function has not only input and output
parameters, but also controlparameters. As part of the input they control the flow of
computation, for example the branching strategy of a branch and bound algorithm.
As part of the output they review the flow of computation, for example the number
of nodes in the branch and bound search tree, the time, and the quality of the first
feasible solution, or they are handling error codes. This is a much more serious
problem for AMBAS and the integration is not fixed up to now. In the current
implementation one has to follow the strict input/output concept. For example
take the function invert. Is the attribute deterrninant result output or control
output? To keep the implementation of A M B A S as clear as it is now, one has to
require that all functions in the same function class have the same control parameter. Then one can equip each function class with data members for control
input and output. Everything else has either to be a part of the input or output,
or has to be set automatically with defaults or has to be asked from the user in a
function-user interaction invoked from the function itself which is strictly forbidden in the AMBAS philosophy.
The set of operations by which AMBAS (resp. the user with the help of
AMBAS) manipulates the objects of data and method classes is restricted to construction, deletion, assignnlent, hnking and access. Each of these operations corresponds to a public method or operator of the selected class or object.
The constructor generates an object of a class and initializes the data sections
with defaults. The memory of the new object is allocated in a way that the destructor
can clear all the memory.
The assignnlent operator initializes one object with the instance of another
object. Instance of an object means the set of current values of its data members.
By the implementation of the assignment it has to be guaranteed that the two
objects do not share c o m m o n memory after the assignment. The assignment is
not restricted to pairs of objects of the same class. It is defined whenever the
object which is assigned is a special case of the object which gets its instance.
AMBAS" concept of data and method classes interprets each class A as a special case of all method classes mapping A to any other class. Assigning an object a of
a class A to an object f of a method class AtoB initializes the input object o f f with
the value of a. Vice versa, a method class A toB is seen as a special case of the class B.
Assignment here means the evaluation o f the function with the current instance o[ A
and assign#lg this vah~e to the object o f class B.
Contrary to the assignment operator, the l#lking operator associates two
names with the same object. If the name that gets a new link has been linked to
another object and there is no other name referring to this object, this object is automatically deleted by a call of its destructor.
Access is the needed counterpart of assignment and linking, The restriction to
such a small set of operations used by AMBAS makes it possible to implement
R. Mffller. D. So#e/Proposal for project scheduling
449
AM BAS without any knowledge of the interior structure of the classes. Classes, in
this perspective, are nothing more than a container system with a normed interface.
To integrate a new algorithm into AMBAS, one has to put it into a method class
and A M B A S can invoke it. If an algorithm is already implemented as a function
which needs one parameter of type class A and returns an instance of a class B,
one simply equips A and B with the missing manipulation methods (see above)
and integrates those classes also into AM BAS. To integrate different algorithms
of the same functionality (e.g. max flow) implemented by different people, one
will probably have different representations of flow networks (as input and
output classes) in AMBAS. Every representation needs its own editor. Making
the results of the algorithms usable for further computations, one has to understand all these data structures and implement the mapping from them to the data
structure needed for the next step (so-called bridge algorithms [6]), Our proposal
for the design of data classes handling the input ~ Y,) and output (Y,,) of algorithms
is to find a domain-specific general representation (ontology). This is of course a
very hard task but it would help greatly in cooperative work. Then one can hide
the mapping to the data structure of a specific algorithm inside the method class.
Even if the algorithm can only be invoked by a system call and reads its input
from a file, one has no problem. This can all be done inside a method class. And
if a class for a flow network is comfortable and well documented one can give the
burden of the integration to the designer of the algorithm.
4.
How to connect to A M B A S
The preceding section illustrated how AMBAS handles data and method
classes in a distributed environment. The classes are C + +-classes with a normed
set of methods. Integration of software into AMBAS, and thus into M I D A
requires the implementation of such classes.
The AMBAS architecture described in section 3, however requires more than
a certain structural organization of data classes. Since methods are described by
pairs of input and output classes, only, these classes have to contain a definition
which semantic conditions the data has to fulfil.
For example, a directed graph may be chosen as a representation for a partially ordered set. The nodes correspond to the elements of the set, and an arc
from a node ~, to a node w corresponds to a relation t, < w. Now, only acyclic, transitively closed graphs represent partial orders. So, if we have an algorithm that
requires as input a partial order in this representation, acyclicity and transitivity
has to be encoded in the definition of the input class.
An approach to encode the semantics of data classes is provided by the
modeling level of MIDA. The idea is to use object oriented modeling enhanced by
several semantic data representation concepts as a high level expert interface in
which one expresses the full syntax and semantics of the data structures and algorithms. A compiler transforms this description into internal representations in
R. Mfflh,r. D. Solte Proposal for pro[ect sche&ding
450
form of ( ' + +-classes. which are then used to encapsulate algorithms and data
structures of arbitrary software libraries.
Another approach has been dcvcloped at the Technical University in Berlin
[21]. They provide in their library ADLIPS (,41eorithm and Data Library tor Pr~/ect
Scheduling) a tool to generate AMBAS compatible C + +-classes. Based on
descriptions the tool takes predefined classes and composes them to structured
classes. The structured classes may have one of the shapes t~'ame, case, tahh', and
graph.
A l?ame is, as a struct in C, or a record in PASCAl_,, a simple composition of
predcfincd types. A ~a.~c is a composition of alternative frames, coinciding with a
union in C. Tahh,s arc tables with arbitrary many indexed rows and a finite
number of predcfined columns. Graphs are directed graphs with arbitrary node
and edge attributes.
Besides the member functions needed by AMBAS, for each class the code for
a comfortable graphical editor based on X 1 I Motif is generated.
One of the conclusions of section 2 was that a comfortable system has to support a large varictv of data structures. This is certainly guaranteed by this system,
since the provided shapes of structures cover all needed composition rules and
alloxv recursive definitions of data structures.
Another conclusion ~vas the necessity to support the combining of algorithms. This is guaranteed bv a flexible technology to assign objects of different
types tO each other. For details, we refer to [21].
The problem of encoding semantics is attacked in the class generation tool by
providing tbr each data class a method evaluate. The designer of the class implements in this method his definition of valid instances of the class. Thus the user
of the class always has control on the feasibility of an instance.
One could imagine that the descriptions that are currently used as input for
the generator routines for classes are replaced by models in some modeling
language. At least the mapping of the structural organization of a model should
cause no problem, since the possible structures of classes generated by the tool
cover all structures occuring in currently available modeling languages. For
example the current implementation of the structured modeling language [8] creates
relational data b a ~ tabh.~ to store the instances. T h e ~ are special cases of tables.
ASCEND [26] creates a hierarchical system of atoms and models, These can be
easily expressed by frames and tables. NETII'ORKS [15, 16] uses pavameterized
graphs for its models. Here appropriate graphs can be used. The transformation of
semantic constraints encoded in the models into a C + +-representation, however.
is not trivial.
5.
Conclusion
The prototype described in this paper forms the basis for further develop.
ments of a system for a model-oriented integration of data and algorithms
R. Mu'ller, D. Solte Proposal for project scheduling
451
IMIDA). The next step of research aims at an integration of several modeling languages such as an extension of SML [7] and the ASCEND-system [26]. Reuse t y
models and model integration are two research issues which come into MIDA by
this integration [17]. Another problem that has to be addressed is how user preferences could be used to propose algorithms for selection ordered w.r,t, the intention
of the user, For that reason the preference elicitation tool [ 18] developed at FAW is
presently being integrated into MIDA to evaluate order relations for the methods
selected by AMBAS. A detailed discussion about the enhanced architecture is
given in [121,
References
[1]
[21
[~]
[4]
I51
[~1
[7]
IX]
[,4]
[10]
I111
!I2]
[13]
[14]
[I 51
116]
[171
IlX}
[191
D. Applegate and W. Cook. A computatuonal stud) of the job-shop ~heduling problem, ORSA
J. C o m p 3 11991t 149 156.
C. Bohm and G. Jacopinl. Flow diagrams, Tunng machines and languages with only t~o formation rules, Commun. ACM 11966}.
E. Balas. On the facial structure of scheduling polyhedra, Math. Prog Study 24 (1985) 179 218
M. Bartusch. R.H. Mohnng and F.J. Radermacher, Scheduling project networks with resource
constraints and time windows, Ann. Oper. Res. 16 (1988).
M. Bartusch, R.H. M6hrlng and F.J. Radermacher. Design aspects ofan advanced DSS for scheduling problems m civil engineering. Dec. Support Syst. 5 11989) 312 344.
R. Felter, Dect.,ion Support A.s.ststant (Deutscher Universit~its Verlag, Wiesbaden. 1989).
A. Geoffrion, An introduction to structured modeling, Manag. Sci. 33 (1987}.
A. Geoffnon, The SML language for structured modeling, WMSi Working Paper 378, Anderson
Graduate School of Management. UCLA ( 1990}.
A. Geoffnon. MS OR: forces, trends, opportunlt,es to flourish. WMSI Working Paper 395,
UCLA (19911.
A. Goldberg and D. Robson. Smalltalk-?¢O The Language and its Imph, rnentatton 1Addison
Wesley,. 1983).
M. Holocher. AM BAS. Entwicklung und lmplementierung eines Systems for den problemonentierten Zugriff auf rechnergestfitzte L6sungsverfahren, Dlplomarbeit FAW-B-92003 tl992}~
M. Holocher. R. Michalski. D. Solte and F Vicufia. MIDA: an open systems architecture for
model-oriented integration of data and algorithms. Dec. Support Syst., to appear.
R. HiJber, V D. Dittrich and P. C. Lockemann, Das KARAMBA-Methodenbanksystem,
Tagungshand der 9. GI-Jahrestagung (1979) pp. 322 336.
M. Holocher and D. Sohe. AMBAS, an adaptative method base shell, in Enterpri.se lntegratum
Modeling, Proc. I.st bit. Conl., ed C. Petrie (MIT Press, 1992).
C V Jones, An introduction to graph-ba~d modeling systems. Part 1: Overview, ORSA J. C o m p
2 ( 1990},
C.V. Jones, An introduction to graph-based modeling systems, Part ll: Graph-grammars and
their implementation, ORSA J. Comp. 3 (1991).
R. Krishnan. P. Piela and A. Westerberg. Reusing mathematical models in ASCEND, Proc.
NA TO ASI on Decision Support Sy.stem~ ( 1991 }, to appear.
T K.:impke, F.J. Radermacher. and P. Wolf. Supporting preference elicitation. The FAW preference elicitation tool. Dec. Support Syst. 9 11993) 381 392.
EL. Lawler, Sequencing jobs to minimize total weighted completion time subject to precedence
constraints, A n n Discr. Math. 2 (1978} 75 90
452
R. Mt~ller, D. Solte/ Proposal for project scheduling
[201 L.G. DeMlchiel and RP, Gabriel, The Common Lisp object system: an overview. Proc. European ConL on ObJect Oriented Programrmng, Pans (1987),
[21] D. MOiler and R. MOiler. A concept for the representation of data and algorithms, in: Computational Support fi,r Discrete Mathematics. DIMACS Workshop. eds. N. Dean and G. Shannon
( 19941,
[22] K Mehlhorn and S N/iher. LEDA. a library of efficient data types and algorithms, in: Graph.
Theoretic ('oncepts of Computer Science. Lecture Notes in Computer Sciences, Vol. 411
(Springer, 1990) pp. 88 106.
[23] R.H, MOhring and F.J. Radermacher, The order theoretic approach to scheduling: the deterministic case, in: Advance.s in Pr~qect Scheduling. eds, R. Slowenski and J. Weglarz (Elsevier Science,
Amsterdam, 19891 pp. 26 66.
124 R.H. MOhring and FJ. Radermacher. The order theoretic approach to scheduling: the stochastic
case. in: ,4dvames in Proiect Sche&dmg, eds. R. Slowenski and J. Weglarz [Elsevier Science,
Amsterdam, 1989) pp. 497 531.
1251 ( i . L Nemhauser and M.WP. Savelsbergh, A cutting plane algorithm for single machine scheduling problems ~'ith release times. Proc. Ist ll'orkshop on COST, Rutgers University, DIMACS
Technical Report 91-18 ( 1991 ),
12e,] P Piela, ASCEND. an object oriented computer environment for modeling and analysis, Ph.D
di~,sertatlon. Department of Chemical Engineering, Carnegie-Mellon University (1989).
1271 M, Queyranne and Y. Wang, Single-machine scheduling polyhedra with precedence constraints.
Math. Oper. Res. 16 11991~ 1 20.
[281 H Schultz and W Pulleyblank, Trends in optimization, O R ' M S Today (August, 1991),
[29] I ) Solte, Open Sv.~tcm~ Ein h'rnendes l'erwaltung,~svstem liir die rechnerunterstfit=te Methodenkon.~truktitm tm Bereuh ~h'~ Operations Research, VDI-Fortschrittsberichte, Reihe 16, Nr. 38.
{Vl)I-Verlag, 1987)
[30] J. de Wit and W. Herroelen, An evaluation of microcomputer-based software packages for prolect management. Eur, J. Oper. Res. 49 {1990).