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

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.

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

1999 ◽  
Vol 9 (4) ◽  
pp. 427-462 ◽  
Author(s):  
SUSUMU NISHIMURA ◽  
ATSUSHI OHORI
Keyword(s):  
Parallel Processing ◽  
Functional Programming ◽  
Formal Semantics ◽  
Operational Semantics ◽  
Type System ◽  
Parallel Execution ◽  
System Of Equations ◽  
Functional Language ◽  
Data Parallel ◽  
Evaluation Mechanism

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.

Structured Operational Semantics of a fragment of the language Scheme

1998 ◽  
Vol 8 (4) ◽  
pp. 335-365 ◽  
Author(s):  
FURIO HONSELL ◽  
ALBERTO PRAVATO ◽  
SIMONA RONCHI DELLA ROCCA
Keyword(s):  
Programming Language ◽  
Functional Programming ◽  
Operational Semantics ◽  
Formal Systems ◽  
Functional Programming Language

In this paper we give a big-step Structured Operational Semantics (SOS), in the style of Plotkin, Kahn and Milner, of a significant fragment of the functional programming language Scheme, including quote, eval, quasiquote and unquote. The SOS formalism allows us to discuss incrementally the various features of the language and to keep a low mathematical overhead, thus producing a rigorous account of the semantics of a ‘real’ programming language, which nonetheless has a pedagogical value. More specifically, we formalize four strictly increasing fragments of Scheme, using a number of formal systems which express the evaluation of expressions, the display of output results, and the handling of errors.

scholarly journals Dynamic game semantics

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.

An operational semantics for parallel lazy evaluation

2000 ◽  
Vol 35 (9) ◽  
pp. 162-173 ◽  
Author(s):  
Clem Baker-Finch ◽  
David J. King ◽  
Phil Trinder
Keyword(s):  
Operational Semantics ◽  
Lazy Evaluation

Spreadsheet functional programming

2007 ◽  
Vol 17 (1) ◽  
pp. 131-143 ◽  
Author(s):  
DAVID WAKELING
Keyword(s):  
Programming Language ◽  
Functional Programming ◽  
Functional Programming Language

AbstractThe functional programming community has shown some interest in spreadsheets, but surprisingly no one seems to have considered making a standard spreadsheet, such as Excel, work with a standard functional programming language, such as Haskell. In this paper, we show one way that this can be done. Our hope is that by doing so, we might get spreadsheet programmers to give functional programming a try.

AN OPERATIONAL SEMANTICS FOR THE PARALLEL LANGUAGE EDEN

2002 ◽  
Vol 12 (02) ◽  
pp. 211-228 ◽  
Author(s):  
MERCEDES HIDALGO-HERRERO ◽  
YOLANDA ORTEGA-MALLÉN
Keyword(s):  
Operational Semantics ◽  
Transition System ◽  
Lazy Evaluation ◽  
Parallel Language ◽  
Parallel Processes ◽  
System A ◽  
Independent Evaluation ◽  
Level Transition ◽  
Concurrent Algorithms ◽  
Main Thread

The functional parallel language Eden — suitable for the description of parallel and concurrent algorithms in a distributed setting — is an extension of Haskell with a set of coordination features. In this paper we present a formal operational semantics for the kernel of Eden, or more precisely, for a λ-calculus widened with explicit parallelism and potentially infinite communication channels. Eden overrides the lazy nature of Haskell on behalf of parallelism. This interplay between laziness and eagerness is accurately described by the semantics proposed here, which is based on Launchbury's natural semantics for lazy evaluation, and is expressed through a two-level transition system: a lower level for the local and independent evaluation of each process, and an upper one for the coordination between all the parallel processes in the system. As processes are created either under demand or in a speculative way, different scheduling strategies are possible — ranging from a minimal one that only allows the main thread to evolve, to a maximal one that evolves in parallel every active binding.

scholarly journals Development of Kotlin / Native Intermediate Representation and Optimizations

2020 ◽  
Vol 18 (2) ◽  
pp. 15-30
Author(s):  
Sergey S. Bogolepov
Keyword(s):  
Programming Language ◽  
Functional Programming ◽  
Virtual Machines ◽  
Object Oriented ◽  
Experimental Results ◽  
Intermediate Representation ◽  
Improve Performance ◽  
Escape Analysis

Kotlin is a statically typed programming language that supports object-oriented and functional programming. It supports JVM, JS and native platforms via LLVM (Kotlin / Native). The first two targets are backed with well-developed virtual machines that can perform advanced program optimizations at runtime. However, for native platforms, all optimizations must be performed at compile time. Currently Kotlin / Native lacks many optimizations, which is why the performance of the generated code is poor in many cases. This paper describes a way to solve this problem by introducing an additional SSA-based intermediate representation and implementing escape analysis using it. Experimental results have shown that this approach can significantly improve performance.

Sign in / Sign up

Export Citation Format

Share Document