The foundations of functional programming languages are examined from both historical and technical perspectives. Their evolution is traced through several critical periods: early work on lambda calculus and combinatory calculus, Lisp, Iswim, FP, ML, and modern functional languages such as Miranda ’ and Haskell. The fundamental premises on which

Theorie"en voor het berekenen van algoritmen (met een samenvatting in het Nederlands) PROEFSCHRIFT ter verkrijging van de graad van doctor aan de Rijksuniversiteit te Utrecht op gezag van de Rector Magnificus, Prof. Dr. J.A. van Ginkel ingevolge het besluit van het College van Dekanen

We describe the SVP data model. The goal of SVP is to model both set and stream data, and to model parallelism in bulk data processing. SVP also shows promise for other parallel processing applications. SVP models collections, which include sets and streams as special cases. Collections are represented as ordered tree structures, and divide-and-conquer mappings are easily defined on these structures. We show that many useful database mappings (queries) have a divide-and-conquer format when specified using collections, and that this specification exposes parallelism. We formalize a class of divide-and-conquer mappings on collections called SVP-transducers. SVP-transducers generalize aggregates, set mappings, stream transductions, and scan computations. At the same time, they have a rigorous semantics based on continuity with respect to collection orderings, and permit implicit specification of both independent and pipeline parallelism. 1 Introduction Achieving parallelism in bulk data...

DATA TYPES A. Comparing Type Objects There has been as much confusion over type identity as there has been over object identity, although the type identity problem is usually referred to as the type equivalence problem [Aho86,s.6.3] [Wegbreit74] [Welsh77]. The type identity problem is to determine when two types are equal, so that type checking can be done in a programming language. 22 Algol-68 takes the point of view of "structural" equivalence, in which nonrecursive types that are built up from primitive types using the same type constructors in the same order should compare equal, while Ada takes the point of view of "name" equivalence, in which types are equivalent if and only if they have the same name. We will ignore the software engineering issues of which kind of type equivalence makes for better-engineered programs, and focus on the basic issue of type equivalence itself. We note that if a type system offers the type TYPE---i.e., it offers first-class representations of typ...

Gaussian elimination is probably the best known and most widely used method for solving linear systems, computing determinants, and finding matrix decompositions. While the basic elimination procedure is simple to state and implement, it becomes more complicated with the addition of a pivoting procedure, which handles degenerate matrices having zero elements on the diagonal. Pivoting can significantly complicate the algorithm, increase data movement, and reduce speed, particularly on high-performance computers. In this paper we propose an alternative scheme for performing Gaussian elimination that first preconditions the input matrix by multiplying it with random matrices, whose inverses can be applied subsequently. At the expense of these multiplications, and making the linear system dense if it was not already, this approach makes the system `nondegenerate' --- subsystems have full rank --- with probability 1. This preconditioning has the effect of (almost certainly) eliminating the ...

this paper is on writing parallel programs, we will not say more about programming in Miranda. 5 Tools and annotations for parallelism

We present a new randomization scheme that preconditions an input linear system by multiplying it with nonsingular random matrices. At the expense of these multiplications, and making the linear system dense if it was not already, this approach makes blocks of the resulting system nonsingular with probability 1. Specifically, in this paper we consider random matrices that are `random butterflies', and call their application a Random Butterfly Transformation (RBT). RBTs can be performed efficiently, and in particular should be useful on parallel and vector machines with architectures that support FFT-like computations. Block Gaussian elimination is an important example of an algorithm with which this RBT can be used. Gaussian elimination is complicated by pivoting, which handles degenerate matrices having zero elements on the diagonal. Pivoting can significantly complicate the algorithm, increase data movement, and reduce speed, particularly on high-performance computers. We show that t...

Abstract Recursive block decomposition algorithms (also known as quadtree algorithms when the blocks are all square) have been proposed to solve well-known problems such as matrix addition, multiplication, inversion, determinant computation, block LDU decomposition, and Cholesky and QR factorization. Until now, such algorithms have been seen as impractical, since they require leading submatrices of the input matrix to be invertible (which is rarely guaranteed). We show how to randomize an input matrix to guarantee that submatrices meet these requirements, and to make recursive block decomposition methods practical on wellconditioned input matrices. The resulting algorithms are elegant, and we show the recursive programs can perform well for both dense and sparse matrices, although with randomization dense computations seem most practical. By `homogenizing ' the input, randomization provides a way to avoid degeneracy in numerical problems that permits simple recursive quadtree algorithms to solve these problems. 1 Introduction We have been investigating alternative computation schemes for large-scale matrix computations. A natural functional programming approach called recursive block decomposition (or quadtree decomposition when the blocks are all square) operates via divide-and-conquer recursion. 1.1 Recursive Block Decomposition Algorithms The basic idea here is that when a matrix is decomposed into smaller blocks, many useful functions of the matrix can be computed recursively. A natural question is whether recursive programming can play a practical role in numerical computation, although today most numerical algorithms are programmed iteratively.

Many scheduling and synchronization problems for large-scale multiprocessing can be overcome using functional (or applicative) programming. With this observation, it is strange that so much attention within the functional programming community has focused on the "aggregate update problem" [10]: essentially how to implement FORTRAN arrays. This situation is strange because in-place updating of aggregates belongs more to uniprocessing than to mathematics. Several years ago functional style drew me to treatment of d-dimen- sional arrays as 2 d --ary trees; in particular, matrices become quaternary trees or quadtrees. This convention yields efficient recopying-cum-update of any array; recursive, algebraic decomposition of conventional arithmetic algorithms; and uniform representations and algorithms for both dense and sparse matrices. For instance, any nonsingular subtree is a candidate as the pivot block for Gaussian elimination; the restriction actually helps identification of pivot b...