92,746 research outputs found
Programming Languages for Scientific Computing
Scientific computation is a discipline that combines numerical analysis,
physical understanding, algorithm development, and structured programming.
Several yottacycles per year on the world's largest computers are spent
simulating problems as diverse as weather prediction, the properties of
material composites, the behavior of biomolecules in solution, and the quantum
nature of chemical compounds. This article is intended to review specfic
languages features and their use in computational science. We will review the
strengths and weaknesses of different programming styles, with examples taken
from widely used scientific codes.Comment: 21 page
Extending scientific computing system with structural quantum programming capabilities
We present a basic high-level structures used for developing quantum
programming languages. The presented structures are commonly used in many
existing quantum programming languages and we use quantum pseudo-code based on
QCL quantum programming language to describe them. We also present the
implementation of introduced structures in GNU Octave language for scientific
computing. Procedures used in the implementation are available as a package
quantum-octave, providing a library of functions, which facilitates the
simulation of quantum computing. This package allows also to incorporate
high-level programming concepts into the simulation in GNU Octave and Matlab.
As such it connects features unique for high-level quantum programming
languages, with the full palette of efficient computational routines commonly
available in modern scientific computing systems. To present the major features
of the described package we provide the implementation of selected quantum
algorithms. We also show how quantum errors can be taken into account during
the simulation of quantum algorithms using quantum-octave package. This is
possible thanks to the ability to operate on density matrices
AutoParallel: A Python module for automatic parallelization and distributed execution of affine loop nests
The last improvements in programming languages, programming models, and
frameworks have focused on abstracting the users from many programming issues.
Among others, recent programming frameworks include simpler syntax, automatic
memory management and garbage collection, which simplifies code re-usage
through library packages, and easily configurable tools for deployment. For
instance, Python has risen to the top of the list of the programming languages
due to the simplicity of its syntax, while still achieving a good performance
even being an interpreted language. Moreover, the community has helped to
develop a large number of libraries and modules, tuning them to obtain great
performance.
However, there is still room for improvement when preventing users from
dealing directly with distributed and parallel computing issues. This paper
proposes and evaluates AutoParallel, a Python module to automatically find an
appropriate task-based parallelization of affine loop nests to execute them in
parallel in a distributed computing infrastructure. This parallelization can
also include the building of data blocks to increase task granularity in order
to achieve a good execution performance. Moreover, AutoParallel is based on
sequential programming and only contains a small annotation in the form of a
Python decorator so that anyone with little programming skills can scale up an
application to hundreds of cores.Comment: Accepted to the 8th Workshop on Python for High-Performance and
Scientific Computing (PyHPC 2018
NCLab: Public Computing Laboratory
This survey paper describes the Network Computing Laboratory (NCLab), a novel public cloud computing platform for mathematics, programming, scientific computing and computer simulations. Through a web-browser interface, it provides users with free access to interactive graphical modules that include symbolic and numerical methods, programming in several languages, computing with Python scientific libraries, computing with GNU Octave, GPU computing with CUDA, computational geometry, 3D CAD design, computational graph theory, finite element programming with the Hermes library, and interactive graphical finite element modules. Users can upload files and data from their local computers, clone projects from the database, share files, form teams, and collaborate on projects. This paper briefly describes how NCLab operates, and it provides concise descriptions of NCLab computational modules with examples of us
Distributed Partial Differential Equation Solving with Julia Fast Fourier Transform Library
Scientific computing relies on advanced computational and mathematical techniques to solve complex problems in scientific domains. For the numerical rendering of spectral, nonlinear, and dynamic phenomena, there is a growing need for greater availability of a broad class of Fourier-based algorithms to perform large scale operations on multidimensional data in distributed and optimized ways. To this effect, the Julia programming language is new and has significant advantages compared to other common languages used in scientific computing. The research presented here formulates a basis for further development in high-performance scientific computing of periodic partial differential equations through the application of distributed Fast Fourier Transforms in Julia with the PencilFFTs.jl library
A Domain-Specific Language and Editor for Parallel Particle Methods
Domain-specific languages (DSLs) are of increasing importance in scientific
high-performance computing to reduce development costs, raise the level of
abstraction and, thus, ease scientific programming. However, designing and
implementing DSLs is not an easy task, as it requires knowledge of the
application domain and experience in language engineering and compilers.
Consequently, many DSLs follow a weak approach using macros or text generators,
which lack many of the features that make a DSL a comfortable for programmers.
Some of these features---e.g., syntax highlighting, type inference, error
reporting, and code completion---are easily provided by language workbenches,
which combine language engineering techniques and tools in a common ecosystem.
In this paper, we present the Parallel Particle-Mesh Environment (PPME), a DSL
and development environment for numerical simulations based on particle methods
and hybrid particle-mesh methods. PPME uses the meta programming system (MPS),
a projectional language workbench. PPME is the successor of the Parallel
Particle-Mesh Language (PPML), a Fortran-based DSL that used conventional
implementation strategies. We analyze and compare both languages and
demonstrate how the programmer's experience can be improved using static
analyses and projectional editing. Furthermore, we present an explicit domain
model for particle abstractions and the first formal type system for particle
methods.Comment: Submitted to ACM Transactions on Mathematical Software on Dec. 25,
201
- …