SEARCH · Search NASA
Results for “rounding error analysis”
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.
Rounding error bounds by perturbation- condition analysis
Rounding error bounds by perturbation condition analysis, and conditioning for eigenvalue problem
An Abstract Interpretation Framework for the Round-Off Error Analysis of Floating-Point Programs
This paper presents an abstract interpretation framework for the round-off error analysis of floating-point programs. This framework defines a parametric abstract analysis that computes, for each combination of ideal and floating-point execution path of the program, a sound over-approximation of the accumulated floating-point round-off error that may occur. In addition, a Boolean expression that characterizes the input values leading to the computed error approximation is also computed. An abstraction on the control flow of the program is proposed to mitigate the explosion of the number of elements generated by the analysis. Additionally, a widening operator is defined to ensure the convergence of recursive functions and loops. An instantiation of this framework is implemented in the prototype tool PRECiSA that generates formal proof certificates stating the correctness of the computed round-off errors.
Floating-point Round-off Error Analysis of Safety-critical Avionics Software
Explore the source record for details and available documents.
VSCode-PRECiSA: a Toolkit for Floating-Point Round-Off Error Analysis
Explore the source record for details and available documents.
Rigorous Floating-Point Round-Off Error Analysis with PRECiSA 4.0
Explore the source record for details and available documents.
Automatic Estimation of Verified Floating-Point Round-Off Errors via Static Analysis
This paper introduces a static analysis technique for computing formally verified round-off error bounds of floating-point functional expressions. The technique is based on a denotational semantics that computes a symbolic estimation of floating-point round-o errors along with a proof certificate that ensures its correctness. The symbolic estimation can be evaluated on concrete inputs using rigorous enclosure methods to produce formally verified numerical error bounds. The proposed technique is implemented in the prototype research tool PRECiSA (Program Round-o Error Certifier via Static Analysis) and used in the verification of floating-point programs of interest to NASA.
Combining Sparse Approximate Factorizations with Mixed-precision Iterative Refinement
The standard LU factorization-based solution process for linear systems can be enhanced in speed or accuracy by employing mixed-precision iterative refinement. Most recent work has focused on dense systems. We investigate the potential of mixed-precision iterative refinement to enhance methods for sparse systems based on approximate sparse factorizations. In doing so, we first develop a new error analysis for LU- and GMRES-based iterative refinement under a general model of LU factorization that accounts for the approximation methods typically used by modern sparse solvers, such as low-rank approximations or relaxed pivoting strategies. We then provide a detailed performance analysis of both the execution time and memory consumption of different algorithms, based on a selected set of iterative refinement variants and approximate sparse factorizations. Our performance study uses the multifrontal solver MUMPS, which can exploit block low-rank factorization and static pivoting. We evaluate the performance of the algorithms on large, sparse problems coming from a variety of real-life and industrial applications showing that mixed-precision iterative refinement combined with approximate sparse factorization can lead to considerable reductions of both the time and memory consumption.
On the equivalence of Gaussian elimination and Gauss-Jordan reduction in solving linear equations
A novel general approach to round-off error analysis using the error complexity concepts is described. This is applied to the analysis of the Gaussian Elimination and Gauss-Jordan scheme for solving linear equations. The results show that the two algorithms are equivalent in terms of our error complexity measures. Thus the inherently parallel Gauss-Jordan scheme can be implemented with confidence if parallel computers are available.
A theoretical analysis of the round-off propagation in different Kalman filter implementations
A theoretical analysis is made of the error propagation due to numerical round-off for four different Kalman filter implementations: the conventional Kalman filter, the square root covariance filter, the square root information filter and the Chandrasekhar square root filter. From these error models, new insights about the applicability of the different filters and their sensitivity to round-off, is obtained. It is shown that the CKF may become completely unreliable when the original plant is unstable, and that this is easily circumvented by a number of techniques. The square root filters, often quoted to possess a conditioning or sensitivity that is the square root of that of the CKF, are shown to possess this property only for the computation of the covariance of the filtered signal and not for the computation of the Kalman gain or the filtered estimate. Finally, the Chandrasekhar filter is shown to be numerically unstable.
Numerical Study of Buoyancy and Different Diffusion Effects on the Structure and Dynamics of Triple Flames
Numerical simulations of 2-D triple flames under gravity force have been implemented to identify the effects of gravity on triple flame structure and propagation properties and to understand the mechanisms of instabilities resulting from both heat release and buoyancy effects. A wide range of gravity conditions, heat release, and mixing widths for a scalar mixing layer are computed for downward-propagating (in the same direction with the gravity vector) and upward-propagating (in the opposite direction of the gravity vector) triple flames. Results of numerical simulations show that gravity strongly affects the triple flame speed through its contribution to the overall flow field. A simple analytical model for the triple flame speed, which accounts for both buoyancy and heat release, is developed. Comparisons of the proposed model with the numerical results for a wide range of gravity, heat release and mixing width conditions, yield very good agreement. The analysis shows that under neutral diffusion, downward propagation reduces the triple flame speed, while upward propagation enhances it. For the former condition, a critical Froude number may be evaluated, which corresponds to a vanishing triple flame speed. Downward-propagating triple flames at relatively strong gravity effects have exhibited instabilities. These instabilities are generated without any artificial forcing of the flow. Instead disturbances are initiated by minute round-off errors in the numerical simulations, and subsequently amplified by instabilities. A linear stability analysis on mean profiles of stable triple flame configurations have been performed to identify the most amplified frequency in spatially developed flows. The eigenfunction equations obtained from the linearized disturbance equations are solved using the shooting method. The linear stability analysis yields reasonably good agreements with the observed frequencies of the unstable triple flames. The frequencies and amplitudes of disturbances increase with the magnitude of the gravity vector. Moreover, disturbances appear to be most amplified just downstream of the premixed branches. The effects of mixing width and differential diffusion are investigated and their roles on the flame stability are studied.
PRECiSA: a static analysis tool for floating-point programs
This presentation introduces PRECiSA, a static analysis framework for analyzing floating-point programs. PRECiSA computes round-off error bounds for a class of floating-point programs, and produces a formal proof certificate of the correctness of these bounds. PRECiSA also has the capability of generating C code which is instrumented to detect unstable branching conditions from a real-number algorithm specification.
Automatic Generation of Guard-Stable Floating-Point Code
In floating-point programs, test instability occurs when the control flow of a conditional statement diverges from its ideal execution under real arithmetic. This phenomenon is caused by the presence of round-off errors in floating-point computations. Writing programs that correctly handle test instability often require expertise on finite precision computations and rounding errors. This paper presents a fully automatic tool chain that generates and formally verifies a test-stable floating-point C program from its functional specification in real arithmetic. The generated program is instrumented to soundly detect when unstable tests may occur and, in these cases, to issue a warning. The proposed approach combines the PRECiSA floating-point static analyzer, the Frama-C software verification suite, and the PVS theorem prover.
A Decentralized Framework to Support UAS Merging and Spacing Operations in Urban Canyons
Explore the source record for details and available documents.
Automatic Generation of Guard-Stable Floating-Point Code
Explore the source record for details and available documents.
A Provably Correct Floating-Point Implementation of Well Clear Avionics Concepts
The NASA DAIDALUS library provides formal definitions for Detect-and-Avoid avionics concepts such as when an aircraft is well-clear with respect to the surrounding air traffic, i.e., it does not operate in such proximity to create a collision hazard. While several properties are proven correct for DAIDALUS assuming ideal real number arithmetic, an actual implementation that uses floating-point numbers may behave unexpectedly because of round-off errors and run-time exceptions. This paper presents an experience report on the application of a formal methods toolchain to extract and verify floating-point C code from a real-valued specification of the well-clear module of DAIDALUS. This toolchain comprises the PVS theorem prover, the PRECiSA floating-point analyzer and code generator, and the Frama-C analysis suite. The generated code is automatically instrumented to detect when the control flow of the floating-point program may diverge from the ideal real number specification, and it is annotated with contracts that state the maximum accumulated round-off error. The absence of overflows is also formally verified for the generated code. In order to apply the toolchain to an industrial case study such as DAIDALUS, a formally verified pre-processing of the input specification is performed, which includes a program slicing and several semantic-preserving simplifications.
Hardware-Independent Proofs of Numerical Programs
On recent architectures, a numerical program may give different answers depending on the execution hardware and the compilation. Our goal is to formally prove properties about numerical programs that are true for multiple architectures and compilers. We propose an approach that states the rounding error of each floating-point computation whatever the environment. This approach is implemented in the Frama-C platform for static analysis of C code. Small case studies using this approach are entirely and automatically proved
Round-off errors in cutting plane algorithms based on the revised simplex procedure
This report statistically analyzes computational round-off errors associated with the cutting plane approach to solving linear integer programming problems. Cutting plane methods require that the inverse of a sequence of matrices be computed. The problem basically reduces to one of minimizing round-off errors in the sequence of inverses. Two procedures for minimizing this problem are presented, and their influence on error accumulation is statistically analyzed. One procedure employs a very small tolerance factor to round computed values to zero. The other procedure is a numerical analysis technique for reinverting or improving the approximate inverse of a matrix. The results indicated that round-off accumulation can be effectively minimized by employing a tolerance factor which reflects the number of significant digits carried for each calculation and by applying the reinversion procedure once to each computed inverse. If 18 significant digits plus an exponent are carried for each variable during computations, then a tolerance value of 0.1 x 10 to the minus 12th power is reasonable.