295 Matching Results

Search Results

Advanced search parameters have been applied.

A Formal Notation for Hardware and Software Verification

Description: Some years ago a theory was published describing compilation of digital logic system build descriptions (list of behaviors for elementary components and connections between them) into recursively computable system behavior descriptions. The current work describes an analogous theory for computer programs.
Date: October 1986
Creator: Chapman, Richard O. & Gabriel, John R.
Partner: UNT Libraries Government Documents Department

Generating Machine Code for High-Level Programming Languages

Description: The purpose of this research was to investigate the generation of machine code from high-level programming language. The following steps were undertaken: 1) Choose a high-level programming language as the source language and a computer as the target computer. 2) Examine all stages during the compiling of a high-level programming language and all data sets involved in the compilation. 3) Discover the mechanism for generating machine code and the mechanism to generate more efficient machine code from the language. 3) Construct an algorithm for generating machine code for the target computer. The results suggest that compiler is best implemented in a high-level programming language, and that SCANNER and PARSER should be independent of target representations, if possible.
Date: December 1976
Creator: Chao, Chia-Huei
Partner: UNT Libraries

INTERFACING AUTOCAD WITH MAGNETIC DESIGN

Description: This report is a summary of work done towards developing an AutoCAD based system for design and analysis of magnets. The computer programs that have been developed are an attempt to integrate the new SUN computer based system with existing software on the old HP1000 System. We believe this is a good start for the further development of the whole system. The programming languages used are AutoLISP for the programs used by AutoCAD, and Fortran (Microsoft Fortran) for all others. The entire work has been done on IBM-AT, with the well known limits of the memory, speed of execution and operating system, therefore, some adjustment may be needed for the more powerful SUN system.
Date: February 1, 1988
Creator: Sorin, M. & Caspi, S.
Partner: UNT Libraries Government Documents Department

Babel Fortran 2003 Binding for Structured Data Types

Description: Babel is a tool aimed at the high-performance computing community that addresses the need for mixing programming languages (Java, Python, C, C++, Fortran 90, FORTRAN 77) in order to leverage the specific benefits of those languages. Scientific codes often rely on structured data types (structs, derived data types) to encapsulate data, and Babel has been lacking in this type of support until recently. We present a new language binding that focuses on their interoperability of C/C++ with Fortran 2003. The new binding builds on the existing Fortran 90 infrastructure by using the iso-c-binding module defined in the Fortran 2003 standard as the basis for C/C++ interoperability. We present the technical approach for the new binding and discuss our initial experiences in applying the binding in FACETS (Framework Application for Core-Edge Transport Simulations) to integrate C++ with legacy Fortran codes.
Date: May 2, 2008
Creator: Muszala, S; Epperly, T & Wang, N
Partner: UNT Libraries Government Documents Department

DATAPLOT: Introduction and Overview

Description: Abstract: This manual provides DATAPLOT code solution to a variety of commonly occurring graphical problems. A line-by-line explanation of code is given, along with illustrations and general discussion.
Date: June 1984
Creator: Filliben, James J.
Partner: UNT Libraries Government Documents Department

Fortran M Language Definition

Description: This document defines the Fortran M extensions to Fortran 77. It updates an earlier definition, dated June 1992, in several minor respects.
Date: August 1993
Creator: Foster, Ian & Chandy, K. Mani
Partner: UNT Libraries Government Documents Department

''Ideal'' directly executed languages: an analytical argument for emulation

Description: Several methods of evaluating user programs are analyzed with respect to space and time requirements. The concept of an ideal'' directly executed language is introduced, and it is argued that the ideal'' directly executed language for a contemporary computing system will not be either its source language or the language accepted by its base machine. (auth)
Date: December 1, 1973
Creator: Hoevel, L.W.
Partner: UNT Libraries Government Documents Department

Flowchart-to-source-code conversion program for GPSS/360

Description: Thesis. An interactive program is descnibed which allows a user to specify a GPSS program as a block diagram. The user draws the block diagram using the Graphical Remote Access Support System (GRASS) and sends it to the remote computer where it is converted to an equivalent source program. He can then run the program, if desired, and have the output from GPSS routed back to the graphics terminal, selecting the portion for which hard copy is desired. The program is written in 360 Assembler Language. (auth)
Date: December 1, 1973
Creator: Purvy, R.E.
Partner: UNT Libraries Government Documents Department

C++ expression templates performance issues in scientific computing

Description: Ever-increasing size and complexity of software applications and libraries in parallel scientific computing is making implementation in the programming languages traditional for this field--FORTRAN 77 and C--impractical. The major impediment to the progression to a higher-level language such as C++ is attaining FORTRAN 77 or C performance, which is considered absolutely necessary by many practitioners. The use of template metaprogramming in C++, in the form of so-called expression templates to generate custom C++ code, holds great promise for getting C performance from C++ in the context of operations on array-like objects. Several sophisticated expression template implementations of parallel array-class libraries exist, and in certain circumstances their promise of performance is realized. Unfortunately this is not uniformly the case; this paper explores the major reasons that this is so.
Date: October 1, 1997
Creator: Bassetti, F.; Davis, K. & Quinlan, D.
Partner: UNT Libraries Government Documents Department

Conventions for quantum pseudocode

Description: A few conventions for thinking about and writing quantum pseudocode are proposed. The conventions can be used for presenting any quantum algorithm down to the lowest level and are consistent with a quantum random access machine (QRAM) model for quantum computing. In principle a formal version of quantum pseudocode could be used in a future extension of a conventional language.
Date: June 1, 1996
Creator: Knill, E.
Partner: UNT Libraries Government Documents Department

AMRITA -- A computational facility

Description: Amrita is a software system for automating numerical investigations. The system is driven using its own powerful scripting language, Amrita, which facilitates both the composition and archiving of complete numerical investigations, as distinct from isolated computations. Once archived, an Amrita investigation can later be reproduced by any interested party, and not just the original investigator, for no cost other than the raw CPU time needed to parse the archived script. In fact, this entire lecture can be reconstructed in such a fashion. To do this, the script: constructs a number of shock-capturing schemes; runs a series of test problems, generates the plots shown; outputs the LATEX to typeset the notes; performs a myriad of behind-the-scenes tasks to glue everything together. Thus Amrita has all the characteristics of an operating system and should not be mistaken for a common-or-garden code.
Date: February 23, 1998
Creator: Shepherd, J.E. & Quirk, J.J.
Partner: UNT Libraries Government Documents Department

A JAVA User Interface for the Virtual Human

Description: A human simulation environment, the Virtual Human (VH), is under development at the Oak Ridge National Laboratory (ORNL). Virtual Human connects three-dimensional (3D) anatomical models of the body with dynamic physiological models to investigate a wide range of human biological and physical responses to stimuli. We have utilized the Java programming language to develop a flexible user interface to the VH. The Java prototype interface has been designed to display dynamic results from selected physiological models, with user control of the initial model parameters and ability to steer the simulation as it is proceeding. Taking advantage of Java�s Remote Method Invocation (RMI) features, the interface runs as a Java client that connects to a Java RMI server process running on a remote server machine. The RMI server can couple to physiological models written in Java, or in other programming languages, including C and FORTRAN. Future versions of the interface will be linked to 3D anatomical models of the human body to complete the development of the VH.
Date: October 13, 1999
Creator: Easterly, C.E.; Strickler, D.J.; Tolliver, J.S. & Ward, R.C.
Partner: UNT Libraries Government Documents Department

Implementation and performance of the pseudoknot problem in sisal

Description: The Pseudoknot Problem is an application from molecular biology that computes all possible three-dimensional structures of one section of a nucleic acid molecule. The problem spans two important application domains: it includes a deterministic, backtracking search algorithm and floating-point intensive computations. Recently, the application has been used to compare and to contrast functional languages. In this paper, we describe a sequential and parallel implementation of the problem in Sisal. We present a method for writing recursive, floating-point intensive applications in Sisal that preserves performance and parallelism. We discuss compiler optimizations, runtime execution, and performance on several multiprocessor systems.
Date: December 1, 1994
Creator: Feo, J. & Ivory, M.
Partner: UNT Libraries Government Documents Department

Building a programmable interface for physics codes using numeric python

Description: With its portability, ease to add built-in functions and objects in C, and fast array facility among many other features, Python proved to be an excellent language for creating programmable scientific applications. In addition to the two modules presented, there are also other progresses at LLNL in using Python. For example, Python interfaces are being developed for at least three graphics packages, and Python interpreter and applications have been built on distributed platforms such as meiko and Cray T3D.
Date: April 16, 1996
Creator: Yang, T.-Y.B.; Dubois, P.F. & Motteler, Z.C.
Partner: UNT Libraries Government Documents Department

An object-oriented extension for debugging the virtual machine

Description: A computer is nothing more then a virtual machine programmed by source code to perform a task. The program`s source code expresses abstract constructs which are compiled into some lower level target language. When a virtual machine breaks, it can be very difficult to debug because typical debuggers provide only low-level target implementation information to the software engineer. We believe that the debugging task can be simplified by introducing aspects of the abstract design and data into the source code. We introduce OODIE, an object-oriented extension to programming languages that allows programmers to specify a virtual environment by describing the meaning of the design and data of a virtual machine. This specification is translated into symbolic information such that an augmented debugger can present engineers with a programmable debugging environment specifically tailored for the virtual machine that is to be debugged.
Date: December 1, 1994
Creator: Pizzi, R.G. Jr.
Partner: UNT Libraries Government Documents Department

Adapting perspectives to facilitate knowledge assimilation

Description: The notion of perspective when supported in knowledge representation can allow the representation of multiple and varying points of view, some of which may even be inconsistent with one another. In an object-based knowledge representation methodology created and used by the authors, a perspective is defined by consolidating a number of objects and a number of those objects` associated attributes and methods into a view. This view can help partition a knowledge domain into separate portions. A separate portion represents an individual`s view of the knowledge domain. Representation of multiple and varying perspectives may add to the existing knowledge as well as reveal paths to additional knowledge. A simple example is presented where perspectives are used to represent game playing strategies and levels of expertise in those strategies. Players` perspectives are adapted and changed to provide additional knowledge and insight into further game playing strategies. Results show improvement in the playing of the games. Additionally, a more complex problem for applying these techniques is introduced.
Date: December 31, 1998
Creator: Kelsey, R.L. & Webster, R.B.
Partner: UNT Libraries Government Documents Department

Experiences in effective use of Tcl/Tk

Description: Tcl/Tk (Toot Command Language and Tool Kit, pronounced ``tickle tee-kay``) is a scripting language supporting Motifm style X Window interfaces. It is extendible, allowing developers to embed additional functionality as commands in the language. However, the power and flexibility of the system leads to many variations or possibilities in its usage. We describe effective methods for taking advantage of Tcl/Tk to increase productivity and enhance the flexibility and adaptability of applications: writing simple Tcl/Tk scripts, extending the Tcl/Tk widget set, wrapping Tcl commands around existing classes and functions, and building Tcl/Tk and 3GL coprocesses. Examples are presented from working applications.
Date: June 1, 1995
Creator: Lee, R.W.
Partner: UNT Libraries Government Documents Department

Users manual for bfort: Producing Fortran interfaces to C source code

Description: In many applications, the most natural computer language to write in may be different from the most natural language to provide a library in. For example, many scientific computing applications are written in Fortran, while many software libraries-particularly those dealing with complicated data structures or dynamic memory management-are written in C. Providing an interface so that Fortran programs can call routines written in C can be a tedious and error-prone process. We describe here a tool that automatically generates a Fortran-callable wrapper for routines written in C, using only a small, structured comment and the declaration of the routine in C. This tool has been used on two large software packages, PETSc and the MPICH implementation of MPI.
Date: March 1, 1995
Creator: Gropp, W.
Partner: UNT Libraries Government Documents Department