Engineering Papers⌕ Search

SEARCH · Engineering Papers

Results for “abstract data types”

Search indexed NASA NTRS and DOE OSTI research on propulsion, heat transfer, battery materials and energy systems. Follow report and document links to the original sources.

Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.

At least 37 records · Page 2
All sourcesNASA NTRSDOE OSTI
NASA NTRS1989

Advanced Software Development Workstation Project

The Advanced Software Development Workstation Project, funded by Johnson Space Center, is investigating knowledge-based techniques for software reuse in NASA software development projects. Two prototypes have been demonstrated and a third is now in development. The approach is to build a foundation that provides passive reuse support, add a layer that uses domain-independent programming knowledge, add a layer that supports the acquisition of domain-specific programming knowledge to provide active support, and enhance maintainability and modifiability through an object-oriented approach. The development of new application software would use specification-by-reformulation, based on a cognitive theory of retrieval from very long-term memory in humans, and using an Ada code library and an object base. Current tasks include enhancements to the knowledge representation of Ada packages and abstract data types, extensions to support Ada package instantiation knowledge acquisition, integration with Ada compilers and relational databases, enhancements to the graphical user interface, and demonstration of the system with a NASA contractor-developed trajectory simulation package. Future work will focus on investigating issues involving scale-up and integration.

Lee, Daniel↗
NASA NTRS1989

Lessons learned in the transition to ADA from FORTRAN at NASA/Goddard

A case study was done at Goddard Space Flight Center, in which two dynamics satellite simulators are developed from the same requirements, one in Ada and the other in FORTRAN. The purpose of the research was to find out how well the prescriptive Ada development model worked to develop the Ada simulator. The FORTRAN simulator development, as well as past FORTRAN developments, provided a baseline for comparison. Since this was the first simulator developed here, the prescriptive Ada development model had many similarities to the usual FORTRAN development model. However, it was modified to include longer design and shorter testing phases, which is generally expected with Ada development. One surprising result was that the percentage of time the Ada project spent in the various development activities was very similar to the percentage of time spent in these activities when doing a FORTRAN project. Another surprising finding was the difficulty the Ada team had with unit testing as well as with integration. In retrospect it is realized that adding additional steps to the design phase, such as an abstract data type analysis, and certain guidelines to the implementation phase, such as to use primarily library units and nest sparingly, would have made development much easier.

Brophy, Carolyn Elizabeth↗
NASA NTRS1989

Lessons learned in the transition to Ada from FORTRAN at NASA/Goddard

Two dynamics satellite simulators are developed from the same requirements, one in Ada and the other in FORTRAN. The purpose of the research was to find out how well the prescriptive Ada development model worked to develop the Ada simulator. The FORTRAN simulator development, as well as past FORTRAN developments, provided a baseline for comparison. Since this was the first simulator developed, the prescriptive Ada development model had many similarities to the usual FORTRAN development model. However, it was modified to include longer design and shorter testing phases, which is generally expected with Ada developments. One result was that the percentage of time the Ada project spent in the various development activities was very similar to the percentage of time spent in these activities when doing a FORTRAN project. Another finding was the difficulty the Ada team had with unit testing as well as with integration. It was realized that adding additional steps to the design phase, such as an abstract data type analysis, and certain guidelines to the implementation phase, such as to use primarily library units and nest sparingly, would have made development easier. These are among the recommendations made to be incorporated in a new Ada development model next time.

Brophy, Carolyn Elizabeth↗
NASA NTRS1991

Programming in a proposed 9X distributed Ada

The studies of the proposed Ada 9X constructs for distribution, now referred to as AdaPT are reported. The goals for this time period were to revise the chosen example scenario and to begin studying about how the proposed constructs might be implemented. The example scenario chosen is the Submarine Combat Information Center (CIC) developed by IBM for the Navy. The specification provided by IBM was preliminary and had several deficiencies. To address these problems, some changes to the scenario specification were made. Some of the more important changes include: (1) addition of a system database management function; (2) addition of a fourth processing unit to the standard resources; (3) addition of an operator console interface function; and (4) removal of the time synchronization function. To implement the CIC scenario in AdaPT, the decided strategy were publics, partitions, and nodes. The principle purpose for implementing the CIC scenario was to demonstrate how the AdaPT constructs interact with the program structure. While considering ways that the AdaPt constructs might be translated to Ada 83, it was observed that the partition construct could reasonably be modeled as an abstract data type. Although this gives a useful method of modeling partitions, it does not at all address the configuration aspects on the node construct.

Waldrop, Raymond S.↗
NASA NTRS1993

Experimental evaluation of the certification-trail method

Certification trails are a recently introduced and promising approach to fault-detection and fault-tolerance. A comprehensive attempt to assess experimentally the performance and overall value of the method is reported. The method is applied to algorithms for the following problems: huffman tree, shortest path, minimum spanning tree, sorting, and convex hull. Our results reveal many cases in which an approach using certification-trails allows for significantly faster overall program execution time than a basic time redundancy-approach. Algorithms for the answer-validation problem for abstract data types were also examined. This kind of problem provides a basis for applying the certification-trail method to wide classes of algorithms. Answer-validation solutions for two types of priority queues were implemented and analyzed. In both cases, the algorithm which performs answer-validation is substantially faster than the original algorithm for computing the answer. Next, a probabilistic model and analysis which enables comparison between the certification-trail method and the time-redundancy approach were presented. The analysis reveals some substantial and sometimes surprising advantages for ther certification-trail method. Finally, the work our group performed on the design and implementation of fault injection testbeds for experimental analysis of the certification trail technique is discussed. This work employs two distinct methodologies, software fault injection (modification of instruction, data, and stack segments of programs on a Sun Sparcstation ELC and on an IBM 386 PC) and hardware fault injection (control, address, and data lines of a Motorola MC68000-based target system pulsed at logical zero/one values). Our results indicate the viability of the certification trail technique. It is also believed that the tools developed provide a solid base for additional exploration.

Sullivan, Gregory F.↗
NASA NTRS1997

How to Express C++ Concepts in Fortran90

r summarizes techniques for emulating in Fortran90 the most important object-oriented concepts of C++ classes (including abstract data types, encapsulation and function overloading), inheritance and dynamic dispatching.

Fortran90↗
NASA NTRS2005

Type-definition objects

This paper presents a number of type definition objects implemented as part of the Joint Asymmetric Warfare Simulation (JAWS).

OOP↗
NASA NTRS1995

(abstract) Application of Non-coherent Data Types for Deep Space Navigation

Several options are being examined to reduce the costs of spacecraft and deep space missions. One such option is to fly spacecraft in a non-coherent mode, that is, the spacecraft does not carry a transponder and cannot coherently return a Doppler signal. Historically, such one-way data has not been used as the sole data type due to the instability of the onboard oscillator, the use of S-band frequencies, and the corresponding larger error sources which could not be modeled. However, with the advent of high-speed work stations and more sophisticated modeling ability, the possibility of using one-way data is being re-examined. This paper addresses the navigation performance of various one-way data types for use in interplanetary missions.

deep space navigation non-coherent data spacecraft↗
NASA NTRS1993

A path-oriented matrix-based knowledge representation system

Experience has shown that designing a good representation is often the key to turning hard problems into simple ones. Most AI (Artificial Intelligence) search/representation techniques are oriented toward an infinite domain of objects and arbitrary relations among them. In reality much of what needs to be represented in AI can be expressed using a finite domain and unary or binary predicates. Well-known vector- and matrix-based representations can efficiently represent finite domains and unary/binary predicates, and allow effective extraction of path information by generalized transitive closure/path matrix computations. In order to avoid space limitations a set of abstract sparse matrix data types was developed along with a set of operations on them. This representation forms the basis of an intelligent information system for representing and manipulating relational data.

Feyock, Stefan↗
NASA NTRS1986

Some design constraints required for the assembly of software components: The incorporation of atomic abstract types into generically structured abstract types

It is nearly axiomatic, that to take the greatest advantage of the useful features available in a development system, and to avoid the negative interactions of those features, requires the exercise of a design methodology which constrains their use. A major design support feature of the Ada language is abstraction: for data, functions processes, resources, and system elements in general. Atomic abstract types can be created in packages defining those private types and all of the overloaded operators, functions, and hidden data required for their use in an application. Generically structured abstract types can be created in generic packages defining those structured private types, as buildups from the user-defined data types which are input as parameters. A study is made of the design constraints required for software incorporating either atomic or generically structured abstract types, if the integration of software components based on them is to be subsequently performed. The impact of these techniques on the reusability of software and the creation of project-specific software support environments is also discussed.

Johnson, Charles S.↗
NASA NTRSDate not supplied

Statistical Classification of Biosignature Information: Combining Elemental, Molecular, Reflectance, and Raman Data to Increase Life Detection Confidence

Planetary exploration missions seeking past or present signs of life carry not just a single instrument, but a suite. There is a need to study how these multiple data types can be combined to create “composite” biosignatures [1]. Algorithmic methods using existing data on living and non-living systems, though limited by the n = 1 of Earth, can nonetheless be informative. We assembled a database of 1277 measurements spanning 16 representative systems either indicative or non-indicative of life. Five classification (machine learning) methods were used on each individual data type, then on the entire set. This abstract summarizes the results; the data is described in more detail in [2], and methods in [3].

Biosignatures↗
NASA NTRS1992

Fortran for the nineties

Fortran has largely enjoyed prominence for the past few decades as the computer programming language of choice for numerically intensive scientific, engineering, and process control applications. Fortran's well understood static language syntax has allowed resulting parsers and compiler optimizing technologies to often generate among the most efficient and fastest run-time executables, particularly on high-end scalar and vector supercomputers. Computing architectures and paradigms have changed considerably since the last ANSI/ISO Fortran release in 1978, and while FORTRAN 77 has more than survived, it's aged features provide only partial functionality for today's demanding computing environments. The simple block procedural languages have been necessarily evolving, or giving way, to specialized supercomputing, network resource, and object-oriented paradigms. To address these new computing demands, ANSI has worked for the last 12-years with three international public reviews to deliver Fortran 90. Fortran 90 has superseded and replaced ISO FORTRAN 77 internationally as the sole Fortran standard; while in the US, Fortran 90 is expected to be adopted as the ANSI standard this summer, coexisting with ANSI FORTRAN 77 until at least 1996. The development path and current state of Fortran will be briefly described highlighting the many new Fortran 90 syntactic and semantic additions which support (among others): free form source; array syntax; new control structures; modules and interfaces; pointers; derived data types; dynamic memory; enhanced I/O; operator overloading; data abstraction; user optional arguments; new intrinsics for array, bit manipulation, and system inquiry; and enhanced portability through better generic control of underlying system arithmetic models. Examples from dynamical astronomy, signal and image processing will attempt to illustrate Fortran 90's applicability to today's general scalar, vector, and parallel scientific and engineering requirements and object oriented programming paradigms. Time permitting, current work proceeding on the future development of Fortran 2000 and collateral standards will be introduced.

Himer, J. T.↗
NASA NTRS2014

SSL Freeform Generator v1.00

The Orion spacecraft utilizes a system of Compact Unique Identifiers (CUIs) to identify telemetry measurements in the process of communicating with the ground. While avionic systems are still in development, simulation of telemetric data must be used for the development of dependent systems. The SuperScript Language (SSL) developed by Honeywell Aerospace provides users a programming language for simulation of this data. The use of tools that provide SSL generation capabilities at a higher level allows for faster and more efficient generation of simulation waveforms. Previous SSL Generator implementations such as Orion Scripted Interface Generator (OrionSIG) relied on software supported routines to generate simulation points for the SSL scripts. This provided relevant simulation capabilities, but was reduced in flexibility by the available software routines available. For this approach, software supported routines have been entirely dropped. Rather, the user is required to enter their own simulation waveform input. This allows arbitrarily complex functions to be utilized simulated with maximum degree of freedom for the user.: The idea for this version of the SSL Generator was a mapping of arbitrary waveforms to Orion CUI telemetry data. The SSL Generator implemented offers a higher degree of freedom to the user than previous versions while attempting to maintain abstraction from the underlying SSL script and the Orion CUI data types. As such, many mappings of waveforms to CUIs will simply not work. Certain implementation decisions were made to minimize the damage caused by these unintended side-effects, such as saturation of values exceeding the maximum or minimum bounds of the data type. Other details, such as signed values being represented in unsigned data types, present problems which cant be fixed to an acceptable degree of intended behavior without user input. Awareness of the limitations of all layers of the software stack will increase the productivity of the end-user.

telemetry↗
NASA NTRS1976

DABI: A data base for image analysis with nondeterministic inference capability

A description is given of the data base used in the perception subsystem of the Mars robot vehicle prototype being implemented at the Jet Propulsion Laboratory. This data base contains two types of information. The first is generic (uninstantiated, abstract) information that specifies the general rules of perception of objects in the expected environments. The second kind of information is a specific (instantiated) description of a structure, i.e., the properties and relations of objects in the specific case being analyzed. The generic knowledge can be used by the approximate reasoning subsystem to obtain information on the specific structures which is not directly measurable by the sensory instruments. Raw measurements are input either from the sensory instruments or a human operator using a CRT or a TTY.

Yakimovsky, Y.↗
NASA NTRS2008

A Data Type for Efficient Representation of Other Data Types

A self-organizing, monomorphic data type denoted a sequence has been conceived to address certain concerns that arise in programming parallel computers. A sequence in the present sense can be regarded abstractly as a vector, set, bag, queue, or other construct. Heretofore, in programming a parallel computer, it has been necessary for the programmer to state explicitly, at the outset, what parts of the program and the underlying data structures must be represented in parallel form. Not only is this requirement not optimal from the perspective of implementation; it entails an additional requirement that the programmer have intimate understanding of the underlying parallel structure. The present sequence data type overcomes both the implementation and parallel structure obstacles. In so doing, the sequence data type provides unified means by which the programmer can represent a data structure for natural and automatic decomposition to a parallel computing architecture. Sequences exhibit the behavioral and structural characteristics of vectors, but the underlying representations are automatically synthesized from combinations of programmers advice and execution use metrics. Sequences can vary bidirectionally between sparseness and density, making them excellent choices for many kinds of algorithms. The novelty and benefit of this behavior lies in the fact that it can relieve programmers of the details of implementations. The creation of a sequence enables decoupling of a conceptual representation from an implementation. The underlying representation of a sequence is a hybrid of representations composed of vectors, linked lists, connected blocks, and hash tables. The internal structure of a sequence can automatically change from time to time on the basis of how it is being used. Those portions of a sequence where elements have not been added or removed can be as efficient as vectors. As elements are inserted and removed in a given portion, then different methods are utilized to provide both an access and memory strategy that is optimized for that portion and the use to which it is put.

James, Mark↗
NASA NTRS1986

An Ada implementation of the network manager for the advanced information processing system

From an implementation standpoint, the Ada language provided many features which facilitated the data and procedure abstraction process. The language supported a design which was dynamically flexible (despite strong typing), modular, and self-documenting. Adequate training of programmers requires access to an efficient compiler which supports full Ada. When the performance issues for real time processing are finally addressed by more stringent requirements for tasking features and the development of efficient run-time environments for embedded systems, the full power of the language will be realized.

Nagle, Gail A.↗
NASA NTRS2003

High-Level Data Races

Data races are a common problem in concurrent and multi-threaded programming. They are hard to detect without proper tool support. Despite the successful application of these tools, experience shows that the notion of data race is not powerful enough to capture certain types of inconsistencies occurring in practice. In this paper we investigate data races on a higher abstraction layer. This enables us to detect inconsistent uses of shared variables, even if no classical race condition occurs. For example, a data structure representing a coordinate pair may have to be treated atomically. By lifting the meaning of a data race to a higher level, such problems can now be covered. The paper defines the concepts view and view consistency to give a notation for this novel kind of property. It describes what kinds of errors can be detected with this new definition, and where its limitations are. It also gives a formal guideline for using data structures in a multi-threading environment.

Artho, Cyrille↗