We consider the problem of laying out a tree with fixed parent/child structure in hierarchical memory. The goal is to minimize the expected number of block transfers performed during a search along a root-to-leaf path, subject to a given probability distribution on the leaves. This problem was previously considered by Gil and Itai, who developed optimal but slow algorithms when the block-transfer size B is known. We present faster but approximate algorithms for the same problem; the fastest such algorithm runs in linear time and produces a solution that is within an additive constant of optimal. In addition, we show how to extend any approximately optimal algorithm to the cache-oblivious setting in which the block-transfer size is unknown to the algorithm. The query performance of the cache-oblivious layout is within a constant factor of the query performance of the optimal known-block-size layout. Computing the cacheoblivious layout requires only logarithmically many calls to the layout algorithm for known block size; in particular, the cache-oblivious layout can be computed in O(N lg N) time, where N is the number of nodes. Finally, we analyze two greedy strategies, and show that they have a performance ratio between Ω(lg B / lg lg B) and O(lg B) when compared to the optimal layout.

Abstract not found

INTRODUCTION Linear logic [Girard87] [Lafont88] [Abramsky93] has been proposed as the basis for a "linear" computer language which preserves the cleanliness of functional programming, yet allows efficient "update-in-place" array operations, no tracing garbage collection and no synchronization. However, some early measurements on linear languages have been disappointing. Wakeling [Wakeling91] complains about the inefficiencies of his version of "linear" ML, especially on list and array variants of Quicksort sorting algorithm, as well as about the stilted linear programming style. We have programmed several versions of Quicksort in a linear fragment of Common Lisp, and---contrary to the conclusions of [Wakeling91]---find that Linear Lisp produces a very fast Quicksort routine. In fact, a linear Quicksort routine for lists (which doesn't require garbage collection) is considerably faster than a non-linear Quicksort routine for lists (which does require garbage collection)

Numbers and strings are two objects manipulated by most programs. Hashing has been well-studied for numbers and it has been effective in practice. In contrast, basic hashing issues for strings remain largely unexplored. In this paper, we identify and formulate the core hashing problem for strings that we call substring hashing. Our main technical results are highly efficient sequential/parallel (CRCW PRAM) Las Vegas type algorithms that determine a perfect hash function for substring hashing. For example, given a binary string of length n, one of our algorithms finds a perfect hash function in O(log n) time, O(n) work, and O(n) space; the hash value for any substring can then be computed in O(log log n) time using a single processor. Our approach relies on a novel use of the suffix tree of a string. In implementing our approach, we design optimal parallel algorithms for the problem of determining weighted ancestors on a edge-weighted tree that may be of independent interest.

For two decades, the Colless index has been the most frequently used statistic for assessing the balance of phylogenetic trees. In this article, this statistic is studied under the Yule and uniform model of phylogenetic trees. The main tool of analysis is a coupling argument with another well-known index called the Sackin statistic. Asymptotics for the mean, variance and covariance of these two statistics are obtained, as well as their limiting joint distribution for large phylogenies. Under the Yule model, the limiting distribution arises as a solution of a functional fixed point equation. Under the uniform model, the limiting distribution is the Airy distribution. The cornerstone of this study is the fact that the probabilistic models for phylogenetic trees are strongly related to the random permutation and the Catalan models for binary search trees.

Abstract. We show that sorting a sufficiently long list of length N using Shellsort with m increments (not necessarily decreasing) requires at least N 1+c/ √ m comparisons in the worst case, for some constant c> 0. For m ≤ (log N / log log N) 2 we obtain an upper bound of the same form. We also prove that Ω(N(log N / log log N) 2) comparisons are needed regardless of the number of increments. Our approach is general enough to apply to other sorting algorithms, including Shaker-sort, for which an even stronger result is proved. 1.

: We provide complete average-case as well as probabilistic analysis of the cost of bucket selection and sorting algorithms. Two variations of bucketing (and flavors therein) are considered: distributive bucketing (large number of buckets) and radix bucketing (recursive with a small number of buckets, suitable for digital computation). For Distributive Selection a compound Poisson limit is established. For all other flavors of bucket selection and sorting, central limit theorems underlying the cost are derived by asymptotic techniques involving perturbation of Rice's integral and contour integration (saddle point methods). In the case of radix bucketing, periodic fluctuations appear in the moments of both the selection and sorting algorithms. (R'esum'e : tsvp) Unit'e de recherche INRIA Rocquencourt Domaine de Voluceau, Rocquencourt, BP 105, 78153 LE CHESNAY Cedex (France) T'el'ephone : (33) 01 39 63 55 11 -- T'el'ecopie : (33) 01 39 63 53 Variations analytiques sur la s'election et l...

We show that the number of renewals up to time t exhibits distributional fluctuations as t → ∞ if the underlying lifetimes increase at an exponential rate in a distributional sense. This provides a probabilistic explanation for the asymptotics of insertion depth in random trees generated by a bit-comparison strategy from uniform input; we also obtain a representation for the resulting family of limit laws along subsequences. Our approach can also be used to obtain rates of convergence.

We consider the problem of generating layouts of multi-level networks, in particular, switching, sorting, and interconnection networks, as compactly as possible, that is, with minimum area, on VLSI grids. Besides traditional interest in these problems motivated by interconnection topologies in parallel computing and switching circuits in telecommunications, there is renewed interest in such layouts as routers in ATM (Asynchronous Transfer Mode) switches. Our results improve on the existing area bounds for these networks by factors of up to 3. At the core, they rely on a systematic, combinatorial approach that we develop for the layout of general permutation networks as well as certain special classes of permutations. 1 Introduction We study the problem of laying out multi-level networks in general, and various switching, sorting and interconnection networks in particular, on a VLSI chip. The goal is to produce compact layouts, that is, layouts with the smallest possible grid area for...

This document contains draft information from a section of a preliminary version of a VERBMOBIL deliverable (TP 5.3-P1). It is distributed in this form to assist partners in advance planning. This document contains a simple version of the core DATR inference engine in Prolog in order to illustrate the principles of DATR inference to Prolog programmers. Note that in minor details it departs slightly from DATR conventions: - nonstandard nodenames are permitted; - the knowledge base must be pre-sorted to permit 'longest path first' inference; - queries include the theory name. Note also that this is not a directly usable implementation: there is no user interface, no DATR-Prolog interpreter, no DATR-specific trace or debugging, no attention paide to efficiency, etc. The aim is to provide a minimal 'core DATR standard inference' interpreter in logical style. 1 Illustration of a DATR theory: a 'microlexicon' MINILEX.DTR Tablecloth: !? == Compound !ilex? == lemma !relation? == (for covering) !modifier? == "Table:!?" !head? == "Cloth:!?". Table: !? == Simplex !ilex? == lemma !meaning? == (horizontal surface to put things on) !orthography? == (t a b l e). Cloth: !? == Simplex !ilex? == lemma 32 Dafydd Gibbon !meaning? == (variety of textile) !orthography? == (c l o t h). Compound: !? == Word !ilex? == generalisation !type? == compound !meaning? == ("!head meaning?" "!relation?" "!modifier meaning?") !orthography? == ("!modifier orthography?" "!head orthography?"). Simplex: !? == Word !ilex? == generalisation !type? == simplex. Word: !ilex? == generalisation !type? == word. Theorems: Tablecloth:!relation?=(for covering). Tablecloth:!meaning?=(variety of textile for covering horizontal surface to put things on). Tablecloth:!orthography?=(t a b l e c l o t h). Table:!orthography...