Results 1  10
of
13
Dijkstra’s algorithm with Fibonacci heaps: An executable description
 in CHR. In 20th Workshop on Logic Programming (WLP’06
, 2006
"... Abstract. We construct a readable, compact and efficient implementation of Dijkstra’s shortest path algorithm and Fibonacci heaps using Constraint Handling Rules (CHR), which is increasingly used as a highlevel rulebased generalpurpose programming language. We measure its performance in different ..."
Abstract

Cited by 18 (11 self)
 Add to MetaCart
Abstract. We construct a readable, compact and efficient implementation of Dijkstra’s shortest path algorithm and Fibonacci heaps using Constraint Handling Rules (CHR), which is increasingly used as a highlevel rulebased generalpurpose programming language. We measure its performance in different CHR systems, investigating both the theoretical asymptotic complexity and the constant factors realized in practice. 1
Purely Functional Representations of Catenable Sorted Lists.
 In Proceedings of the 28th Annual ACM Symposium on Theory of Computing
, 1996
"... The power of purely functional programming in the construction of data structures has received much attention, not only because functional languages have many desirable properties, but because structures built purely functionally are automatically fully persistent: any and all versions of a structur ..."
Abstract

Cited by 16 (5 self)
 Add to MetaCart
The power of purely functional programming in the construction of data structures has received much attention, not only because functional languages have many desirable properties, but because structures built purely functionally are automatically fully persistent: any and all versions of a structure can coexist indefinitely. Recent results illustrate the surprising power of pure functionality. One such result was the development of a representation of doubleended queues with catenation that supports all operations, including catenation, in worstcase constant time [19].
Twotier relaxed heaps
 Proceedings of the 17th International Symposium on Algorithms and Computation, Lecture Notes in Computer Science 4288, SpringerVerlag
, 2006
"... Abstract. We introduce an adaptation of runrelaxed heaps which provides efficient heap operations with respect to the number of element comparisons performed. Our data structure guarantees the worstcase cost of O(1) for findmin, insert, and decrease; and the worstcase cost of O(lg n) with at mos ..."
Abstract

Cited by 11 (8 self)
 Add to MetaCart
Abstract. We introduce an adaptation of runrelaxed heaps which provides efficient heap operations with respect to the number of element comparisons performed. Our data structure guarantees the worstcase cost of O(1) for findmin, insert, and decrease; and the worstcase cost of O(lg n) with at most lg n + 3 lg lg n + O(1) element comparisons for delete, improving the bound of 3lg n + O(1) on the number of element comparisons known for runrelaxed heaps. Here, n denotes the number of elements stored prior to the operation in question, and lg n equals max {1, log 2 n}. 1
Future Directions In Program Transformations
, 1997
"... This paper briefly surveys what transformational programming is about, and how to make progress in the field. A program transformation is a meaningpreserving mapping defined on a programming language. Transformational programming is a program development methodology in which an implementation I is ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
This paper briefly surveys what transformational programming is about, and how to make progress in the field. A program transformation is a meaningpreserving mapping defined on a programming language. Transformational programming is a program development methodology in which an implementation I is obtained from a specification S by applying a sequence T k :::T 1 of transformations to S. If S and each transformation T i applied to successive implementations T i\Gamma1 :::T 1 S of S are proved correct for
Persistent data structures
 IN HANDBOOK ON DATA STRUCTURES AND APPLICATIONS, CRC PRESS 2001, DINESH MEHTA AND SARTAJ SAHNI (EDITORS) BOROUJERDI, A., AND MORET, B.M.E., "PERSISTENCY IN COMPUTATIONAL GEOMETRY," PROC. 7TH CANADIAN CONF. COMP. GEOMETRY, QUEBEC
, 1995
"... ..."
Realtime Garbage Collection of a Functional Persistent Heap
, 1999
"... Traditional database management systems perform updatesinplace and use logs and periodic checkpointing to efficiently achieve atomicity and durability. In this Thesis we shall present a different method, Shades, for achieving atomicity and durability using a copyonwrite policy instead of updates ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
Traditional database management systems perform updatesinplace and use logs and periodic checkpointing to efficiently achieve atomicity and durability. In this Thesis we shall present a different method, Shades, for achieving atomicity and durability using a copyonwrite policy instead of updatesinplace. We shall also present index structures and the implementation of Shines, a persistent functional programming language, built on top of Shades. Shades includes realtime generational garbage collection. Realtimeness is achieved by collecting only a small part, a generation, of the database at a time. Contrary to previously presented persistent garbage collection algorithms, Shades has no need to maintain metadata (remembered sets) of intrageneration pointers on disk since the metadata can be reconstructed during recovery. This considerably reduces the amount of disk writing. In conjunction with aggressive commit grouping, efficient index structures, a design specialized to a main memory environment, and a carefully crafted implementation of Shines, we have achieved surprisingly high performance, handsomely beating commercial database management systems.
Functional Pearls: Explaining Binomial Heaps
, 1999
"... This paper explains binomial heaps, a beautiful data structure for priority queues, using the functional programming language Haskell (Peterson & Hammond, 1997). We largely follow a deductive approach: using the metaphor of a tennis tournament we show that binomial heaps arise naturally through a nu ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
This paper explains binomial heaps, a beautiful data structure for priority queues, using the functional programming language Haskell (Peterson & Hammond, 1997). We largely follow a deductive approach: using the metaphor of a tennis tournament we show that binomial heaps arise naturally through a number of logical steps. Haskell supports the deductive style of presentation very well: new types are introduced at ease, algorithms can be expressed clearly and succinctly, and Haskell's type classes allow to capture common algorithmic patterns. The paper aims at the level of an undergraduate student who has experience in reading and writing Haskell programs, and who is familiar with the concept of a priority queue. 2 Priority queues
Numerical Representations as HigherOrder Nested Datatypes
, 1998
"... Number systems serve admirably as templates for container types: a container object of size n is modelled after the representation of the number n and operations on container objects are modelled after their numbertheoretic counterparts. Binomial queues are probably the first data structure that wa ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
Number systems serve admirably as templates for container types: a container object of size n is modelled after the representation of the number n and operations on container objects are modelled after their numbertheoretic counterparts. Binomial queues are probably the first data structure that was designed with this analogy in mind. In this paper we show how to express these socalled numerical representations as higherorder nested datatypes. A nested datatype allows to capture the structural invariants of a numerical representation, so that the violation of an invariant can be detected at compiletime. We develop a programming method which allows to adapt algorithms to the new representation in a mostly straightforward manner. The framework is employed to implement three different container types: binary randomaccess lists, binomial queues, and 23 finger search trees. The latter data structure, which is treated in some depth, can be seen as the main innovation from a datastruct...
Automated Benchmarking of Functional Data Structures
 In Practical Aspects of Declarative Languages
, 1999
"... . Despite a lot of recent interest in purely functional data structures, for example [Ada93, Oka95, BO96, Oka96, OB97, Erw97], few have been benchmarked. Of these, even fewer have their performance qualified by how they are used. But how a data structure is used can significantly affect performa ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
. Despite a lot of recent interest in purely functional data structures, for example [Ada93, Oka95, BO96, Oka96, OB97, Erw97], few have been benchmarked. Of these, even fewer have their performance qualified by how they are used. But how a data structure is used can significantly affect performance. This paper makes three original contributions. (1) We present an algorithm for generating a benchmark according to a given use of data structure. (2) We compare use of an automated tool based on this algorithm, with the traditional technique of handpicked benchmarks, by benchmarking six implementations of randomaccess list using both methods. (3) We use the results of this benchmarking to present a decision tree for the choice of randomaccess list implementation, according to how the list will be used. 1 Motivation Recent years have seen renewed interest in purely functional data structures: sets [Ada93], randomaccess lists [Oka95], priority queues [BO96], arrays [OB97], gr...
Relaxed weak queues: an alternative to runrelaxed heaps
, 2005
"... Abstract. A simplification of a runrelaxed heap, called a relaxed weak queue, is presented. This new priorityqueue implementation supports all operations as efficiently as the original: findmin, insert, and decrease (also called decreasekey) in O(1) worstcase time, and delete in O(lg n) worstc ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
Abstract. A simplification of a runrelaxed heap, called a relaxed weak queue, is presented. This new priorityqueue implementation supports all operations as efficiently as the original: findmin, insert, and decrease (also called decreasekey) in O(1) worstcase time, and delete in O(lg n) worstcase time, n denoting the number of elements stored prior to the operation. These time bounds are valid on a pointer machine as well as on a randomaccess machine. A relaxed weak queue is a collection of at most ⌊lg n ⌋ + 1 perfect weak heaps, where there are in total at most ⌊lg n ⌋ + 1 nodes that may violate weakheap order. In a pointerbased representation of a perfect weak heap, which is a binary tree, it is enough to use two pointers per node to record parentchild relationships. Due to decrease, each node must store one additional pointer. The auxiliary data structures maintained to keep track of perfect weak heaps and potential violation nodes only require O(lg n) words of storage. That is, excluding the space used by the elements themselves, the total space usage of a relaxed weak queue can be as low as 3n + O(lg n) words. ACM CCS Categories and Subject Descriptors. E.1 [Data Structures]: Lists, stacks, and queues; E.2 [Data Storage Representations]: Linked representations;