Results 21  30
of
52
A New Parallel Skeleton for General Accumulative Computations
 International Journal of Parallel Programming
, 2004
"... this paper, we propose a powerful and general parallel skeleton called accumulate and describe its efficientimplementation in C++ with MPI (Message Passing Interface) (18) as a solution to the above problems. Unlike the approaches that apply such optimizations as loop restructuring to the target p ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
(Show Context)
this paper, we propose a powerful and general parallel skeleton called accumulate and describe its efficientimplementation in C++ with MPI (Message Passing Interface) (18) as a solution to the above problems. Unlike the approaches that apply such optimizations as loop restructuring to the target program, our approach provides a general recursive computation with accumulation as a library function (skeleton) with an optimized implementation. We are based on the data parallel programming model of BMF, which provides us with a concise way to describe and manipulate parallel programs. The main advantages of accumulate can be summarized as follows
Deriving animations from recursive definitions
 In Draft Proceedings of the 14th International Workshop on the Implementation of Functional Languages (IFL’02
, 2002
"... Abstract. This paper describes a generic method to derive an animation from a recursive definition, with the objective of debugging and understanding this definition by expliciting its control structure. This method is based on a well known algorithm of factorizing a recursive function into the comp ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
(Show Context)
Abstract. This paper describes a generic method to derive an animation from a recursive definition, with the objective of debugging and understanding this definition by expliciting its control structure. This method is based on a well known algorithm of factorizing a recursive function into the composition of the producer and the consumer of its call tree. We developed a systematic method to transform both the resulting functions in order to draw the tree step by step. The theory of data types as fixed points of functors, generic recursion patterns, and monads, are fundamental to our work and are briefly presented. Using polytypic implementations of monadic recursion patterns and an application to manipulate and generate graph layouts we developed a prototype that, given a recursive function written in a subset of Haskell, returns a function whose execution yields the desired animation. 1
Short cut fusion: Proved and improved
 Pages 47–71 of: Semantics, Applications, and Implementation of Program Generation
, 2001
"... Abstract. Short cut fusion is a particular program transformation technique which uses a single, local transformation — called the foldrbuild rule — to remove certain intermediate lists from modularly constructed functional programs. Arguments that short cut fusion is correct typically appeal eithe ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Short cut fusion is a particular program transformation technique which uses a single, local transformation — called the foldrbuild rule — to remove certain intermediate lists from modularly constructed functional programs. Arguments that short cut fusion is correct typically appeal either to intuition or to “free theorems ” — even though the latter have not been known to hold for the languages supporting higherorder polymorphic functions and fixed point recursion in which short cut fusion is usually applied. In this paper we use Pitts ’ recent demonstration that contextual equivalence in such languages is relationally parametric to prove that programs in them which have undergone short cut fusion are contextually equivalent to their unfused counterparts. The same techniques in fact yield a much more general result. For each algebraic data type we define a generalization augment of build which constructs substitution instances of its associated data structures. Together with the wellknown generalization cata of foldr to arbitrary algebraic data types, this allows us to formulate and prove correct for each a contextual equivalencepreserving cataaugment fusion rule. These rules optimize compositions of functions that uniformly consume algebraic data structures with functions that uniformly produce substitution instances of them. 1
HOL2P  A system of classical higher order logic with second order polymorphism
 20th International Conference on Theorem Proving in Higher Order Logics: TPHOLs 2007, volume 4732 of Lecture Notes in Computer Science
, 2007
"... Abstract. This paper introduces the logical system HOL2P that extends classical higher order logic (HOL) with type operator variables and universal types. HOL2P has explicit term operations for type abstraction and type application. The formation of type application terms t [ T] is restricted to sma ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
Abstract. This paper introduces the logical system HOL2P that extends classical higher order logic (HOL) with type operator variables and universal types. HOL2P has explicit term operations for type abstraction and type application. The formation of type application terms t [ T] is restricted to small types T that do not contain any universal types. This constraint ensures the existence of a settheoretic model and thus consistency. The expressiveness of HOL2P allows categorytheoretic concepts such as natural transformations and initial algebras to be applied at the level of polymorphic HOL functions. The parameterisation of terms with type operators adds genericity to theorems. Type variable quantification can also be expressed. A prototype of HOL2P has been implemented on top of HOLLight. Type inference is semiautomatic, and some type annotations are necessary. Reasoning is supported by appropriate tactics. The implementation has been used to check some sample derivations. 1
Swapping arguments and results of recursive functions
 In Mathematics of Program Construction, Proceedings, volume 4014 of LNCS
, 2006
"... Abstract. Many useful calculation rules, such as fusion and tupling, rely on wellstructured functions, especially in terms of inputs and outputs. For instance, fusion requires that wellproduced outputs should be connected to wellconsumed inputs, so that unnecessary intermediate data structures ca ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Many useful calculation rules, such as fusion and tupling, rely on wellstructured functions, especially in terms of inputs and outputs. For instance, fusion requires that wellproduced outputs should be connected to wellconsumed inputs, so that unnecessary intermediate data structures can be eliminated. These calculation rules generally fail to work unless functions are wellstructured. In this paper, we propose a new calculation rule called IO swapping. IO swapping exchanges calltime computations (occurring in the arguments) and returntime computations (occurring in the results) of a function, while guaranteeing that the original and resulting function compute the same value. IO swapping enables us to rearrange inputs and outputs so that the existing calculation rules can be applied. We present new systematic derivations of efficient programs for detecting palindromes, and a method of higherorder removal that can be applied to defunctionalize function arguments, as two concrete applications. 1
Automatic visualization of recursion trees: a case study on generic programming
 Electronic Notes in Theoretical Computer Science
"... Although the principles behind generic programming are already well understood, this style of programming is not widespread and examples of applications are rarely found in the literature. This paper addresses this shortage by presenting a new method, based on generic programming, to automatically v ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
Although the principles behind generic programming are already well understood, this style of programming is not widespread and examples of applications are rarely found in the literature. This paper addresses this shortage by presenting a new method, based on generic programming, to automatically visualize recursion trees of functions written in Haskell. Crucial to our solution is the fact that almost any function definition can be automatically factorized into the composition of a fold after an unfold of some intermediate data structure that models its recursion tree. By combining this technique with an existing tool for graphical debugging, and by extensively using Generic Haskell, we achieve a rather concise and elegant solution to this problem. 1
Towards a Modular Program Derivation via Fusion and Tupling
 The First ACM SIGPLAN Conference on Generators and Components, Lecture
, 2002
"... We show how programming pearls can be systematically derived via fusion, followed by tupling transformations. By focusing on the elimination of intermediate data structures (fusion) followed by the elimination of redundant calls (tupling), we systematically realise both space and time efficient algo ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We show how programming pearls can be systematically derived via fusion, followed by tupling transformations. By focusing on the elimination of intermediate data structures (fusion) followed by the elimination of redundant calls (tupling), we systematically realise both space and time efficient algorithms from naive specifications. We illustrate our approach using a wellknown maximum segment sum (MSS) problem, and a lessknown maximum segment product (MSP) problem. While the two problems share similar specifications, their optimised codes are significantly different. This divergence in the transformed codes do not pose any difficulty. By relying on modular techniques, we are able to systematically reuse both code and transformation in our derivation.
Lumberjack Summer Camp: A CrossInstitutional Undergraduate Research Experience in Computer Science
 Computer Science Education
, 2001
"... This paper describes our experiences in leading Lumberjack Summer Camp, a tenweek undergraduate research experience in compilerbased optimization techniques for functional programs, held during the summer of 2000. Like many undergraduate research experiences, Lumberjack Summer Camp was designed ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
This paper describes our experiences in leading Lumberjack Summer Camp, a tenweek undergraduate research experience in compilerbased optimization techniques for functional programs, held during the summer of 2000. Like many undergraduate research experiences, Lumberjack Summer Camp was designed to provide an opportunity for students and faculty to work closely together toward a common research goal. But Lumberjack Summer Camp was designed around an additional aim as well: to bring together a critical mass of researchers from two small liberal arts colleges to pursue individual research projects situated within one overarching, collaborative, cuttingedge research endeavor. We explore some important consequences of this design choice, ultimately o#ering Lumberjack Summer Camp as an unusual, but very workable, model for undergraduate research experiences.
A Calculational Framework for Parallelization of Sequential Programs
 In International Symposium on Information Systems and Technologies for Network Society
, 1997
"... this paper, we propose ..."
The expression lemma ⋆
"... Abstract. Algebraic data types and catamorphisms (folds) play a central role in functional programming as they allow programmers to define recursive data structures and operations on them uniformly by structural recursion. Likewise, in objectoriented (OO) programming, recursive hierarchies of objec ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Algebraic data types and catamorphisms (folds) play a central role in functional programming as they allow programmers to define recursive data structures and operations on them uniformly by structural recursion. Likewise, in objectoriented (OO) programming, recursive hierarchies of object types with virtual methods play a central role for the same reason. There is a semantical correspondence between these two situations which we reveal and formalize categorically. To this end, we assume a coalgebraic model of OO programming with functional objects. The development may be helpful in deriving refactorings that turn sufficiently disciplined functional programs into OO programs of a designated shape and vice versa. Key words: expression lemma, expression problem, functional object, catamorphism, fold, the composite design pattern, program calculation, distributive law, free monad, cofree comonad. 1