Recent theoretical advances in elimination theory use straight-line programs as a datastructure to represent multivariate polynomials. We present here the Projective Noether Package which is a Maple implementation of one of these new algorithms, yielding as a byproduct a computation of the dimension of a projective variety. Comparative results on benchmarks for time and space of several families of multivariate polynomial equation systems are given and we point out both weaknesses and advantages of different approaches.

In 1525, the painter Albrecht Dürer introduced the notion of a net of a polytope, and published nets for some of the Platonian and Archimedian polyhedra, along with directions about how to construct them. An unfolding of a 3-dimensional polytope P is obtained by cutting the boundary of P along a collection of edges that spans the vertex set of P and then flattening the remaining set to a polygon in the plane. An unfolding is a net if it does not overlap itself. Conversely, a simple connected plane polygon with specific folding lines is a net, if it is possible to fold it into (the boundary of) a polytope. We consider the question whether every 3-dimensional polytope has a net. Although the problem is intuitive and easy to state, and there are nets known for all regular and uniform polytopes, in general it is still unsolved. After giving an overview of related questions and conjectures about the nature or existence of nets for 3-polytopes, we present an account of our experiments wit...

While the theoretical aspects of many graph algorithms are well understood, the practical application of these algorithms imposes some problems: Typically, the implementation is bound to a specific data structure, the results and their representation are predefined etc. On the other hand, since many graph algorithms use other algorithms to solve subproblems, it is necessary to be able to freely choose the input and the output and/or to modify the behavior of the subalgorithms. Since the necessary freedom is normally missing from the implementation of graph algorithms, a programmer of a complex algorithm is forced to implement algorithms in an appropriated way to use them as subalgorithms. Thus, implementing complex algorithms becomes even harder resulting in relatively erroneous implementations if complex algorithms are implemented at all. It would desirable to have implementation of algorithms available which can be used as subalgorithms in a flexible way and which can be applied to arbitrary graph representations. This work introduces and discusses concepts to implement graph algorithms in a reusable fashion. With reusable it is meant that an algorithm can be used with different graph data structures and/or with modified behavior. To achieve this, components for an abstraction from the data structure are

An algorithm component is an implementation of an algorithm which is not intended to be a stand-alone module, but to perform a specific task within a large software package or even within several distinct software packages. Hence, the design of algorithm components must also incorporate software engineering aspects. A key design goal is adaptability: this goal is important for maintenance throughout a project, prototypical development, and reuse in new, unforeseen contextes. However, efficiency must not be sacrificed. The aim of this paper is to identify concrete requirements which must be fulfilled by an algorithm component to meet these general goals. To explore what adaptability of an algorithm component really means, we will discuss an acid test: Dijkstra's algorithm for shortest paths and its application in various realistic scenarios. From this analysis, we will derive general, language-independent design goals, which are intended to support implementations of efficient, adaptabl...

Abstract. Modularization along the boundaries of data structures and algorithms is a commonly-used software decomposition technique in computer science research and practice. When applied, however, it results in incomplete segregation of data structure handling and algorithm code into separate modules. The resulting tight coupling between modules makes it difficult to develop these modules independently, difficult to understand them independently, and difficult to change them independently. Object-oriented computing has maintained the traditional dichotomy between data structures and algorithms by encapsulating only data structures as objects, leaving algorithms to be encapsulated as single procedures whose parameters are such objects. For the full software engineering benefits of the information hiding principle to be realized, data abstractions that encapsulate data structures and algorithms together are essential. 1

Efficiency, flexibility, and ease of use are desirable goals in library design. However, these goals seem to contradict each other. The Library of Efficient Algorithms and Data Structures (LEDA) focuses on efficiency and ease of use. On the other hand, we have developed concepts for the implementation of algorithms which focus on efficiency and flexibility. In this paper, we present a possible combination of these concepts with LEDA, and we report computational results which estimate the resulting run-time overhead. 1. Introduction This paper systematically summarizes the technical project reports [8, 9, 17] and is in addition based on [10, 20]. All implementations in this project were done in C++ (see http://www.informatik. uni-konstanz.de/Research/projects algo.html#projekt5). Many libraries offer efficient data structures and algorithms for various algorithmic problem domains. However, an implementation of an algorithm in a library need not fit seamlessly into every application. H...

this paper, and to add own new classes and algorithms. There are only three conditions that have to be fulfilled: ffl For each algorithm of a problem class P that is to be integrated into PlaNet, P has to be integrated in PlaNet.

Software reusability is an important and difficult problem in general, and this is in particular true for graph algorithms. The usual way to address reusability of graph algorithms is to provide a standard--setting library of data structures (incl. various kinds of graphs), on which graph algorithms may be implemented. In this working paper, we discuss the disadvantages to this approach, and we propose a couple of domain design patterns to overcome these disadvantages. To apply design patterns, we shift the focus from data structures as the primary units of reuse to algorithms themselves. So far, our concept is highly immature, and so is this paper. In fact, this paper merely reflects the state of our discussion and is intended to serve as a base for further dicussions. We are currently implementing a case study (maximum flow problem) in C++ to evaluate our ideas empirically. 1 Introduction Efficiency vs. reusability. Besides mere correctness, there are several design criteria for go...