PCCONTUR VERSION 1.0 : a microcomputer general purpose contouring program, Part C - Source code PCCONTUR disk

1988 ◽  
Author(s):  
Richard H. Godson ◽  
Robert E. Bracken ◽  
Michael W. Webring
Keyword(s):  
Source Code ◽  
General Purpose ◽  
Part C

scholarly journals Development in Vulkan: a domain-specific approach

2021 ◽  
Vol 33 (5) ◽  
pp. 181-204
Author(s):  
Vladimir Frolov ◽  
Vadim Sanzharov ◽  
Vladimir Galaktionov ◽  
Alexander Shcherbakov
Keyword(s):  
Image Processing ◽  
Ray Tracing ◽  
Code Generation ◽  
Source Code ◽  
General Purpose ◽  
Software Systems ◽  
Specific Class ◽  
Domain Specific ◽  
Architectural Patterns ◽  
C Program

In this paper we propose a high-level approach to developing GPU applications based on the Vulkan API. The purpose of the work is to reduce the complexity of developing and debugging applications that implement complex algorithms on the GPU using Vulkan. The proposed approach uses the technology of code generation by translating a C++ program into an optimized implementation in Vulkan, which includes automatic shader generation, resource binding, and the use of synchronization mechanisms (Vulkan barriers). The proposed solution is not a general-purpose programming technology, but specializes in specific tasks. At the same time, it has extensibility, which allows to adapt the solution to new problems. For single input C++ program, we can generate several implementations for different cases (via translator options) or different hardware. For example, a call to virtual functions can be implemented either through a switch construct in a kernel, or through sorting threads and an indirect dispatching via different kernels, or through the so-called callable shaders in Vulkan. Instead of creating a universal programming technology for building various software systems, we offer an extensible technology that can be customized for a specific class of applications. Unlike, for example, Halide, we do not use a domain-specific language, and the necessary knowledge is extracted from ordinary C++ code. Therefore, we do not extend with any new language constructs or directives and the input source code is assumed to be normal C++ source code (albeit with some restrictions) that can be compiled by any C++ compiler. We use pattern matching to find specific patterns (or patterns) in C++ code and convert them to GPU efficient code using Vulkan. Pattern are expressed through classes, member functions, and the relationship between them. Thus, the proposed technology makes it possible to ensure a cross-platform solution by generating different implementations of the same algorithm for different GPUs. At the same time, due to this, it allows you to provide access to specific hardware functionality required in computer graphics applications. Patterns are divided into architectural and algorithmic. The architectural pattern defines the domain and behavior of the translator as a whole (for example, image processing, ray tracing, neural networks, computational fluid dynamics and etc.). Algorithmic pattern express knowledge of data flow and control and define a narrower class of algorithms that can be efficiently implemented in hardware. Algorithmic patterns can occur within architectural patterns. For example, parallel reduction, compaction (parallel append), sorting, prefix sum, histogram calculation, map-reduce, etc. The proposed generator works on the principle of code morphing. The essence of this approach is that, having a certain class in the program and transformation rules, one can automatically generate another class with the desired properties (for example, the implementation of the algorithm on the GPU). The generated class inherits from the input class and thus has access to all data and functions of the input class. Overriding virtual functions in generated class helps user to carefully connect generated code to the other Vulkan code written by hand. Shaders can be generated in two variants: OpenCL shaders for google “clspv” compiler and GLSL shaders for an arbitrary GLSL compiler. Clspv variant is better for code which intensively uses pointers and the GLSL generator is better if specific HW features are used (like hardware ray tracing acceleration). We have demonstrated our technology on several examples related to image processing and ray tracing on which we get 30-100 times acceleration over multithreaded CPU implementation.

scholarly journals Introducing the Patterson Cylindrical Projection

2015 ◽  
pp. 77-81 ◽  
Author(s):  
Tom Patterson ◽  
Bojan Šavrič ◽  
Bernhard Jenny
Keyword(s):  
Aspect Ratio ◽  
Source Code ◽  
General Purpose ◽  
Reference Source ◽  
Polynomial Equations ◽  
Map Projection ◽  
Cylindrical Projection ◽  
Made In

The Patterson cylindrical, a new projection designed for general-purpose mapmaking, is an alternative to other cylindrical projections. It is positioned between the Plate Carrée projection, which has a 1:2 aspect ratio, and the Miller 1 projection, which excessively exaggerates the size of polar areas. The Patterson cylindrical balances polar exaggeration against maintaining the familiar shape of continents and has a compact height-to-width aspect ratio. Creating the projection started with a graphical template made in Flex Projector that served as a guide for developing the polynomial equations, which are introduced in this article. The reference source code is available in the Java Map Projection Library. 

Development and Application of Planar Computational General-Purpose Constrained Multibody Simulations in MATLAB With Simple Graphical/Visualization Capability

2015 ◽  
Author(s):  
J. R. Dye ◽  
Y. Y. Tay ◽  
H. M. Lankarani
Keyword(s):  
Programming Languages ◽  
Equations Of Motion ◽  
Source Code ◽  
Data Entry ◽  
General Purpose ◽  
Integration Scheme ◽  
Double Pendulum ◽  
Time Step ◽  
Code Structure ◽  
Matlab Programming

This study demonstrates the implementation and advantages in utilizing the Matlab programming environment for general-purpose simulations of constrained planar dynamic and kinematic multibody mechanical systems. Many currently available tools have a focus and can have limited flexibility through difficulty in data entry, limited access to source code, analysis of data or use of programming languages not readily taught. A Matlab source code is created, which includes the use of Microsoft Excel and GUI’s created in GUIDE that allow a user to construct, simulate and analyze multibody systems in Matlab. This technique allows the user to utilize any of Matlab toolboxes for unique problems or integrate the base program into a Simulink environment. An overview of the general code structure and multibody kinematics and dynamics equations used are shown in this paper. For kinematic simulations, the system’s Cartesian coordinates are found by finding the roots of the constraints vector at each time step. For the dynamic systems, the solver uses a numerical integration scheme with augmented form of the constrained equations of motion to solve for the system’s accelerations. Examples are presented demonstrating the benefits of using the Matlab environment and the flexibility to easily expand the code to simulate unique problems. These examples include an Ackermann steering for automotive applications and a double pendulum at the influence of gravity. The last example shows how a custom function can be created to inject forces into the dynamic solver in order to simulate a structural beam at the influence of a heavy pendulum.

scholarly journals Multi-Agent Based Intelligent Tutoring System Source Code Generation Using MASITS Tool

2010 ◽  
Vol 41 (1) ◽  
pp. 27-36 ◽  
Author(s):  
Egons Lavendelis ◽  
Janis Grundspenkis
Keyword(s):  
Code Generation ◽  
Intelligent Tutoring ◽  
Intelligent Tutoring System ◽  
Source Code ◽  
Requirements Analysis ◽  
General Purpose ◽  
Tutoring System ◽  
Agent Based ◽  
Development Tools ◽  
Multi Agent

Multi-Agent Based Intelligent Tutoring System Source Code Generation Using MASITS ToolSeveral agent development tools have been proposed. At the same time, specific tools for agent based Intelligent Tutoring System (ITS) development do not exist. However, ITSs have some specific characteristics that must be taken into consideration during the development. General purpose Agent Oriented Software Engineering (AOSE) methodologies and therefore development tools do not sufficiently correspond to the characteristics of ITSs. Additionally, the general purpose AOSE methodologies and tools do not allow plugging in domain specific rules and diagrams. Thus, usage of knowledge gained in ITS research during the development process is limited. In the absence of general tools that allow plugging in knowledge from ITS research, a specific tool named MASITS has been developed. The tool supports a specific agent based ITS development methodology named MASITS which takes into consideration specific characteristics of ITSs and integrates knowledge from ITS research. The tool supports all phases of ITS development, starting from requirements analysis and ending with deployment. Requirements analysis and design phases are supported by appropriate diagram creation tools. Implementation is supported by source code generation from diagrams created during the design phase. JADE platform is used for agent implementation. Thus, Java classes for ontology, agents and behaviours are generated from the design diagrams. The paper includes a brief overview of diagrams used in the source code generation and detailed algorithms for source code generation from the diagrams.

scholarly journals Constructing Workflows from Script Applications

2012 ◽  
Vol 20 (4) ◽  
pp. 359-377 ◽  
Author(s):  
Mikołaj Baranowski ◽  
Adam Belloum ◽  
Marian Bubak ◽  
Maciej Malawski
Keyword(s):  
Programming Languages ◽  
Source Code ◽  
General Purpose ◽  
Control Flow ◽  
Scientific Workflows ◽  
Collaborative Programming ◽  
Execution Environment ◽  
Grid Infrastructures ◽  
Grid Application ◽  
High Level

For programming and executing complex applications on grid infrastructures, scientific workflows have been proposed as convenient high-level alternative to solutions based on general-purpose programming languages, APIs and scripts. GridSpace is a collaborative programming and execution environment, which is based on a scripting approach and it extends Ruby language with a high-level API for invoking operations on remote resources. In this paper we describe a tool which enables to convert the GridSpace application source code into a workflow representation which, in turn, may be used for scheduling, provenance, or visualization. We describe how we addressed the issues of analyzing Ruby source code, resolving variable and method dependencies, as well as building workflow representation. The solutions to these problems have been developed and they were evaluated by testing them on complex grid application workflows such as CyberShake, Epigenomics and Montage. Evaluation is enriched by representing typical workflow control flow patterns.

scholarly journals General Purpose Optimization Library (GPOL): A Flexible and Efficient Multi-Purpose Optimization Library in Python

2021 ◽  
Vol 11 (11) ◽  
pp. 4774
Author(s):  
Illya Bakurov ◽  
Marco Buzzelli ◽  
Mauro Castelli ◽  
Leonardo Vanneschi ◽  
Raimondo Schettini
Keyword(s):  
Source Code ◽  
Search Algorithms ◽  
General Purpose ◽  
Supervised Machine Learning ◽  
Formal Definition ◽  
Learning Problem ◽  
Iterative Search ◽  
Problem Types ◽  
Wide Range ◽  
Novel Approaches

Several interesting libraries for optimization have been proposed. Some focus on individual optimization algorithms, or limited sets of them, and others focus on limited sets of problems. Frequently, the implementation of one of them does not precisely follow the formal definition, and they are difficult to personalize and compare. This makes it difficult to perform comparative studies and propose novel approaches. In this paper, we propose to solve these issues with the General Purpose Optimization Library (GPOL): a flexible and efficient multipurpose optimization library that covers a wide range of stochastic iterative search algorithms, through which flexible and modular implementation can allow for solving many different problem types from the fields of continuous and combinatorial optimization and supervised machine learning problem solving. Moreover, the library supports full-batch and mini-batch learning and allows carrying out computations on a CPU or GPU. The package is distributed under an MIT license. Source code, installation instructions, demos and tutorials are publicly available in our code hosting platform (the reference is provided in the Introduction).

Sign in / Sign up

Export Citation Format

Share Document