Anne Kaldewaij

The derivation of a tighter bound for top-down skew heaps

In this paper we present and analyze functional programs for a number of priority queue operations. These programs are based upon the top-down skew heaps—a truly elegant data structure—designed by D.D. Sleator and R.E. Tarjan. We show how their potential technique can be used to determine the time complexity of functional programs. This functional approach enables us to derive a potential function leading to tighter bounds for the amortized costs of the priority queue operations. From the improved bounds it follows, for instance, that Skewsort, a simple sorting program using these operations, requires only about 1.44N log2N comparisons to sort N numbers (in the worst case).

A systolic design for acceptors of regular languages

In this paper we present a derivation method for networks of systolic cells. The method is calculational and can be applied for specifications that are data-independent, i.e. the order of communications does not depend on the values communicated. The techniques used in this style of parallel programming are comparable with techniques used in sequential programming. The presentation is done by means of an example: the derivation of a set of building blocks for the construction of acceptors for regular languages.

The derivation of systolic computations

A method is presented by which systolic computations can be derived from formal specifications. These derivations proceed in a calculational manner, originating from input/output relations and guided by performance considerations. The resulting program is a network of communicating cells that are expressed in a CSP-like program notation. The derivation method is illustrated by means of a nontrivial example, viz. the design of a rank order filter.

The Translation of Processes into Circuits

A process is a pair 〈 A, X 〉 in which A is a set of symbols (the alphabet) and X is a non-empty prefix-closed subset of A* (the trace set). A process may be viewed as the specification of a mechanism: -symbols correspond to events that may occur. -traces correspond to sequences of events that may be observed when the mechanism is in operation.

Some algorithms based on the dual of Dilworth's theorem

Abstract In this paper we present a constructive proof of a theorem on minimal decompositions of partially ordered sets. The structure of this proof indicates a strategy for the development of programs that determine such minimal decompositions. The latter is illustrated by a number of examples.

A Derivation of a Systolic Rank Order Filter with Constant Response Time

A design technique for systolic computations is explained by means of an example. The example is the derivation of a fast, parallel program for rank order filtering. The derivation proceeds in a calculational manner, originating from a formal specification and guided by performance considerations. The resulting solution is a linear systolic array of N cells, where N is the window size. It has constant response time and latency N.

On the decomposition of sequences into ascending subsequences

Proof. Let k be the maximum length of a decreasing subsequence of X. Since any two different elements of a decreasing subsequence of X do not belong to the same ascending subsequence of X, the minimum number of ascending subsequences of X is at least k. For each element of X we define its level ~, 1 ~< d~< k, as the maximum length of a decreasing subsequence of X ending in that element. According to this definition two elements of X with the same level form a non-decreasing subsequence. Hence, for each level d the subsequence consisting of elements of level d is ascending. Moreover, since each element of X has a level, these ascending subsequences are a decomposition of X. Hence, the minimum number of ascending sequences of X is at most k. []

Rank order filters and priority queues

SummaryA derivation of a parallel algorithm for rank order filtering is presented. Both derivation and result differ from earlier designs: the derivations are less complicated and the result allows a number of different implementations. The same derivation is used to design a collection of priority queues. Both filters and priority queues are highly efficient: they have constant response time and small latency.

Searching by Elimination

We present a way of program derivation that is applicable to a wide class of searching problems. Compared to more conventional approaches, this method yields very elegant programs. For a general problem specification, we derive a rather general program scheme. For the specific problem at hand, the general scheme is refined — depending on the mathematical properties of the objects involved — to a particular program. This is illustrated by some examples, varying from elementary problems to more advanced problems.

The matrix as in-situ data structure

It is shown how a matrix can be used to implement a class of dictionaries. Instead of the strong requirement of ascendingness of a linear array, the weaker requirement of ascendingness of a matrix is used. This results in implementations that are efficient in both computation time and storage usage.