Static analysis yields efficient exact integer arithmetic for computational geometry

In solid modeling systems, the stability of Boolean set operation algorithms is an important issue. The stability can be achieved by using the homogeneous processing, which is proposed by one of the authors, and the exact integer arithmetic. The variable integer data type can represent very large integers by changing the size of the date length. However, the increase of the data length of integers leads to the increase of the computation time. In geometric algorithms, the signs of determinants are necessary to modify the topological data structure. The previous method adaptively and repeatedly extracts 8 bits from variable integer data to detect the signs of 4×4 determinants. The previously proposed method detects the signs of determinants using an FPU. In this paper, a more efficient method is proposed for detecting the signs of 4×4 determinants by extracting 16 bits. The algorithm can detect the signs of 4×4 determinants faster than the previous algorithm.

Vector normalization is an important process in several algorithms. It is used in classical physical calculations, mathematical techniques, and machine learning, which has witnessed significant advancements in recent years. Normalization and regularization ensure the stability of solutions and play an important role in algorithm convergence. Normalization typically refers to the division of elements by their norm. Division should not be used in algorithmic implementations because its computational cost is considerably higher than that of multiply–add operations. Based on this, there is a well-known method referred to as the fast inverse square root (FISR) algorithm in floating-point calculations (IEEE754). In deeper-level embedded systems that require fast responses or power efficiency, integer instead of real number arithmetic (floating-point number arithmetic) should be used to increase speed. Conversely, in deeper-level embedded systems that require fast responses or power efficiency, integer arithmetic should be used instead of real number arithmetic (floating-point number arithmetic) to increase speed. Therefore, embedded engineers encounter problems in instances in which they use integer arithmetic for implementation, but real number arithmetic is required to compute vectors and other higher-dimensional algebra. There is no conventional normalization algorithm similar to the FISR algorithm for integer arithmetic; however, the proposed pseudo-normalization achieves vector normalization within a restricted domain using only multiply–add operations and bit shifts. This allows for fast and robust operations, even for low-performance MCUs that do not have power-efficient FPUs. As an example, this study demonstrates the computation of the arctangent (Arctan2 function; atan2(y, x)) with high precision using only integer multiply–add operations. In this study, we proposed a method of vector normalization using only integer arithmetic for embedded systems and confirmed its effectiveness by simulation using Verilog. The research results can contribute to various fields such as signal processing of IMU sensor data, faster artificial intelligence training, and efficient rendering of computer graphics.

In this paper, we develop a (preconditioned) GMRES solver based on integer arithmetic, and introduce an iterative refinement framework for the solver. We describe the data format for the coefficient matrix and vectors for the solver that is based on integer or fixed-point numbers. To avoid overflow in calculations, we introduce initial scaling and logical shifts (adjustments) of operands in arithmetic operations. We present the approach for operand shifts, considering the characteristics of the GMRES algorithm. Numerical tests demonstrate that the integer arithmetic-based solver with iterative refinement has comparable solver performance in terms of convergence to the standard solver based on floating-point arithmetic. Moreover, we show that preconditioning is important, not only for improving convergence but also reducing the risk of overflow.

Chapter 7 - Arithmetic Operations

In computable analysis, sequences of rational numbers which effectively converge to a real number x are used as the (rho-) names of x. A real number x is computable if it has a computable name, and a real function f is computable if there is a Turing machine M which computes f in the sense that, M accepts any rho-name of x as input and outputs a rho-name of f(x) for any x in the domain of f. By weakening the effectiveness requirement of the convergence and classifying the converging speeds of rational sequences, several interesting classes of real numbers of weak computability have been introduced in literature, e.g., in addition to the class of computable real numbers (EC), we have the classes of semi-computable (SC), weakly computable (WC), divergence bounded computable (DBC) and computably approximable real numbers (CA). In this paper, we are interested in the weak computability of continuous real functions and try to introduce an analogous classification of weakly computable real functions. We present definitions of these functions by Turing machines as well as by sequences of rational polygons and prove these two definitions are not equivalent. Furthermore, we explore the properties of these functions, and among others, show their closure properties under arithmetic operations and composition.

The split-radix FFT computes a size-n complex DFT, when n is a large power of 2, using just \(4n\lg n-6n+8\) arithmetic operations on real numbers. This operation count was first announced in 1968, stood unchallenged for more than thirty years, and was widely believed to be best possible.Recently James Van Buskirk posted software demonstrating that the split-radix FFT is not optimal. Van Buskirk’s software computes a size-n complex DFT using only \((34/9+o(1))n\lg n\) arithmetic operations on real numbers. There are now three papers attempting to explain the improvement from 4 to 34/9: Johnson and Frigo, IEEE Transactions on Signal Processing, 2007; Lundy and Van Buskirk, Computing, 2007; and this paper.This paper presents the “tangent FFT,” a straightforward in-place cache-friendly DFT algorithm having exactly the same operation counts as Van Buskirk’s algorithm. This paper expresses the tangent FFT as a sequence of standard polynomial operations, and pinpoints how the tangent FFT saves time compared to the split-radix FFT. This description is helpful not only for understanding and analyzing Van Buskirk’s improvement but also for minimizing the memory-access costs of the FFT.KeywordsTangent FFTsplit-radix FFTmodified split-radix FFTscaled odd tailDFTconvolutionpolynomial multiplicationalgebraic complexitycommunication complexity

T-sum of sigmoid-shaped fuzzy intervals

We introduce a novel method for complex number representation. The proposed, redundant complex binary number system (RCBNS) is developed by combining a redundant binary number and a complex number in base (-1+j). Donald (1960) and Walter Penny (1964, 1965) represented complex numbers using base -j and (-1+j) in the classified algorithmic models. A redundant complex binary number system consists of both real and imaginary-radix number systems that form a redundant integer digit set. This system is formed by using complex radix of (-1+j) and a digit set of /spl alpha/=3, where /spl alpha/ assumes a value of -3, -2, -1, 0, 1, 2, 3. The arithmetic operations of complex numbers with this system treat the real and imaginary parts as one unit. The carry-free addition has the advantage of redundancy in number representation in the arithmetic operations. Results of the arithmetic operations are in the RCBNS form. The two methods for conversion from the RCBNS form to the standard binary number form have been presented. The RCBNS reduces the number of steps required to perform complex number arithmetic operations, thus enhancing the speed.

Airborne critical systems that use real numbers in their algorithms can be considerably affected by the floating-point discretized representation. This limitation in the representation is the cause of many problems already known while running software with floating-point variables such as loss of precision in arithmetic operations. This work presents a method for detecting floating-point absorption and cancellation phenomena using static analysis in software design models. Our method uses a range analysis tool that operates over SCADE model to propagate the range of the internal variables and, then, each addition and subtraction operation in the model is analyzed to check the occurrence of the floating-point absorption and cancellation phenomena. The results are presented in an HTML report containing absorption alerts and cancellations charts providing the number of canceled bits for each sub-range in order to permit better assessment of the impact of each detected cancellation. In order to validate the proposed method, we compare the results of our proposed method with the results obtained by an alternative validation method developed using the source code as input and the Frama-C EVA to propagate internal ranges. The method can be used as an early design analysis enabling the cheaper detection and treatment of floating-point anomalies.

The mathematical concept of real numbers is much richer than the double precision numbers widely used as their implementation on a computer. The field of ‘exact real arithmetic' tries to combine the elegance and correctness of the mathematical theories with the speed of double precision hardware, as far as possible. In this paper, we describe an ongoing approach using the specification language ACSL, the tool suite Frama-C (with why and jessie) and the proof assistant Coq to verify central aspects of the iRRAM software package, which is known to be a fast C++ implementation of 'exact' reals numbers.

Though many safety-critical software systems use floating point to represent real-world input and output, the mathematical specifications of these systems' behaviors use real numbers. Significant deviations from those specifications can cause errors and jeopardize safety. To ensure system safety, some programming systems offer exact real arithmetic, which often enables a program's computation to match its mathematical specification exactly. However, exact real arithmetic complicates decision-making: in these systems, it is impossible to compute (total and deterministic) discrete decisions based on connected spaces such as R. We present programming-language semantics based on constructive topology with variants allowing nondeterminism and/or partiality. Either nondeterminism or partiality suffices to allow computable decision making on connected spaces such as R. We then introduce pattern matching on spaces, a language construct for creating programs on spaces, generalizing pattern matching in functional programming, where patterns need not represent decidable predicates and also may overlap or be inexhaustive, giving rise to nondeterminism or partiality, respectively. Nondeterminism and/or partiality also yield formal logics for constructing approximate decision procedures. We extended the Marshall language for exact real arithmetic with these constructs and implemented some programs with it.

In the recent years, numerous proof systems have improved enough to be used for formally verifying non-trivial mathematical results. They, however, have different purposes and it is not always easy to choose which one is adapted to undertake a formalization effort. In this survey, we focus on properties related to real analysis: real numbers, arithmetic operators, limits, differentiability, integrability and so on. We have chosen to look into the formalizations provided in standard by the following systems: Coq, HOL4, HOL Light, Isabelle/HOL, Mizar, ProofPower-HOL, and PVS. We have also accounted for large developments that play a similar role or extend standard libraries: ACL2(r) for ACL2, C-CoRN/MathClasses for Coq, and the NASA PVS library. This survey presents how real numbers have been defined in these various provers and how the notions of real analysis described above have been formalized. We also look at the methods of automation these systems provide for real analysis.

We prove that the art gallery problem is equivalent under polynomial time reductions to deciding whether a system of polynomial equations over the real numbers has a solution. The art gallery problem is a classic problem in computational geometry, introduced in 1973 by Victor Klee. Given a simple polygon P and an integer k, the goal is to decide if there exists a set G of k guards within P such that every point p ∈ P is seen by at least one guard g∈ G. Each guard corresponds to a point in the polygon P, and we say that a guard g sees a point p if the line segment pg is contained in P. The art gallery problem has stimulated extensive research in geometry and in algorithms. However, the complexity status of the art gallery problem has not been resolved. It has long been known that the problem is NP-hard, but no one has been able to show that it lies in NP. Recently, the computational geometry community became more aware of the complexity class ∃ ℝ, which has been studied earlier by other communities. The class ∃ ℝ consists of problems that can be reduced in polynomial time to the problem of deciding whether a system of polynomial equations with integer coefficients and any number of real variables has a solution. It can be easily seen that NP ⊆ ∃ ℝ. We prove that the art gallery problem is ∃ ℝ-complete, implying that (1) any system of polynomial equations over the real numbers can be encoded as an instance of the art gallery problem, and (2) the art gallery problem is not in the complexity class NP unless NP=∃ ℝ. As an illustration of our techniques, we can show that for every compact semi-algebraic set S⊂ [0,1]2 there exists a polygon with rational coordinates that enforces one of the guards to be at any position p∈ S, in any optimal guarding. As a corollary of our construction, we prove that for any real algebraic number α there is an instance of the art gallery problem where one of the coordinates of the guards equals α in any guard set of minimum cardinality. That rules out many natural geometric approaches to the problem, as it shows that any approach based on constructing a finite set of candidate points for placing guards has to include points with coordinates being roots of polynomials with arbitrary degree. In the ∃ ℝ-hardness proof for the art gallery problem we introduce a new ∃ ℝ-complete problem ETR-INV. We believe that this problem is of independent interest, as it can be used to obtain ∃ ℝ-hardness proofs for other problems. In particular, ETR-INV has been very recently used to prove ∃ ℝ-hardness of other geometric problems.

The design and implementation of a parallel-processing-based pitch detector is presented. Pitch information is extracted by performing pitch detection on four different waveforms derived from the speech signal. Pitch information from the four pitch-detection processes is then combined to determine a final pitch estimate. The performance of this pitch detector is evaluated on a large database and compared to other well-known pitch detection algorithms. It has been implemented in real time on a TMS32020 fixed-point digital signal processor as part of a 2.4 kb/s vocoder. A performance comparison of the real-time fixed-point implementation and a computer simulation are also given. The results show that the pitch detector performance is maintained in the real-time implementation mainly because the majority of the algorithm computations are integer arithmetic and logic-type operations. >

In the previous chapter, a detailed description of the algorithms for the ‘algcurves’ package in Maple was presented. As discussed there, the package is able to handle general algebraic curves with coefficients given as exact arithmetic expressions, a restriction due to the use of exact integer arithmetic. Coefficients in terms of floating point numbers, i.e., the representation of decimal numbers of finite length on a computer, can in principle be handled, but the floating point numbers have to be converted to rational numbers. This can lead to technical difficulties in practice. One also faces limitations if one wants to study families of Riemann surfaces, where the coefficients in the algebraic equation defining the curve are floating point numbers depending on a set of parameters, i.e., if one wants to explore modular properties of Riemann surfaces as in the examples discussed below. An additional problem in this context can be computing time since the computation of the Riemann matrix uses the somewhat slow Maple integration routing. Thus, a more efficient computation of the Riemann matrix is interesting if one wants to study families of Riemann surfaces or higher genus examples which are computationally expensive.KeywordsRiemann SurfaceBranch PointTheta FunctionAlgebraic CurveAlgebraic CurfThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.