Results 1 
3 of
3
Purely Functional RandomAccess Lists
 In Functional Programming Languages and Computer Architecture
, 1995
"... We present a new data structure, called a randomaccess list, that supports array lookup and update operations in O(log n) time, while simultaneously providing O(1) time list operations (cons, head, tail). A closer analysis of the array operations improves the bound to O(minfi; log ng) in the wor ..."
Abstract

Cited by 17 (2 self)
 Add to MetaCart
We present a new data structure, called a randomaccess list, that supports array lookup and update operations in O(log n) time, while simultaneously providing O(1) time list operations (cons, head, tail). A closer analysis of the array operations improves the bound to O(minfi; log ng) in the worst case and O(log i) in the expected case, where i is the index of the desired element. Empirical evidence suggests that this data structure should be quite efficient in practice. 1 Introduction Lists are the primary data structure in every functional programmer 's toolbox. They are simple, convenient, and usually quite efficient. The main drawback of lists is that accessing the ith element requires O(i) time. In such situations, functional programmers often find themselves longing for the efficient random access of arrays. Unfortunately, arrays can be quite awkward to implement in a functional setting, where previous versions of the array must be available even after an update. Since arra...
Lower Bounds for Dynamic Algebraic Problems
, 1998
"... We consider dynamic evaluation of algebraic functions (matrix multiplication, determinant, convolution, Fourier transform, etc.) in the model of Reif and Tate; i.e., if f(x 1 ; : : : ; xn ) = (y 1 ; : : : ; y m ) is an algebraic problem, we consider serving online requests of the form \change i ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
We consider dynamic evaluation of algebraic functions (matrix multiplication, determinant, convolution, Fourier transform, etc.) in the model of Reif and Tate; i.e., if f(x 1 ; : : : ; xn ) = (y 1 ; : : : ; y m ) is an algebraic problem, we consider serving online requests of the form \change input x i to value v" or \what is the value of output y i ?". We present techniques for showing lower bounds on the worst case time complexity per operation for such problems. The rst gives lower bounds in a wide range of rather powerful models (for instance history dependent algebraic computation trees over any in nite subset of a eld, the integer RAM, and the generalized real RAM model of BenAmram and Galil). Using this technique, we show optimal n) bounds for dynamic matrixvector product, dynamic matrix multiplication and dynamic discriminant and an n) lower bound for dynamic polynomial multiplication (convolution), providing a good match with Reif and Tate's O( n log n) upper bound. We also show linear lower bounds for dynamic determinant, matrix adjoint and matrix inverse and an n) lower bound for the elementary symmetric functions. The second technique is the communication complexity technique of Miltersen, Nisan, Safra, and Wigderson which we apply to the setting of dynamic algebraic problems, obtaining similar lower bounds in the word RAM model. The third technique gives lower bounds in the weaker straight line program model. Using this technique, we show an 457 n) = log log n) lower bound for dynamic discrete Fourier transform.
A Parallel Complexity Model for Functional Languages
 IN: PROC. ACM CONF. ON FUNCTIONAL PROGRAMMING LANGUAGES AND COMPUTER ARCHITECTURE
, 1994
"... A complexity model based on the calculus with an appropriate operational semantics in presented and related to various parallel machine models, including the PRAM and hypercube models. The model is used to study parallel algorithms in the context of "sequential" functional languages, and to relate ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
A complexity model based on the calculus with an appropriate operational semantics in presented and related to various parallel machine models, including the PRAM and hypercube models. The model is used to study parallel algorithms in the context of "sequential" functional languages, and to relate these results to algorithms designed directly for parallel machine models. For example, the paper shows that equally good upper bounds can be achieved for merging two sorted sequences in the pure calculus with some arithmetic constants as in the EREW PRAM, when they are both mapped onto a more realistic machine such as a hypercube or butterfly network. In particular for n keys and p processors, they both result in an O(n=p + log 2 p) time algorithm. These results argue that it is possible to get good parallelism in functional languages without adding explicitly parallel constructs. In fact, the lack of random access seems to be a bigger problem than the lack of parallelism. This research...