872 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

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

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

''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

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


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

A Tool for Measuring the Size, Structure and Complexity of Software

Description: The problem addressed by this thesis is the need for a software measurement tool that enforces a uniform measurement algorithm on several programming languages. The introductory chapter discusses the concern for software measurement and provides background for the specific models and metrics that are studied. A multilingual software measurement tool is then introduced, that analyzes programs written in Ada, C, Pascal, or PL/I, and quantifies over thirty different program attributes. Metrics computed by the program include McCabe's measure of cyclomatic complexity and Halstead's software science metrics. Some results and conclusions of preliminary data analysis, using the tool, are also given. The appendices contain exhaustive counting algorithms for obtaining the metrics in each language.
Date: May 1984
Creator: Versaw, Larry
Partner: UNT Libraries

SMARTARRAY: A C++ class template for self-describing, resizable, error-resistant arrays

Description: The SmartArray class template supports one-dimensional (single index) arrays and provides four major features that make it superior to built-in C++ arrays: a SmartArray is self-describing (both capacity and content), a SmartArray can be dynamically resized, the index supplied to the operator of a SmartArray is bounds checked, and the lower bound of a SmartArray can be chosen by the programmer. Additionally, the SmartArray class provides a full set of traversal functions, an assignment operator, editing functions, and an error handling mechanism-yet remains small, self-contained, portable, efficient, and easy to master. The class template SmartArray <T> requires that T be either a built-in type or a class that provides an assignment operator, a default (no argument) constructor, a copy constructor, and a destructor. If T does not contain any pointers, the compiler-generated versions of these four functions will probably be adequate.
Date: April 1, 1996
Creator: Perano, K.J. & Nielan, P.E.
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

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

Rapid application development using the Tcl/Tk language

Description: During the last year, high level applications at CEBAF were written using the Tcl/Tk scripting language. This language is rapidly gaining in popularity, in part due to ease of constructing programs with X11 graphical user interfaces, and in part to ease of adding compiled user code for specialized purposes. Extensions to the language provide object oriented programming, which was used to develop a hierarchy of classes relevant for high level accelerator control. We describe basic language features, some 3rd party add-on packages, and local additions to the toolbox. Next we describe features of the accelerator object hierarchy, and finally describe applications written using this toolbox such as the ModelServer prototype, Slow Orbit and Energy Lock, the Linac Energy Management System, and other applications.
Date: December 31, 1995
Creator: van Zeijts, J.
Partner: UNT Libraries Government Documents Department

Program Transformation in HATS

Description: HATS is a general purpose syntax derivation tree based transformation system in which transformation sequences are described in special purpose language. A powerful feature of this language is that unification is an explicit operation. By making unification explicit, an elegant framework arises in which to express complex application conditions which in turn enables refined control strategies to be realized. This paper gives an overview of HATS, focusing especially on the framework provided by the transformation language and its potential with respect to control and general purpose transformation.
Date: February 24, 1999
Creator: Winter, V.L.
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

Toward Fortran 77 performance from object-oriented C++ scientific frameworks

Description: The use of object-oriented C{sup 2} frameworks has significantly simplified the development of numerous complex parallel scientific applications at Los Alamos National Laboratory and elsewhere. In spite of considerable use of, and commitment to, these frameworks, concerns about performance are nonetheless a significant issue; performance very close to that of FORTRAN 77 with message passing must be realized before the acceptance and use of such frameworks will be truly widespread. This paper identifies the primary source of inefficiency in using C or C{sup 2} for numerical codes with stencil- or stencil-like operations, and demonstrates two solutions--one portable, one not--to give genuine FORTRAN 77 performance.
Date: December 1, 1998
Creator: Bassetti, F.; Davis, K. & Quinlan, D.
Partner: UNT Libraries Government Documents Department

Object oriented programming interfaces for accelerator control

Description: Several years ago, the AGS controls group was given the task of developing software for the RHIC accelerator. Like the AGS, the RHIC control system needs to control and monitor equipment distributed around a relatively large geographic area. A local area network connects this equipment to a collection of UNIX workstations in a central control room. Similar software had been developed for the AGS about a decade earlier, but isn`t well suited for RHIC use for a number of reasons. Rather than adapt the AGS software for RHIC use, the controls group opted to start with a clean slate. To develop software that would address the shortcomings of the AGS software, while preserving the useful features that evolved through years of use. A current trend in control system design is to provide an object oriented programming interface for application developers. This talk will discuss important aspects and features of object oriented application programming interfaces (APIs) for accelerator control systems, and explore why such interfaces are becoming the norm.
Date: July 1, 1997
Creator: Hoff, L. T.
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