Search NASA⌕ Search

SEARCH · Search NASA

Results for “Logic Programming”

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 73 records · Page 4
All sourcesNASA NTRSDOE OSTI
NASA NTRS1984

Evaluation of automated decisionmaking methodologies and development of an integrated robotic system simulation, appendix B

The purpose of the Robotics Simulation (ROBSIM) program is to provide a broad range of computer capabilities to assist in the design, verification, simulation, and study of robotic systems. ROBSIM is programmed in FORTRAN 77 and implemented on a VAX 11/750 computer using the VMS operating system. This programmer's guide describes the ROBSIM implementation and program logic flow, and the functions and structures of the different subroutines. With this manual and the in-code documentation, and experienced programmer can incorporate additional routines and modify existing ones to add desired capabilities.

Haley, D. C.↗
NASA NTRS1986

Evaluation of automated decisionmaking methodologies and development of an integrated robotic system simulation. Appendix B: ROBSIM programmer's guide

The purpose of the Robotic Simulation (ROBSIM) program is to provide a broad range of computer capabilities to assist in the design, verification, simulation, and study of robotic systems. ROBSIM is programmed in FORTRAM 77 and implemented on a VAX 11/750 computer using the VMS operating system. The programmer's guide describes the ROBSIM implementation and program logic flow, and the functions and structures of the different subroutines. With the manual and the in-code documentation, an experienced programmer can incorporate additional routines and modify existing ones to add desired capabilities.

Haley, D. C.↗
NASA NTRS1987

SOLON: An autonomous vehicle mission planner

The State-Operator Logic Machine (SOLON) Planner provides an architecture for effective real-time planning and replanning for an autonomous vehicle. The highlights of the system, which distinguish it from other AI-based planners that have been designed previously, are its hybrid application of state-driven control architecture and the use of both schematic representations and logic programming for the management of its knowledge base. SOLON is designed to provide multiple levels of planning for a single autonomous vehicle which is supplied with a skeletal, partially-specified mission plan at the outset of the vehicle's operations. This mission plan consists of a set of objectives, each of which will be decomposable by the planner into tasks. These tasks are themselves comparatively complex sets of actions which are executable by a conventional real-time control system which does not perform planning but which is capable of making adjustments or modifications to the provided tasks according to constraints and tolerances provided by the Planner. The current implementation of the SOLON is in the form of a real-time simulation of the Planner module of an Intelligent Vehicle Controller (IVC) on-board an autonomous underwater vehicle (AUV). The simulation is embedded within a larger simulator environment known as ICDS (Intelligent Controller Development System) operating on a Symbolics 3645/75 computer.

Dudziak, M. J.↗
NASA NTRS1990

Computer program to solve two-dimensional shock-wave interference problems with an equilibrium chemically reacting air model

The computer program EASI, an acronym for Equilibrium Air Shock Interference, was developed to calculate the inviscid flowfield, the maximum surface pressure, and the maximum heat flux produced by six shock wave interference patterns on a 2-D, cylindrical configuration. Thermodynamic properties of the inviscid flowfield are determined using either an 11-specie, 7-reaction equilibrium chemically reacting air model or a calorically perfect air model. The inviscid flowfield is solved using the integral form of the conservation equations. Surface heating calculations at the impingement point for the equilibrium chemically reacting air model use variable transport properties and specific heat. However, for the calorically perfect air model, heating rate calculations use a constant Prandtl number. Sample calculations of the six shock wave interference patterns, a listing of the computer program, and flowcharts of the programming logic are included.

Glass, Christopher E.↗
NASA NTRS1992

A PC-based collapse factor analysis for high pressure cryogenic systems

A collapse factor simulation computer program, suitable for use on personal computers, for supercritical cryogen system pressurization is examined. The available literature is previewed, individual component models are developed, and the overall simulation program logic is examined. Extensive use is made of existing thermodynamic and transport property evaluation packages. Heat transfer is estimated using natural convection correlations, and transient wall heat conduction is considered. Examples of the simulation are demonstrated for two facilities. Partial validation is achieved by comparing the simulation output with data from an existing test facility. Preliminary results indicate that the collapse factors will seldom exceed 1.15 during supercritical operation of high-pressure cryogenic systems. Recommendations for improvements in the component models and the simulation are made.

Hodge, B. K.↗
NASA NTRS1992

An interactive preprocessor for the NASA engine performance program

The Simplified NEPP Automated Preprocessor (SNAP), which is written to aid in the preparation of input data files for the NASA Engine Performance Program (NEPP), is described. Specifically, SNAP is a software package on the Virtual Machine operating system that prompts the NEPP user for input information via a series of menus. The data collected from these menus are assimilated into an input file suitable for the running of NEPP. SNAP acts as a user-friendly preprocessing interface for NEPP. This serves as an introduction to the SNAP software, a user's manual, a description of the program logic, and a maintenance manual for future modifications to the software.

Berton, Jeffrey J.↗
NASA NTRS1992

Global planning of several plants

This paper discusses an attempt to solve the problem of planning several pharmaceutical plants at a global level. The interest in planning at this level is to increase the global control over the production process, to improve its overall efficiency, and to reduce the need for interaction between production plants. In order to reduce the complexity of this problem and to make it tractable, some abstractions were made. Based on these abstractions, a prototype is being developed within the framework of the EUREKA project PROTOS, using Constraint Logic Programming techniques.

Bescos, Sylvie↗
NASA NTRS1987

Using Histories to Implement Atomic Objects

In this paper we describe an approach of implementing atomicity. Atomicity requires that computations appear to be all-or-nothing and executed in a serialization order. The approach we describe has three characteristics. First, it utilizes the semantics of an application to improve concurrency. Second, it reduces the complexity of application-dependent synchronization code by analyzing the process of writing it. In fact, the process can be automated with logic programming. Third, our approach hides the protocol used to arrive at a serialization order from the applications. As a result, different protocols can be used without affecting the applications. Our approach uses a history tree abstraction. The history tree captures the ordering relationship among concurrent computations. By determining what types of computations exist in the history tree and their parameters, a computation can determine whether it can proceed.

Ng, Pui↗
NASA NTRS2005

What Sensing Tells Us: Towards a Formal Theory of Testing for Dynamical Systems

Just as actions can have indirect effects on the state of the world, so too can sensing actions have indirect effects on an agent's state of knowledge. In this paper, we investigate "what sensing actions tell us", i.e., what an agent comes to know indirectly from the outcome of a sensing action, given knowledge of its actions and state constraints that hold in the world. To this end, we propose a formalization of the notion of testing within a dialect of the situation calculus that includes knowledge and sensing actions. Realizing this formalization requires addressing the ramification problem for sensing actions. We formalize simple tests as sensing actions. Complex tests are expressed in the logic programming language Golog. We examine what it means to perform a test, and how the outcome of a test affects an agent's state of knowledge. Finally, we propose automated reasoning techniques for test generation and complex-test verification, under certain restrictions. The work presented in this paper is relevant to a number of application domains including diagnostic problem solving, natural language understanding, plan recognition, and active vision.

McIlraith, Sheila↗
NASA NTRS2009

Problems Encountered During the Recertification of the GLORY Solar Array Dual Axis Gimbal Drive Actuators

The Glory observatory is the current incarnation of the Vegetation Canopy Lidar (VCL) mission spacecraft bus. The VCL spacecraft bus, having been cancelled for programmatic reasons in 2000, was nearly integrated when it was put into storage for possible future use. The Glory mission was a suitable candidate for using this spacecraft and in 2006 an effort to recertify the two axis solar array gimbal drive after its extended storage was begun. What was expected to be a simple performance validation of the two dual axis gimbal stepper motors became a serious test, diagnosis and repair task once questions arose on the flight worthiness of the hardware. A significant test program logic flow was developed which identified decisions that could be made based on the results of individual recertification tests. Without disassembling the bi-axial gimbals, beginning with stepper motor threshold voltage measurements and relating these to powered drive torque measurements, both performed at the spacecraft integrator s facility, a confusing picture of the health of the actuators came to light. Tests at the gimbal assembly level and tests of the disassembled actuators were performed by the manufacturer to validate our results and torque discrepancies were noted. Further disassembly to the component level of the actuator revealed the source of the torque loss.

Saltzman, Marc↗
NASA NTRS2009

Proof-Carrying Code with Correct Compilers

In the late 1990s, proof-carrying code was able to produce machine-checkable safety proofs for machine-language programs even though (1) it was impractical to prove correctness properties of source programs and (2) it was impractical to prove correctness of compilers. But now it is practical to prove some correctness properties of source programs, and it is practical to prove correctness of optimizing compilers. We can produce more expressive proof-carrying code, that can guarantee correctness properties for machine code and not just safety. We will construct program logics for source languages, prove them sound w.r.t. the operational semantics of the input language for a proved-correct compiler, and then use these logics as a basis for proving the soundness of static analyses.

Appel, Andrew W.↗
NASA NTRS2005

Fuzzy Logic Engine

The Fuzzy Logic Engine is a software package that enables users to embed fuzzy-logic modules into their application programs. Fuzzy logic is useful as a means of formulating human expert knowledge and translating it into software to solve problems. Fuzzy logic provides flexibility for modeling relationships between input and output information and is distinguished by its robustness with respect to noise and variations in system parameters. In addition, linguistic fuzzy sets and conditional statements allow systems to make decisions based on imprecise and incomplete information. The user of the Fuzzy Logic Engine need not be an expert in fuzzy logic: it suffices to have a basic understanding of how linguistic rules can be applied to the user's problem. The Fuzzy Logic Engine is divided into two modules: (1) a graphical-interface software tool for creating linguistic fuzzy sets and conditional statements and (2) a fuzzy-logic software library for embedding fuzzy processing capability into current application programs. The graphical- interface tool was developed using the Tcl/Tk programming language. The fuzzy-logic software library was written in the C programming language.

Howard, Ayanna↗
NASA NTRS1980

A computer program for the generation of logic networks from task chart data

The Network Generation Program (NETGEN), which creates logic networks from task chart data is presented. NETGEN is written in CDC FORTRAN IV (Extended) and runs in a batch mode on the CDC 6000 and CYBER 170 series computers. Data is input via a two-card format and contains information regarding the specific tasks in a project. From this data, NETGEN constructs a logic network of related activities with each activity having unique predecessor and successor nodes, activity duration, descriptions, etc. NETGEN then prepares this data on two files that can be used in the Project Planning Analysis and Reporting System Batch Network Scheduling program and the EZPERT graphics program.

Herbert, H. E.↗
DOE OSTI2020

High performance context switching for virtualized FPGA accelerators

A hardware context manager in a field-programmable gate array (FPGA) device includes configuration logic configured to program one or more programming regions in the FPGA device based on configuration data for implementing a target configuration of the one or more programming regions. Context management logic in the hardware context manager is coupled with the configuration logic and saves a first context corresponding to the target configuration by retrieving first state information from the set of one or more programming regions, where the first state information is generated based on the target configuration, and storing the retrieved first state information in a context memory. The context management logic restores the first context by transferring the first state information from the context memory to the one or more programming regions, and causing the configuration logic to program the one or more programming regions based on the configuration data.

42 ENGINEERING↗
DOE OSTI2024

A Formalization of Core Why3 in Coq

Intermediate verification languages like Why3 and Boogie have made it much easier to build program verifiers, transforming the process into a logic compilation problem rather than a proof automation one. Why3 in particular implements a rich logic for program specification with polymorphism, algebraic data types, recursive functions and predicates, and inductive predicates; it translates this logic to over a dozen solvers and proof assistants. Accordingly, it serves as a backend for many tools, including Frama-C, EasyCrypt, and GNATProve for Ada SPARK. But how can we be sure that these tools are correct? The alternate foundational approach, taken by tools like VST and CakeML, provides strong guarantees by implementing the entire toolchain in a proof assistant, but these tools are harder to build and cannot directly take advantage of SMT solver automation. As a first step toward enabling automated tools with similar foundational guarantees, we give a formal semantics in Coq for the logic fragment of Why3. We show that our semantics are useful by giving a correct-by-construction natural deduction proof system for this logic, using this proof system to verify parts of Why3's standard library, and proving sound two of Why3's transformations used to convert terms and formulas into the simpler logics supported by the backend solvers.

97 MATHEMATICS AND COMPUTING↗
NASA NTRS1973

Rendezvous targeting

Revisions to be included in 'Space Shuttle Guidance, Navigation and Control Design Equations' are reported. Technical changes include: (1) a plane change maneuver was incorporated in the program's logic; (2) in the search for an apsidal crossing, program checks were included to update through intervals of pi in the case of near circular orbits or close proximity to an apsidal point; (3) following an astronaut overwrite of a Lambert maneuver, the state vector was updated to establish a new target vector for use in the powered flight routine; and (4) following the computation of each maneuver, the position vector of the primary vehicle was offset - to help compensate for the effects of the finite maneuver - prior to the update of the state vector to the next maneuver point. Input and output variables, detailed flow diagrams a functional flow diagram, and a description of equations are presented.

Tempelman, W. H.↗