Christine Rüb

Exact accumulation of floating-point numbers

The authors present a new idea for designing a chip which computes the exact sum of arbitrarily many floating-point numbers, i.e. it can accumulate the floating-point numbers without cancellation. Such a chip is needed to provide a fast implementation of Kulisch arithmetic. This is a new theory of floating-point arithmetic which makes it possible to compute least significant bit accurate solutions to even ill-conditioned numerical problems. The proposed approach avoids the disadvantages of previously suggested designs which are too large, too slow, or consume too much power. The crucial point is a technique for a fast carry resolution in a long accumulator. It can also be implemented in software. >The authors present a new idea for designing a chip which computes the exact sum of arbitrarily many floating-point numbers, i.e. it can accumulate the floating-point numbers without cancellation. Such a chip is needed to provide a fast implementation of Kulisch arithmetic. This is a new theory of floating-point arithmetic which makes it possible to compute least significant bit accurate solutions to even ill-conditioned numerical problems. The proposed approach avoids the disadvantages of previously suggested designs which are too large, too slow, or consume too much power. The crucial point is a technique for a fast carry resolution in a long accumulator. It can also be implemented in software.<<ETX>>

On the average running time of odd-even merge sort

This paper is concerned with the average running time of Batchers odd-even merge sort when implemented on a collection of processors. We consider the case where the size n of the input is an arbitrary multiple of the number p of processors used. We show that Batchers odd-even merge (for two sorted lists of length m each) can be implemented to run in time O((m/p)(1+log(1+p2/m))) on the average, and that odd-even merge sort can be implemented to run in time O((n/p)(log(n/p)+logp(1+log(1+p2/n)))) on the average. In the case of merging (sorting) the average is taken over all possible outcomes of the merging (all possible permutations of n elements). That means that odd-even merge and odd-even merge sort have an optimal average running time if n≥p2.

On the Average Running Time of Odd-Even Merge Sort

This paper gives an upper bound for the average running time of Batchers odd?even merge sort when implemented on a collection of processors. We consider the case wheren, the size of the input, is an arbitrary multiple of the numberpof processors used. We show that Batchers odd?even merge (for two sorted lists of lengthneach) can be implemented to run in timeO((n/p)(log(2+p2/n))) on the average,11In this paper,logxalways meanslog2x.and that odd?even merge sort can be implemented to run in timeO((n/p)(logn+logplog(2+p2/n))) on the average. In the case of merging (sorting), the average is taken over all possible outcomes of the merge (all possible permutations ofnelements). That means that odd?even merge and odd?even merge sort have an optimal average running time ifn?p2. The constants involved are also quite small.

Lower bounds for merging on the hypercube

We show lower bounds for the problems of merging two sorted lists of equal length and sorting by repeatedly merging pairs of sorted sequences on the hypercube. These lower bounds hold on the average for any ordering of the processors of the hypercube.

A circuit for exact summation of floating-point numbers

In recent years methods for solving numerical problems have been developed which in contrast to traditional numerical methods compute intervals which are proven to contain the true solution of the given problem (cf. [10,11]). These methods rely on an exact evaluation of inner product expressions in order to obtain good (i.e. small) enclosure intervals. Practical experience has shown that using these methods even ill conditioned problems can often be solved with maximum accuracy. Since the exact inner product computation is a basic operation for these methods we developed a circuit to support the difficult part of the inner product computation: the accurate accumulation of the partial products.

On Batcher's Merge Sorts as Parallel Sorting Algorithms

We examine the average running times of Batchers bitonic merge and Batchers odd-even merge when they are used as parallel merging algorithms. It has been shown previously that the running time of odd-even merge can be upper bounded by a function of the maximal rank difference for elements in the two input sequences. Here we give an almost matching lower bound for odd-even merge as well as a similar upper bound for (a special version of) bitonic merge. From this follows that the average running time of odd-even merge (bitonic merge) is Θ((n/p)(1+log(1+p 2/n))) (O((n/p)(1+log(1+p 2/n))), resp.) where n is the size of the input and p is the number of processors. Using these results we then show that the average running times of odd-even merge sort and bitonic merge sort are O((n/p) (log n + (log(1 +p2/n))2)), that is, the two algorithms are optimal on the average if \(n \geqslant p^2 /2^{\sqrt {\log p} }\).