Parallel functional programming on recursively 
defined data via data-parallel recursion

This article proposes a new language mechanism for data-parallel processing of dynamically allocated recursively defined data. Different from the conventional array-based data- parallelism, it allows parallel processing of general recursively defined data such as lists or trees in a functional way. This is achieved by representing a recursively defined datum as a system of equations, and defining new language constructs for parallel transformation of a system of equations. By integrating them with a higher-order functional language, we obtain a functional programming language suitable for describing data-parallel algorithms on recursively defined data in a declarative way. The language has an ML style polymorphic type system and a type sound operational semantics that uniformly integrates the parallel evaluation mechanism with the semantics of a typed functional language. We also show the intended parallel execution model behind the formal semantics, assuming an idealized distributed memory multicomputer.

Download Full-text

A Scientific Calculator for Exact Real Number Computation Based on LRT, GMP and FC++

Acta Universitaria ◽

10.15174/au.2012.339 ◽

2012 ◽

Vol 22 ◽

pp. 35-41

Author(s):

Alejandra Lucatero ◽

J. Raymundo Marcial-Romero ◽

J. A. Hernández

Keyword(s):

Real Number ◽

Programming Language ◽

Functional Programming ◽

Operational Semantics ◽

Trigonometric Functions ◽

Lazy Evaluation ◽

Evaluation Mechanism ◽

The One ◽

Exact Real Number Computation ◽

Scientific Calculator

Language for Redundant Test (LRT) is a programming language for exact real number computation. Its lazy evaluation mechanism (also called call-by-need) and its infinite list requirement, make the language appropriate to be implemented in a functional programming language such as Haskell. However, a direction translation of the operational semantics of LRT into Haskell as well as the algorithms to implement basic operations (addition subtraction, multiplication, division) and trigonometric functions (sin, cosine, tangent, etc.) makes the resulting scientific calculator time consuming and so inefficient. In this paper, we present an alternative implementation of the scientific calculator using FC++ and GMP. FC++ is a functional C++ library while GMP is a GNU multiple presicion library. We show that a direct translation of LRT in FC++ results in a faster scientific calculator than the one presented in Haskell.

Download Full-text

Typing first-class continuations in ML

Journal of Functional Programming ◽

10.1017/s095679680000085x ◽

1993 ◽

Vol 3 (4) ◽

pp. 465-484 ◽

Cited By ~ 26

Author(s):

Robert Harper ◽

Bruce F. Duba ◽

David Macqueen

Keyword(s):

Operational Semantics ◽

Type System ◽

Type Systems ◽

Functional Language ◽

Type Assignment ◽

Polymorphic Type ◽

Alternative Type

AbstractAn extension of ML with continuation primitives similar to those found in Scheme is considered. A number of alternative type systems are discussed, and several programming examples are given. A continuation-based operational semantics is defined for a small, purely functional language, and the soundness of the Damas–Milner polymorphic type assignment system with respect to this semantics is proved. The full Damas–Milner type system is shown to be unsound in the presence of first-class continuations. Restrictions on polymorphism similar to those introduced in connection with reference types are shown to suffice for soundness.

Download Full-text

Monadic encapsulation of effects: a revised approach (extended version)

Journal of Functional Programming ◽

10.1017/s0956796801004154 ◽

2001 ◽

Vol 11 (6) ◽

pp. 591-627 ◽

Cited By ~ 24

Author(s):

E. MOGGI ◽

AMR SABRY

Keyword(s):

Ad Hoc ◽

Operational Semantics ◽

Type System ◽

Lambda Calculus ◽

Higher Order ◽

Functional Language ◽

Simple Modification ◽

Type Safety ◽

Original Proposal ◽

Type Parameter

Launchbury and Peyton Jones came up with an ingenious idea for embedding regions of imperative programming in a pure functional language like Haskell. The key idea was based on a simple modification of Hindley-Milner's type system. Our first contribution is to propose a more natural encapsulation construct exploiting higher-order kinds, which achieves the same encapsulation effect, but avoids the ad hoc type parameter of the original proposal. The second contribution is a type safety result for encapsulation of strict state using both the original encapsulation construct and the newly introduced one. We establish this result in a more expressive context than the original proposal, namely in the context of the higher-order lambda-calculus. The third contribution is a type safety result for encapsulation of lazy state in the higher-order lambda-calculus. This result resolves an outstanding open problem on which previous proof attempts failed. In all cases, we formalize the intended implementations as simple big-step operational semantics on untyped terms, which capture interesting implementation details not captured by the reduction semantics proposed previously.

Download Full-text

Dynamic game semantics

Mathematical Structures in Computer Science ◽

10.1017/s0960129520000250 ◽

2020 ◽

pp. 1-60

Author(s):

Norihiro Yamada ◽

Samson Abramsky

Keyword(s):

Programming Languages ◽

Functional Programming ◽

Operational Semantics ◽

Dynamic Game ◽

Standard Interpretation ◽

Functional Programming Languages ◽

Game Semantics ◽

Wide Range ◽

Cartesian Closed Categories ◽

Cartesian Closed

Abstract The present work achieves a mathematical, in particular syntax-independent, formulation of dynamics and intensionality of computation in terms of games and strategies. Specifically, we give game semantics of a higher-order programming language that distinguishes programmes with the same value yet different algorithms (or intensionality) and the hiding operation on strategies that precisely corresponds to the (small-step) operational semantics (or dynamics) of the language. Categorically, our games and strategies give rise to a cartesian closed bicategory, and our game semantics forms an instance of a bicategorical generalisation of the standard interpretation of functional programming languages in cartesian closed categories. This work is intended to be a step towards a mathematical foundation of intensional and dynamic aspects of logic and computation; it should be applicable to a wide range of logics and computations.

Download Full-text

A secure data parallel processing based embedded system for internet of things computer vision using field programmable gate array devices

International Journal of Circuit Theory and Applications ◽

10.1002/cta.2964 ◽

2021 ◽

Author(s):

Kashif Naseer Qureshi ◽

Sundus Qayyum ◽

Muhammad Najam Ul Islam ◽

Gwanggil Jeon

Keyword(s):

Computer Vision ◽

Parallel Processing ◽

Internet Of Things ◽

Embedded System ◽

Field Programmable Gate Array ◽

Data Parallel ◽

Secure Data ◽

Field Programmable ◽

Gate Array

Download Full-text

Research on Big Data Parallel Processing Platform Based on Postal Industry

Proceedings of the 2020 4th International Conference on Digital Signal Processing ◽

10.1145/3408127.3408180 ◽

2020 ◽

Author(s):

Pinglin Yang ◽

Gaizhi Guo

Keyword(s):

Big Data ◽

Parallel Processing ◽

Data Parallel ◽

Processing Platform

Download Full-text

A system of constructor classes: overloading and implicit higher-order polymorphism

Journal of Functional Programming ◽

10.1017/s0956796800001210 ◽

1995 ◽

Vol 5 (1) ◽

pp. 1-35 ◽

Cited By ~ 32

Author(s):

Mark P. Jones

Keyword(s):

Type System ◽

Type Systems ◽

Natural Generalization ◽

Higher Order ◽

Functional Language ◽

Effective Algorithm ◽

Prototype Implementation ◽

Type Classes

AbstractThis paper describes a flexible type system that combines overloading and higher-order polymorphism in an implicitly typed language using a system of constructor classes—a natural generalization of type classes in Haskell. We present a range of examples to demonstrate the usefulness of such a system. In particular, we show how constructor classes can be used to support the use of monads in a functional language. The underlying type system permits higher-order polymorphism but retains many of the attractive features that have made Hindley/Milner type systems so popular. In particular, there is an effective algorithm that can be used to calculate principal types without the need for explicit type or kind annotations. A prototype implementation has been developed providing, amongst other things, the first concrete implementation of monad comprehensions known to us at the time of writing.

Download Full-text