High-level Programming Environment Research Articles

ОБУЧАЮЩЕЕ ПРИЛОЖЕНИЕ ПО СВОБОДНОЙ СРЕДЕ РАЗРАБОТКИ RSTUDIO

The article stipulates the relevance of developing a training application for a free software development environment RStudio focused on the study of statistical methods for processing experimental data. A brief description of the high-level object-oriented programming language and environment for statistical calcula-tions and visualization of the initial and calculated data R is given; substantiates its effectiveness in the educa-tional process. The functionality of the developed software product is described.

Formal constraint-based compilation for noisy intermediate-scale quantum systems

Noisy, intermediate-scale quantum (NISQ) systems are expected to have a few hundred qubits, minimal or no error correction, limited connectivity and limits on the number of gates that can be performed within the short coherence window of the machine. The past decade’s research on quantum programming languages and compilers is directed towards large systems with thousands of qubits. For near term quantum systems, it is crucial to design tool flows which make efficient use of the hardware resources without sacrificing the ease and portability of a high-level programming environment. In this paper, we present a compiler for the Scaffold quantum programming language in which aggressive optimization specifically targets NISQ machines with hundreds of qubits. Our compiler extracts gates from a Scaffold program, and formulates a constrained optimization problem which considers both program characteristics and machine constraints. Using the Z3 SMT solver, the compiler maps program qubits to hardware qubits, schedules gates, and inserts CNOT routing operations while optimizing the overall execution time. The output of the optimization is used to produce target code in the OpenQASM language, which can be executed on existing quantum hardware such as the 16-qubit IBM machine. Using real and synthetic benchmarks, we show that it is feasible to synthesize near-optimal compiled code for current and small NISQ systems. For large programs and machine sizes, the SMT optimization approach can be used to synthesize compiled code that is guaranteed to finish within the coherence window of the machine.

Curriculum change for graduate-level control engineering education at the Universidad Pontificia Bolivariana

Abstract This paper addresses the graduate-level control engineering curriculum change performed at the Universidad Pontificia Bolivariana (UPB), Medellin, Colombia. New proposed methodologies include active learning activities using a new multipurpose experimental test bed that was developed with industrial components. The renovated graduate-level control engineering related courses include: Continuous Processes, Discrete Processes, Fuzzy Logic, Neural Networks and Genetic Algorithms, Linear Control, Nonlinear Control, and Optimal Estimation. The new experimental station was developed for teaching, research, and industrial training activities for the School of Engineering at the UPB. In this work, we report the use of the station in an Optimal Estimation course to replace a traditional homework/exams evaluation approach with an applied work that required independent study, the implementation of different observers in a real lab-scale industrial plant, and a paper-style written report. Increasing independent study activities resulted in academic discussions that are valuable for the learning process of the student. The use of the experimental station and the real comparison of estimation algorithms, implemented by using industrial controllers and high-level programming environments, provided the student skills that cannot be acquired by using only simulations in which real implementation restrictions/challenges do not appear. This work represents one of the first approaches for the implementation of the new curriculum model at the UPB for graduate education. The methodology used in the Optimal Estimation class promoted independent learning, critical thinking and writing skills through significant learning activities.

Development and Implementation of a High-Level Control System for the Underwater Remotely Operated Vehicle VISOR3

This paper addresses the design and implementation of a high-level control system for the planning, supervision, and mission operation of the observation class remotely operated vehicle VISOR3. This work was developed following the Waterfall Model for the Software Development Life Cycle. First, a brief description of the ROV VISOR3 is made. Then, the functional and non-functional requirements, that are based on the ISO/IEC/IEEE 29148:2011 and were gathered from stakeholders, are presented. The software architecture is based on the standard ISO/IEC/IEEE 42010:2011. The implementation of the high-level control system is done by using a high-level programming environment using layers through parallel executed threads. This architecture establishes a flexible structure and guidelines that orient the implementation of future components for the mission control system of the ROV.

IB2d: a Python and MATLAB implementation of the immersed boundary method

The development of fluid-structure interaction (FSI) software involves trade-offs between ease of use, generality, performance, and cost. Typically there are large learning curves when using low-level software to model the interaction of an elastic structure immersed in a uniform density fluid. Many existing codes are not publicly available, and the commercial software that exists usually requires expensive licenses and may not be as robust or allow the necessary flexibility that in house codes can provide. We present an open source immersed boundary software package, IB2d, with full implementations in both MATLAB and Python, that is capable of running a vast range of biomechanics models and is accessible to scientists who have experience in high-level programming environments. IB2d contains multiple options for constructing material properties of the fiber structure, as well as the advection-diffusion of a chemical gradient, muscle mechanics models, and artificial forcing to drive boundaries with a preferred motion.

Reliability Aware Task Scheduling In Wireless Hetrogeneous Systems

A distributed operating system is one that looks to its user like an ordinary centralized operating system, but runs on multiple, independent nodes. A distributed operating system should:  control resource allocation to allow their use in the most effective way;  provide the user with a convenient virtual computer that serves as a high-level programming environment;  hide the distribution of the resources;  provide mechanisms for protecting system resources against access by unauthorized users. The main purpose of this research is to explore and use the idle resources and to share the wireless distributed system fairly among the processes. Reliability is taken into account to achieve the goal of scheduling. The comparison study, based on both randomly generated graphs and the graphs of some real applications, shows that proposed scheduling algorithm can achieve reliable task scheduling and improves system reliability significantly. For experimental performance study, a real world application as well as synthetic workloads have been considered. It can be stated that shortening scheduling times improves performance of the system. Hence if scheduling algorithms are applied in parallel to reduce scheduling times, the performance of the heterogeneous clusters will be further enhanced. General Terms Distributed Computing, reliable task scheduling.

Анализ динамических режимов работы трехфазных трехстержневых трансформаторов в пакете MATLAB

Background: Dynamic modes of various nonlinear electromagnetic devices regarding instantaneous currents and voltages are now calculated by numerical methods. That is why the software package MATLAB, a high-level programming environment, has become widely spread. However, its built-in features are not always sufficient to describe circuits containing non-linear electromagnetic devices, in particular three-core transformers. It becomes clear while studying asymmetrical transients which are caused by changing parameters of the transformer itself, such as breakage or short circuit of windings, or by using a connecting load. Asymmetric transients of transformers are normally analysed by the method of superposition of forced and free modes. And the forced mode is calculated by the method of symmetrical components, while the available free components are determined by introducing different coefficients identified by comparing the accumulated experimental and calculated data. This approach is based on rather rough assumptions. The goal of the present research is to develop methods, algorithms and programs which allow us to use Simulink for calculating nonlinear electromagnetic devices. Materials and methods: The study of dynamical modes in the transformer was performed by the alternating direction method in MATLAB environment that has a program for calculation of nonlinear magnetic circuit of the three-core transformer.  «Вестник ИГЭУ» Вып. 4 2016 г.  ФГБОУВО «Ивановский государственный энергетический университет имени В.И. Ленина» 12 Results: A model and algorithms have been developed extending the capabilities of Simulink for the calculation of circuits with non-linear electromagnetic devices. The asymmetrical modes for the three-core transformer with a Y/Yn winding connection scheme have been calculated. Conclusions: The proposed model is universal and allows analysing transient, steady-state and emergency modes under asymmetric loads in transformers with different connection diagrams. The evaluation was made by verifying the results of numerical experiments against the passport data of the transformer.

Towards a performance portable, architecture agnostic implementation strategy for weather and climate models

We propose a software implementation strategy for complex weather and climate models that produces performance portable, architecture agnostic codes. It relies on domain and data structure specific tools that are usable within common model development frameworks - Fortran today and possibly high-level programming environments like Python in the future. We present the strategy in terms of a refactoring project of the atmospheric model COSMO, where we have rewritten the dynamical core and refactored the remaining Fortran code. The dynamical core is built on top of the domain specific Stencil Loop Language for stencil computations on structured grids, a generic framework for halo exchange and boundary conditions, as well as a generic communication library that handles data exchange on a distributed memory system. All these tools are implemented in C++ making extensive use of generic programming and template metaprogramming. The refactored code is shown to outperform the current production code and is performance portable to various hybrid CPU-GPU node architectures.

Forge

Domain-specific languages provide a promising path to automatically compile high-level code to parallel, heterogeneous, and distributed hardware. However, in practice high performance DSLs still require considerable software expertise to develop and force users into tool-chains that hinder prototyping and debugging. To address these problems, we present Forge, a new meta DSL for declaratively specifying high performance embedded DSLs. Forge provides DSL authors with high-level abstractions (e.g., data structures, parallel patterns, effects) for specifying their DSL in a way that permits high performance. From this high-level specification, Forge automatically generates both a naïve Scala library implementation of the DSL and a high performance version using the Delite DSL framework. Users of a Forge-generated DSL can prototype their application using the library version, and then switch to the Delite version to run on multicore CPUs, GPUs, and clusters without changing the application code. Forge-generated Delite DSLs perform within 2x of hand-optimized C++ and up to 40x better than Spark, an alternative high-level distributed programming environment. Compared to a manually implemented Delite DSL, Forge provides a factor of 3-6x reduction in lines of code and does not sacrifice any performance. Furthermore, Forge specifications can be generated from existing Scala libraries, are easy to maintain, shield DSL developers from changes in the Delite framework, and enable DSLs to be retargeted to other frameworks transparently.

Accelerating numerical modeling of wave propagation through 2-D anisotropic materials using OpenCL

We present an implementation of the numerical modeling of elastic waves propagation, in 2D anisotropic materials, using the new parallel computing devices (PCDs). Our study is aimed both to model laboratory experiments and explore the capabilities of the emerging PCDs by discussing performance issues. In the experiments a sample plate of an anisotropic material placed inside a water tank is rotated and, for every angle of rotation it is subjected to an ultrasonic wave (produced by a large source transducer) that propagates in the water and through the material producing some reflection and transmission signals that are recording by a “point-like” receiver. This experiment is numerically modeled by running a finite difference code covering a set of angles θ∈[−50°, 50°], and recorded the signals for the transmission and reflection results. Transversely anisotropic and weakly orthorhombic materials are considered. We accelerated the computation using an open-source toolkit called PyOpenCL, which lets one to easily access the OpenCL parallel computation API’s from the high-level programming environment of Python. A speedup factor over 19 using the GPU is obtained when compared with the execution of the same program in parallel using a CPU multi-core (in this case we use the 4-cores that has the CPU). The performance for different graphic cards and operating systems is included together with the full 2-D finite difference code with PyOpenCL.

Matrix Numerov method for solving Schrödinger’s equation

We recast the well-known Numerov method for solving Schrödinger’s equation into a representation of the kinetic energy operator on a discrete lattice. With just a few lines of code in a high-level programming environment such as mathematica, it is simple to calculate and plot accurate eigenvalues and eigenvectors for a variety of potential problems. We illustrate the method by calculating high-accuracy solutions for the |x| potential.

Minimizing the ripple effect of web-centric software by using the pheromone extension

The ripple effect metric shows what impact changes to a software will likely have on the rest of the system. In web-based data analysis, it has become a widespread practice to deploy both the script and the program developed with a high-level programming language software tool. Due to different vendors and the diversified philosophies behind different software tools, it may be slightly difficult to cope with the ripple effect across them. This paper initiates an experimental idea to minimize the wrapper interface ripple for web-based script tools and high-level programming environments and also indicates many potential research directions for the development of computationally intelligent tools in the software engineering domain that demand lower cost and less complexity. This work incorporates Ant Colony Optimization (ACO) and its prime artifact pheromone, which has been modified as a pheromone extension module to minimize ripples when cross-coding. A standard benchmark data set has been taken to validate the performance of the proposed algorithm.

Craniux: A LabVIEW-Based Modular Software Framework for Brain-Machine Interface Research

This paper presents “Craniux,” an open-access, open-source software framework for brain-machine interface (BMI) research. Developed in LabVIEW, a high-level graphical programming environment, Craniux offers both out-of-the-box functionality and a modular BMI software framework that is easily extendable. Specifically, it allows researchers to take advantage of multiple features inherent to the LabVIEW environment for on-the-fly data visualization, parallel processing, multithreading, and data saving. This paper introduces the basic features and system architecture of Craniux and describes the validation of the system under real-time BMI operation using simulated and real electrocorticographic (ECoG) signals. Our results indicate that Craniux is able to operate consistently in real time, enabling a seamless work flow to achieve brain control of cursor movement. The Craniux software framework is made available to the scientific research community to provide a LabVIEW-based BMI software platform for future BMI research and development.

Toward high-performance polynomial system solvers based on triangular decompositions

This thesis is devoted to the design and implementation of polynomial system solvers based on symbolic computation. Solving systems of non-linear, algebraic or differential equations, is a fundamental problem in mathematical sciences. It has been studied for centuries and still stimulates many research developments, in particular on the front of high-performance computing. Triangular decompositions are a highly promising technique with the potential to produce high-performance polynomial system solvers. This thesis makes several contributions to this effort. We propose asymptotically fast algorithms for the core operations on which triangular decompositions rely. Complexity results and comparative implementation show that these new algorithms provide substantial performance improvements. We present a fundamental software library for polynomial arithmetic in order to support the implementation of high-performance solvers based on triangular decompositions. We investigate strategies for the integration of this library in high-level programming environments where triangular decompositions are usually implemented. We obtain a high performance library combining highly optimized C routines and solving procedures written in the Maple computer algebra system. The experimental result shows that our approaches are very effective, since our code often outperforms pre-existing solvers in a significant manner.

Introductory computational science using MATLAB and image processing

Abstract We describe a new course designed to introduce engineering students to computational thinking. One of the most significant challenges in teaching an introductory-level applied computing course is that students are not expected to have substantial math and science experience. To address this, we have developed exercises which use edge detection and basic image processing to motivate the use of programming MATLAB in a non-trivial scientific application. MATLAB is a popular high-level programming language and environment which supports a wide range of computational science applications. MATLAB has strong support for operating on image data, which allows us to balance solving practical engineering problems with basic core concepts of computer science such as functional abstraction, conditional execution, and iteration.

GPULib: GPU Computing in High-Level Languages

GPULib helps scientists and engineers take advantage of GPUs from within high-level programming environments without requiring any detailed knowledge of the GPU architecture.

Achieving behavioral control with millisecond resolution in a high-level programming environment

The creation of psychophysical tasks for the behavioral neurosciences has generally relied upon low-level software running on a limited range of hardware. Despite the availability of software that allows the coding of behavioral tasks in high-level programming environments, many researchers are still reluctant to trust the temporal accuracy and resolution of programs running in such environments, especially when they run atop non-real-time operating systems. Thus, the creation of behavioral paradigms has been slowed by the intricacy of the coding required and their dissemination across labs has been hampered by the various types of hardware needed. However, we demonstrate here that, when proper measures are taken to handle the various sources of temporal error, accuracy can be achieved at the 1 ms time-scale that is relevant for the alignment of behavioral and neural events.

AUTOMATIC MAPPING OF ASSIST APPLICATIONS USING PROCESS ALGEBRA

Grid technologies aim to harness the computational capabilities of widely distributed collections of computers. Due to the heterogeneous and dynamic nature of the set of grid resources, the programming and optimisation burden of a low level approach to grid computing is clearly unacceptable for large scale, complex applications. The development of grid applications can be simplified by using high-level programming environments. In the present work, we address the problem of the mapping of a high-level grid application onto the computational resources. In order to optimise the mapping of the application, we propose to automatically generate performance models from the application using the process algebra PEPA. We target applications written with the high-level environment ASSIST, since the use of such a structured environment allows us to automate the study of the application more effectively.

MERMAID – MULTIPLE-ROBOT MIDDLEWARE FOR INTELLIGENT DECISION-MAKING

This paper describes the basic concepts and features of MeRMaID (Multiple-Robot Middleware for Intelligent Decision-making), a robot programming framework whose goal is to provide a simplified and systematic high-level behavior programming environment for multi-robot teams. MeRMaID constrains, on purpose, some of the programmer's options, and can accept plans described by state machines, Petri nets and other types of decision-making algorithms, including fuzzy-logic decision-making and rule-based systems. Its current version enables concurrent multi-platform programming, modularity (for flexible module replacement and easy module edition/modification), and independence from robot hardware (since it includes an Hardware Abstraction Layer).

Realization of the chess mate solver application

This paper presents details of the chess mate solver application, which is a part of the author?s Geniss general chess application. The problem chess is an important domain connected with solving of the chess problems. The Geniss Mate Solver (G.M.S.) application solves Mate-in-N-move problems. Main techniques used for the implementation of the application are full-width searching with Alpha-Beta pruning technique and zero evaluation function. The application is written in Delphi for Windows programming environment and the searching engine is completely coded in assembly language (about 10000 lines). This hybrid software structure enables efficient program development by using high-level programming environment and the realization of a very fast searching engine at the same time. The machine code is manually coded and could achieve above 7 million generated positions per second on the 1Ghz Celeron PC.