Results 11 
13 of
13
Auburn: A Kit for Benchmarking Functional Data Structures
 LECTURE NOTES IN COMPUTER SCIENCE
, 1997
"... Benchmarking competing implementations of a data structure can be both tricky and time consuming. The efficiency of an implementation may depend critically on how it is used. This problem is compounded by persistence. All purely functional data structures are persistent. We present a kit that c ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
Benchmarking competing implementations of a data structure can be both tricky and time consuming. The efficiency of an implementation may depend critically on how it is used. This problem is compounded by persistence. All purely functional data structures are persistent. We present a kit that can generate benchmarks for a given data structure. A benchmark is made from a description of how it should use an implementation of the data structure. The kit will improve the speed, ease and power of the process of benchmarking functional data structures.
Improved Multiunit Auction Clearing Algorithms with Interval (MultipleChoice) Knapsack Problems
"... Abstract. We study the interval knapsack problem (IKP), and the interval multiplechoice knapsack problem (IMCKP), as generalizations of the classic 0/1 knapsack problem (KP) and the multiplechoice knapsack problem (MCKP), respectively. Compared to singleton items in KP and MCKP, each item i in I ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Abstract. We study the interval knapsack problem (IKP), and the interval multiplechoice knapsack problem (IMCKP), as generalizations of the classic 0/1 knapsack problem (KP) and the multiplechoice knapsack problem (MCKP), respectively. Compared to singleton items in KP and MCKP, each item i in IKP and IMCKP is represented by a ([ai, bi], pi) pair, where integer interval [ai, bi] specifies the possible range of units, and pi is the unitprice. Our main results are a FPTAS for IKP with time O(nlog n + n/ǫ 2) and a FPTAS for IMCKP with time O(nm/ǫ), and pseudopolynomialtime algorithms for both IKP and IMCKP with time O(nM) and space O(n + M). Here n, m, and M denote number of items, number of item sets, and knapsack capacity respectively. We also present a 2approximation of IKP and a 3approximation of IMCKP both in linear time. We apply IKP and IMCKP to the singlegood multiunit sealedbid auction clearing problem where M identical units of a single good are auctioned. We focus on two bidding models, among them the interval model allows each bid to specify an interval range of units, and XORinterval model allows a bidder to specify a set of mutually exclusive interval bids. The interval and XORinterval bidding models correspond to IKP and IMCKP respectively, thus are solved accordingly. We also show how to compute VCG payments to all the bidders with an overhead of O(log n) factor. Our results for XORinterval bidding model imply improved algorithms for the piecewise constant bidding model studied by Kothari et al. [18], improving their algorithms by a factor of Ω(n). 1
Loopless Functional Algorithms
, 2005
"... Loopless algorithms generate successive combinatorial patterns in constant time, producing the first in time linear to the size of input. Although originally formulated in an imperative setting, this thesis proposes a functional interpretation of these algorithms in the lazy language Haskell. Since ..."
Abstract
 Add to MetaCart
Loopless algorithms generate successive combinatorial patterns in constant time, producing the first in time linear to the size of input. Although originally formulated in an imperative setting, this thesis proposes a functional interpretation of these algorithms in the lazy language Haskell. Since it may not be possible to produce a pattern in constant time, a list of integers generated using the library function unfoldr determines the transitions between consecutive patterns. The generation of Gray codes, permutations, ideals of posets and combinations illustrate applications of loopless algorithms in both imperative and functional form, particularly derivations of the KodaRuskey and JohnsonTrotter algorithms. Common themes in the construction of loopless imperative algorithms, such as focus pointers, doubly linked lists and coroutines, contrast greatly with the functional uses of realtime queues, tree traversals, fusion and tupling.