Results 1  10
of
11
ECLiPSe: A Platform for Constraint Logic Programming
, 1997
"... This paper introduces the Constraint Logic Programming (CLP) platform ECLiPSe. ECLiPSe is designed to be more than an implementation of CLP: it also supports mathematical programming and stochastic programming techniques. The crucial advantage of ECLiPSe is that it enables the programmer to use a co ..."
Abstract

Cited by 98 (0 self)
 Add to MetaCart
This paper introduces the Constraint Logic Programming (CLP) platform ECLiPSe. ECLiPSe is designed to be more than an implementation of CLP: it also supports mathematical programming and stochastic programming techniques. The crucial advantage of ECLiPSe is that it enables the programmer to use a combination of algorithms appropriate to the application at hand. This benefit results from the ECLiPSe facility to support finegrained hybridisation. ECLiPSe is designed for solving difficult "combinatorial" industrial problems in the areas of planning, scheduling and resource allocation. The platform offers a conceptual modelling language for specifying the problem clearly and simply, in a way that is neutral as to the algorithm which will be used to solve it. Based on the conceptual model it is easy to construct alternative design models, also expressed in ECLiPSe.
Lazy Imperative Programming
 Yale University
, 1993
"... In this paper we argue for the importance of lazy state, that is, sequences of imperative (destructive) actions in which the actions are delayed until their results are required. This enables statebased computations to take advantage of the control power of lazy evaluation. We provide some examples ..."
Abstract

Cited by 29 (5 self)
 Add to MetaCart
In this paper we argue for the importance of lazy state, that is, sequences of imperative (destructive) actions in which the actions are delayed until their results are required. This enables statebased computations to take advantage of the control power of lazy evaluation. We provide some examples of its use, and describe an implementation within Glasgow Haskell. 1 Introduction There has long been a tension between functional programming languages and their more traditional imperative counterparts. On the one hand, functional languages are commonly more expressive and easier to reason about than imperative languages, but on the other hand, certain algorithms and interactions seem to rely fundamentally on statebased computation. It is clearly worth attempting to combine the strengths of each. Some languages like Scheme and ML have incorporated imperative actions as side effects. This approach only makes sense in a callbyvalue language where the order of evaluation is statically de...
The Automated Transformation of Abstract Specifications of Numerical Algorithms into Efficient Array Processor Implementations
 Science of Computer Programming
, 1997
"... We present a set of program transformations which are applied automatically to convert abstract functional specifications of numerical algorithms into efficient implementations tailored to the AMT DAP array processor. The transformations are based upon a formal algebra of a functional array form, wh ..."
Abstract

Cited by 12 (5 self)
 Add to MetaCart
We present a set of program transformations which are applied automatically to convert abstract functional specifications of numerical algorithms into efficient implementations tailored to the AMT DAP array processor. The transformations are based upon a formal algebra of a functional array form, which provides a functional model of the array operations supported by the DAP programming language. The transformations are shown to be complete. We present specifications and derivations of two example algorithms: an algorithm for computing eigensystems and an algorithm for solving systems of linear equations. For the former, we compare the execution performance of the implementation derived by transformation with the performance of an independent, manually constructed implementation; the efficiency of the derived implementation matches that of the manually constructed implementation.
Models for Persistence in Lazy Functional Programming Systems
, 1993
"... Research into providing support for long term data in lazy functional programming systems is presented in this thesis. The motivation for this work has been to reap the benefits of integrating lazy functional programming languages and persistence. The benefits are . the programmer need not write cod ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
Research into providing support for long term data in lazy functional programming systems is presented in this thesis. The motivation for this work has been to reap the benefits of integrating lazy functional programming languages and persistence. The benefits are . the programmer need not write code to support long term data since this is provided as part of the programming system . persistent data can be used in a type safe way since the programming language type system applies to data with the whole range of persistence . the benefits of lazy evaluation are extended to the full lifetime of a data value. Whilst data is reachable, any evaluation performed on the data persists. A data value changes monotonically from an unevaluated state towards a completely evaluated state over time. . interactive data intensive applications such as functional databases can be developed. These benefits are realised by the development of models for persistence in lazy functional programming systems. Tw...
Two Models For Integrating Persistence and Lazy Functional Languages
, 1991
"... A new programming system  STAPLE (Statically Typed Applicative Persistent Language Environment)  which integrates a lazy functional programming language and a persistent store is described. The motivation for introducing orthogonal persistence into a functional setting is given. Two models for ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
A new programming system  STAPLE (Statically Typed Applicative Persistent Language Environment)  which integrates a lazy functional programming language and a persistent store is described. The motivation for introducing orthogonal persistence into a functional setting is given. Two models for achieving this integration are then described together with a discussion of the way laziness interacts with persistence and the benefits resulting from this interaction. In the first model, a system of persistent modules allows the programmer to create persistent values by naming them in a module. In the second model, a combination of stream I/O and a dynamic type allows functional programs to manipulate values already in the persistent store and to allow dynamically created values to become persistent. 1 1 Introduction The integration of persistence and lazy functional programming languages promises to reduce the complexity and improve the efficiency of functional programs. In addition...
Formal Methods within A Totally Functional Approach to Programming”, to appear
 Formal Methods at the Crossroads: from Panacea to Foundational Support”, Proc. 10th Anniversary Colloquium of UNU/IIST, the International Institute for Software Technology of The United Nations
"... Abstract. Taking functional programming to its extremities in search of simplicity still requires integration with other development (e.g. formal) methods. Induction is the key to deriving and verifying functional programs, but can be simplified through packaging proofs with functions, particularly ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Abstract. Taking functional programming to its extremities in search of simplicity still requires integration with other development (e.g. formal) methods. Induction is the key to deriving and verifying functional programs, but can be simplified through packaging proofs with functions, particularly “folds”, on data (structures). “Totally Functional Programming ” avoids the complexities of interpretation by directly representing data (structures) as “platonic combinators ” the functions characteristic to the data. The link between the two simplifications is that platonic combinators are a kind of partiallyapplied fold, which means that platonic combinators inherit foldtheoretic properties, but with some apparent simplifications due to the platonic combinator representation. However, despite observable behaviour within functional programming that suggests that TFP is widelyapplicable, significant work remains before TFP as such could be widely adopted. 1 Programming is Too Hard There can be little doubt that “programming ” (both as metaphor for and essence of the
Reusable Ada libraries supporting infinite data structures
 In Proceedings of the annual ACM SIGAda international conference on Ada
, 1998
"... In this paper we describe a method, based on lazy evaluation, for creating infinite data structures in Ada. We illustrate some potential applications of infinite data structures and describe three different implementation approaches. 1.1 Keywords Ada, functional programming, lazy evaluation, infinit ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
In this paper we describe a method, based on lazy evaluation, for creating infinite data structures in Ada. We illustrate some potential applications of infinite data structures and describe three different implementation approaches. 1.1 Keywords Ada, functional programming, lazy evaluation, infinite data structures. 2.
A Recursive Approach to Multivariate Automatic
 Differentiation”, Optimization Methods and Software
, 1995
"... In one approach to automatic di erentiation, the range of a function is generalized from a single real value to an aggregate representing the values of the function and one or more derivatives. The operations and functions of elementary analysis are extended to these aggregates so as to preserve the ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
In one approach to automatic di erentiation, the range of a function is generalized from a single real value to an aggregate representing the values of the function and one or more derivatives. The operations and functions of elementary analysis are extended to these aggregates so as to preserve the validity of the derivatives. In this paper we develop a recursive approach to de ning the necessary operations in the context of functions of several variables. Formally, the de nitions are essentially the same as those needed in the single variable case. The resulting system provides automatic propagation of values of all partial derivatives up to a prespeci ed order for a function of several variables. 1
Verifying Arithmetic Hardware in HigherOrder Logic
"... Abstract Theorembased design uses logical inference rather than simulation to determine or verify the properties of design implementations. The initial effort to make such an approach practical is large when compared to conventional simulation. However, the cost of this effort is typically incur ..."
Abstract
 Add to MetaCart
Abstract Theorembased design uses logical inference rather than simulation to determine or verify the properties of design implementations. The initial effort to make such an approach practical is large when compared to conventional simulation. However, the cost of this effort is typically incurred only once. The hardware descriptions are parameterized so that the verification results are applicable to an entire set of designs rather than just one instantiation. To illustrate these ideas, the logical structure used to verify arithmetic hardware in HOL is outlined. In particular, the role of data abstraction, recursion, and induction is shown. 1.
Parsec: A practical parser library
, 2001
"... Despite the long list of publications on parser combinators, there does not yet exist a monadic parser combinator library that is applicable in real world situations. In particular naive implementations of parser combinators are likely to su#er from space leaks and are often unable to report precise ..."
Abstract
 Add to MetaCart
Despite the long list of publications on parser combinators, there does not yet exist a monadic parser combinator library that is applicable in real world situations. In particular naive implementations of parser combinators are likely to su#er from space leaks and are often unable to report precise error messages in case of parse errors. The Parsec parser combinator library described in this paper, utilizes a novel implementation technique for space and time e#cient parser combinators that in case of a parse error, report both the position of the error as well as all grammar productions that would have been legal at that point in the input.