Downloads & Free Reading Options - Results

In many real-time signal processing applications, fast and numerically stable algorithms for solving least-squares problems are necessary and important. In particular, under non-stationary conditions, these algorithms must be able to adapt themselves to reflect the changes in the system and take appropriate adjustments to achieve optimum performances. Among existing algorithms, the QR-decomposition (QRD)-based recursive least-squares (RLS) methods have been shown to be useful and effective for adaptive signal processing. In order to increase the speed of processing and achieve high throughput rate, many algorithms are being vectorized and/or pipelined to facilitate high degrees of parallelism. A time-recursive formulation of RLS filtering employing block QRD will be considered first. Several methods, including a new non-continuous windowing scheme based on selectively rejecting contaminated data, were investigated for adaptive processing. Based on systolic triarrays, many other forms of systolic arrays are shown to be capable of implementing different algorithms. Various updating and downdating systolic algorithms and architectures for RLS filtering are examined and compared in details, which include Householder reflector, Gram-Schmidt procedure, and Givens rotation. A unified approach encompassing existing square-root-free algorithms is also proposed. For the sinusoidal spectrum estimation problem, a judicious method of separating the noise from the signal is of great interest. Various truncated QR methods are proposed for this purpose and compared to the truncated SVD method. Computer simulations provided for detailed comparisons show the effectiveness of these methods. This thesis deals with fundamental issues of numerical stability, computational efficiency, adaptivity, and VLSI implementation for the RLS filtering problems. In all, various new and modified algorithms and architectures are proposed and analyzed; the significance of any of the new method depends crucially on specific application.

This paper considers the deterministic and stochastic modeling of 2-D systems described by their input/output data. In the deterministic case, the modeling problem is formulated as a 2-D Pade approximation problem. By studying several possible geometries of approximation, we obtain several sets of recursions of the 2-D rational approximants. These results exploit the properties of 2-D Hankel matrices, and they are used here to characterize the 2-D rational transfer functions. In the stochastic case, the realization problem is viewed as a 2-D prediction problem. This problem is solved recursively by generalizing to the 2-D case an algorithm due to Levinson in the 1-D case. The predictors obtained by this algorithm are then showed to converge to the 2-D spectral factors of the output spectrum. (Author)

Based on the Newton Raphson method, this paper presents recursive algorithms that are rapidly convergent and more stable for modeling the equivalent continuous-time (discrete-time) model from the available discrete-time (continuous-time) model for a fixed sampling period. The newly developed recursive algorithms relax the constraints imposed upon the existing model conversion algorithms, and, thus enhance the applications of microprocessors and associated microelectronics to digital control systems. A practical example is presented to demonstrate the effectiveness of the proposed procedures. Reprints.

If $A$ is a tridiagonal matrix, then the equations $AX=I$ and $XA=I$ defining the inverse $X$ of $A$ are in fact the second order recurrence relations for the elements in each row and column of $X$. Thus, the recursive algorithms should be a natural and commonly used way for inverting tridiagonal matrices -- but they are not. Even though a variety of such algorithms were proposed so far, none of them can be applied to numerically invert an arbitrary tridiagonal matrix. Moreover, some of the methods suffer a huge instability problem. In this paper, we investigate these problems very thoroughly. We locate and explain the different reasons the recursive algorithms for inverting such matrices fail to deliver satisfactory (or any) result, and then propose new formulae for the elements of $X=A^{-1}$ that allow to construct the asymptotically fastest possible algorithm for computing the inverse of an arbitrary tridiagonal matrix $A$, for which both residual errors, $\|AX-I\|$ and $\|XA-I\|$, are always very small.

The Viterbi algorithm is indeed a very simple and efficient method of implementing the maximum likelihood decoding. However, if we take advantage of the structural properties in a trellis section, other efficient trellis-based decoding algorithms can be devised. Recently, an efficient trellis-based recursive maximum likelihood decoding (RMLD) algorithm for linear block codes has been proposed. This algorithm is more efficient than the conventional Viterbi algorithm in both computation and hardware requirements. Most importantly, the implementation of this algorithm does not require the construction of the entire code trellis, only some special one-section trellises of relatively small state and branch complexities are needed for constructing path (or branch) metric tables recursively. At the end, there is only one table which contains only the most likely code-word and its metric for a given received sequence r = (r(sub 1), r(sub 2),...,r(sub n)). This algorithm basically uses the divide and conquer strategy. Furthermore, it allows parallel/pipeline processing of received sequences to speed up decoding.

We prove a moderate deviation principle for the continuous time interpolation of discrete time recursive stochastic processes. The methods of proof are somewhat different from the corresponding large deviation result, and in particular the proof of the upper bound is more complicated. The results can be applied to the design of accelerated Monte Carlo algorithms for certain problems, where schemes based on moderate deviations are easier to construct and in certain situations provide performance comparable to those based on large deviations.

Recursion continues to play an important role in high-performance computing. However, parallelizing recursive algorithms while achieving high performance is nontrivial and can result in complex, hard to maintain code. In particular, assigning processors to subproblems is complicated by recent observations that communication costs often dominate computation costs. Previous work [1][3] demonstrates that carefully choosing which divide-and-conquer steps to execute in parallel (breadth-first steps) and which to execute sequentially (depth-first steps) can result in significant performance gains over naive scheduling. Our Framework for Recursive Parallel Algorithms (FRPA) allows for the separation of an algorithms implementation from its parallelization. The programmer must simply define how to split a problem, solve the base case, and merge solved subproblems; FRPA handles parallelizing the code and tuning the recursive parallelization strategy, enabling algorithms to achieve high performance. To demonstrate FRPAs performance capabilities, we present a detailed analysis of two algorithms: Strassen-Winograd [1] and Communication-Optimal Parallel Recursive Rectangular Matrix Multiplication (CARMA) [3]. Our single-precision CARMA implementation is fewer than 80 lines of code and achieves a speedup of up to 11x over Intels Math Kernel Library (MKL) [4] matrix multiplication routine on skinny matrices. Our double-precision Strassen-Winograd implementation, at just 150 lines of code, is up to 45 faster than MKL for large square matrix multiplications. To show FRPAs generality and simplicity, we implement six additional algorithms: mergesort, quicksort, TRSM, SYRK, Cholesky decomposition, and Delaunay triangulation [5]. FRPA is implemented in C++, runs in shared-memory environments, uses Intels Cilk Plus [6] for task-based parallelism, and leverages OpenTuner [7] to tune the parallelization strategy.

Matrix multiplication is one of the most fundamental algorithmic problems in numerical linear algebra, distributed computing, scientific computing, and high-performance computing. Parallelization of matrix multiplication has been extensively studied (e.g., [21, 12, 24, 2, 51, 39, 36, 23, 45, 61]). It has been addressed using many theoretical approaches, algorithmic tools, and software engineering methods in order to optimize performance and obtain faster and more efficient parallel algorithms and implementations. To design efficient parallel algorithms, it is necessary not only to load balance the computation, but also to minimize the time spent communicating between processors. The interprocessor communication costs are in many cases significantly higher than the computational costs. Moreover, hardware trends predict that more problems will become communication-bound in the future [38, 35]. Even matrix multiplication, which is widely considered to be computation-bound, becomes communication-bound when a given problem is run on sufficiently many processors.

The Geometrically Intrinsic Nonlinear Recursive Filter, or GI Filter, is designed to estimate an arbitrary continuous-time Markov diffusion process X subject to nonlinear discrete-time observations. The GI Filter is fundamentally different from the much-used Extended Kalman Filter (EKF), and its second-order variants, even in the simplest nonlinear case, in that: It uses a quadratic function of a vector observation to update the state, instead of the linear function used by the EKF. It is based on deeper geometric principles, which make the GI Filter coordinate-invariant. This implies, for example, that if a linear system were subjected to a nonlinear transformation f of the state-space and analyzed using the GI Filter, the resulting state estimates and conditional variances would be the push-forward under f of the Kalman Filter estimates for the untransformed system-a property which is not shared by the EKF or its second-order variants. The noise covariance of X and the observation covariance themselves induce geometries on state space and observation space, respectively, and associated canonical connections. A sequel to this paper develops stochastic differential geometry results based on intrinsic location parameters , a notion derived from the heat flow of harmonic mappings- from which we derive the coordinate-free filter update formula. The present article presents the algorithm with reference to a specific example- the problem of tracking and intercepting a target, using sensors based on a moving missile. Computational experiments show that, when the observation function is highly nonlinear, there exist choices of the noise parameters at which the GI Filter significantly outperforms the EKF.

We prove a moderate deviation principle for the continuous time interpolation of discrete time recursive stochastic processes. The methods of proof are somewhat different from the corresponding large deviation result, and in particular the proof of the upper bound is more complicated.

A certain relatively simple type of recursive multitarget correlation and tracking algorithm is developed for the case of position-only target reports. Several aspects of its performance are tested numerically on simulated data resembling ship tracking situations of various target densities. Some simplifications of this procedure are also tested in this way to assess the relative contributions of several implementation concepts in this context. (Author)

This report presents a comparison of existing angle-only target motion analysis algorithms which have applications in tracking under jamming conditions. Though a number of different algorithms have been proposed for this problem, the particular emphasis in this report is recursive style algorithms which are more suited to airborne applications. In particular, six algorithms are considered, which are derivatives of either the standard or the extended Kalman filter. Four of these algorithms are single-filter trackers while the other two are based on weighted sum of multiple filter outputs. Simulation results are presented to verify the claimed properties of these algorithms.

Pushdown systems (PDSs) and recursive state machines (RSMs), which are linearly equivalent, are standard models for interprocedural analysis. Yet RSMs are more convenient as they (a) explicitly model function calls and returns, and (b) specify many natural parameters for algorithmic analysis, e.g., the number of entries and exits. We consider a general framework where RSM transitions are labeled from a semiring and path properties are algebraic with semiring operations, which can model, e.g., interprocedural reachability and dataflow analysis problems. Our main contributions are new algorithms for several fundamental problems. As compared to a direct translation of RSMs to PDSs and the best-known existing bounds of PDSs, our analysis algorithm improves the complexity for finite-height semirings (that subsumes reachability and standard dataflow properties). We further consider the problem of extracting distance values from the representation structures computed by our algorithm, and give efficient algorithms that distinguish the complexity of a one-time preprocessing from the complexity of each individual query. Another advantage of our algorithm is that our improvements carry over to the concurrent setting, where we improve the best-known complexity for the context-bounded analysis of concurrent RSMs. Finally, we provide a prototype implementation that gives a significant speed-up on several benchmarks from the SLAM/SDV project.

We present algorithms that learn certain classes of function-free recursive logic programs in polynomial time from equivalence queries. In particular, we show that a single k-ary recursive constant-depth determinate clause is learnable. Two-clause programs consisting of one learnable recursive clause and one constant-depth determinate non-recursive clause are also learnable, if an additional ``basecase'' oracle is assumed. These results immediately imply the pac-learnability of these classes. Although these classes of learnable recursive programs are very constrained, it is shown in a companion paper that they are maximally general, in that generalizing either class in any natural way leads to a computationally difficult learning problem. Thus, taken together with its companion paper, this paper establishes a boundary of efficient learnability for recursive logic programs.

We present recursive multiport schemes for implementing quantum Fourier transforms and the inversion step in Grover's algorithm on an integrated linear optics device. In particular, each scheme shows how to execute a quantum operation on $2d$ modes using a pair of circuits for the same operation on $d$ modes. The circuits operate on path-encoded qudits and realize $d$-dimensional unitary transformations on these states using linear optical networks with $O\left(d^2\right)$ optical elements. To evaluate the schemes against realistic errors, we ran simulations of proof-of-principle experiments using a simple fabrication model of silicon-based photonic integrated devices that employ directional couplers and thermo-optic modulators for beam splitters and phase shifters, respectively. We find that high-fidelity performance is achievable with our multiport circuits for $2$-qubit and $3$-qubit quantum Fourier transforms, and for quantum search on four-item and eight-item databases.

We present recursive multiport schemes for implementing quantum Fourier transforms and the inversion step in Grover's algorithm on an integrated linear optics device. In particular, each scheme shows how to execute a quantum operation on $2d$ modes using a pair of circuits for the same operation on $d$ modes. The circuits operate on path-encoded qudits and realize $d$-dimensional unitary transformations on these states using linear optical networks with $O\left(d^2\right)$ optical elements. To evaluate the schemes against realistic errors, we ran simulations of proof-of-principle experiments using a simple fabrication model of silicon-based photonic integrated devices that employ directional couplers and thermo-optic modulators for beam splitters and phase shifters, respectively. We find that high-fidelity performance is achievable with our multiport circuits for $2$-qubit and $3$-qubit quantum Fourier transforms, and for quantum search on four-item and eight-item databases.

In this paper, a new computationally efficient algorithm for recursive least-squares (RLS) filtering is presented. The proposed Split RLS algorithm can perform the approximated RLS with 0(N) complexity for signals having no special data structure to be exploited, while avoiding the high computational complexity (0(N2)) required in the conventional RLS algorithms. Our performance analysis shows that the estimation bias will be small when the input data are less correlated. We also show that for highly correlated data, the orthogonal preprocessing scheme can be used to improve the performance of the Split RLS. Furthermore, the systolic implementation of our algorithm based on the QR-decomposition RLS (QRD-RLS) array as well as its application to multidimensional adaptive filtering is also discussed. The hardware complexity for the resulting array is only 0(N) and the system latency can be reduced to O(log2 N). The simulation results show that the Split RLS outperforms the conventional RLS in the application of image restoration. A major advantage of the Split RLS is its superior tracking capability over the conventional RLS under non-stationary environments.

A technique is presented for solving the inverse dynamics of flexible planar multibody systems. This technique yields the non-causal joint efforts (inverse dynamics) as well as the internal states (inverse kinematics) that produce a prescribed nominal trajectory of the end effector. A non-recursive global Lagrangian approach is used in formulating the equations for motion as well as in solving the inverse dynamics equations. Contrary to the recursive method previously presented, the proposed method solves the inverse problem in a systematic and direct manner for both open-chain as well as closed-chain configurations. Numerical simulation shows that the proposed procedure provides an excellent tracking of the desired end effector trajectory.

Polar codes are recursive general concatenated codes. This property motivates a recursive formalization of the known decoding algorithms: Successive Cancellation, Successive Cancellation with Lists and Belief Propagation. This description allows an easy development of the first two algorithms for arbitrary polarizing kernels. Hardware architectures for these decoding algorithms are also described in a recursive way, both for Arikan's standard polar codes and for arbitrary polarizing kernels.

This work examines the performance of the Recursive Least Squares (RLS) Algorithm, and derivative, the Recursive Lattice Least Squares (RLLS) algorithm in matching a linear model to a simple nonlinear system. The response of a single degree of freedom mass-spring-dashpot system to continuous forcing is simulated, and estimates for the modal parameters are obtained. Nonlinearity is introduced by allowing the restoring spring to slide without friction in a gap of specified width. Such a nonlinearity is of interest since it is a simple model of the effect of loose joints in a deployable spacecraft restoring spring to slide without friction in a gap of specified width. Such a nonlinearity is of interest since it is a simple model of the effect of loose joints in a deployable spacecraft structure. The effect of the gap size on the algorithms is studied, and the noise level and sampling rate are adjusted to see how they influence these results. The RLS Algorithm is found to be the most reliable. Finally, the RLS Algorithm is extended to include an estimate for the gap width, and good results are obtained for the noise-free case. Additional conclusions are made on how to minimize the effect of such a gap nonlinearity on the identification process. Keywords: Parameter identification; Modal analysis; Theses; Nonlinear systems; Space structures.

This paper focuses on the problem of recursive nonlinear least squares parameter estimation in multi-agent networks, in which the individual agents observe sequentially over time an independent and identically distributed (i.i.d.) time-series consisting of a nonlinear function of the true but unknown parameter corrupted by noise. A distributed recursive estimator of the \emph{consensus} + \emph{innovations} type, namely $\mathcal{CIWNLS}$, is proposed, in which the agents update their parameter estimates at each observation sampling epoch in a collaborative way by simultaneously processing the latest locally sensed information~(\emph{innovations}) and the parameter estimates from other agents~(\emph{consensus}) in the local neighborhood conforming to a pre-specified inter-agent communication topology. Under rather weak conditions on the connectivity of the inter-agent communication and a \emph{global observability} criterion, it is shown that at every network agent, the proposed algorithm leads to consistent parameter estimates. Furthermore, under standard smoothness assumptions on the local observation functions, the distributed estimator is shown to yield order-optimal convergence rates, i.e., as far as the order of pathwise convergence is concerned, the local parameter estimates at each agent are as good as the optimal centralized nonlinear least squares estimator which would require access to all the observations across all the agents at all times. In order to benchmark the performance of the proposed distributed $\mathcal{CIWNLS}$ estimator with that of the centralized nonlinear least squares estimator, the asymptotic normality of the estimate sequence is established and the asymptotic covariance of the distributed estimator is evaluated. Finally, simulation results are presented which illustrate and verify the analytical findings.

To exploit both memory locality and the full performance potential of highly tuned kernels, dense linear algebra libraries such as LAPACK commonly implement operations as blocked algorithms. However, to achieve next-to-optimal performance with such algorithms, significant tuning is required. On the other hand, recursive algorithms are virtually tuning free, and yet attain similar performance. In this paper, we first analyze and compare blocked and recursive algorithms in terms of performance, and then introduce ReLAPACK, an open-source library of recursive algorithms to seamlessly replace most of LAPACK's blocked algorithms. In many scenarios, ReLAPACK clearly outperforms reference LAPACK, and even improves upon the performance of optimizes libraries.

Bell System Technical Journal, 62: 10. December 1983 pp 2961-2992. Recursive Fixed-Order Covariance Least-Squares Algorithms. (Honig, M.L.)

2.5 player parity games combine the challenges posed by 2.5 player reachability games and the qualitative analysis of parity games. These two types of problems are best approached with different types of algorithms: strategy improvement algorithms for 2.5 player reachability games and recursive algorithms for the qualitative analysis of parity games. We present a method that - in contrast to existing techniques - tackles both aspects with the best suited approach and works exclusively on the 2.5 player game itself. The resulting technique is powerful enough to handle games with several million states.

We consider the problems of liveness verification and liveness synthesis for recursive programs. The liveness verification problem (LVP) is to decide whether a given omega-context-free language is contained in a given omega-regular language. The liveness synthesis problem (LSP) is to compute a strategy so that a given omega-context-free game, when played along the strategy, is guaranteed to derive a word in a given omega-regular language. The problems are known to be EXPTIME-complete and EXPTIME-complete, respectively. Our contributions are new algorithms with optimal time complexity. For LVP, we generalize recent lasso-finding algorithms (also known as Ramsey-based algorithms) from finite to recursive programs. For LSP, we generalize a recent summary-based algorithm from finite to infinite words. Lasso finding and summaries have proven to be efficient in a number of implementations for the finite state and finite word setting.

Recursive Monte Carlo filters, also called particle filters, are a powerful tool to perform computations in general state space models. We discuss and compare the accept--reject version with the more common sampling importance resampling version of the algorithm. In particular, we show how auxiliary variable methods and stratification can be used in the accept--reject version, and we compare different resampling techniques. In a second part, we show laws of large numbers and a central limit theorem for these Monte Carlo filters by simple induction arguments that need only weak conditions. We also show that, under stronger conditions, the required sample size is independent of the length of the observed series.

The forest-of-octrees approach to parallel adaptive mesh refinement and coarsening (AMR) has recently been demonstrated in the context of a number of large-scale PDE-based applications. Although linear octrees, which store only leaf octants, have an underlying tree structure by definition, it is not often exploited in previously published mesh-related algorithms. This is because the branches are not explicitly stored, and because the topological relationships in meshes, such as the adjacency between cells, introduce dependencies that do not respect the octree hierarchy. In this work we combine hierarchical and topological relationships between octree branches to design efficient recursive algorithms. We present three important algorithms with recursive implementations. The first is a parallel search for leaves matching any of a set of multiple search criteria. The second is a ghost layer construction algorithm that handles arbitrarily refined octrees that are not covered by previous algorithms, which require a 2:1 condition between neighboring leaves. The third is a universal mesh topology iterator. This iterator visits every cell in a domain partition, as well as every interface (face, edge and corner) between these cells. The iterator calculates the local topological information for every interface that it visits, taking into account the nonconforming interfaces that increase the complexity of describing the local topology. To demonstrate the utility of the topology iterator, we use it to compute the numbering and encoding of higher-order $C^0$ nodal basis functions. We analyze the complexity of the new recursive algorithms theoretically, and assess their performance, both in terms of single-processor efficiency and in terms of parallel scalability, demonstrating good weak and strong scaling up to 458k cores of the JUQUEEN supercomputer.

Some recursive filtering algorithms were developed for tracking ships when observations are sporadic and imprecise. Tracking with position-only observations was emphasized, but a procedure was also developed for utilizing possible independent observations of ship velocity. Two basic algorithms are considered: a Kalman filter with adaptive driving noise for generating estimates (and containment ellipses) for current and future ship positions, and a corresponding Bayesian smoother for generating estimates of past positions. The driving noise was treated as a velocity term in a continuous-time model of ship's motion. The details of these two algorithms were developed for tracking on a plane, on a sphere in geographical coordinates, and on a sphere in three-dimensional rectilinear coordinates. A FORTRAN implementation and some corresponding numerical results were developed for the planar case.

Recursive Least-Squares (RLS) algorithms are a family of widely-used techniques for adaptive parameter estimation and filtering. In many applications, a special structure in the estimation problem can be exhibited. This structure can be exploited to arrive at fast RLS algorithms. In this dissertation, we focus mainly on fast algorithms based on certain shift- invariance properties, and the particular filter structure considered will be a so-called tapped delay-line or transversal filter structure. Single-channel applications include high resolution spectrum estimation (AR modeling), noise cancellation, speech and biomedical signal processing. The multichannel algorithms (where each channel feeds a tapped delay-line) accommodate such applications as identification of systems described by difference equations with multiple polynomials (e.g. ARX and ARMAX models), adaptive minimum-variance control, fractionally-spaced and decision-feedback equalizers, multirate signal processing, image enhancement, and adaptive broadband beamforming.

A Two-Dimensional Fast Recursive Least Squares (2-D FRLS) algorithm is presented using a geometrical formulation ed on the mathematical concepts of vector space, orthogonal projection and subspace decomposition. By appropriately ordering the 2-D data, the algorithm provides an exact least-squares solution to the deterministic Normal equations. The method is further extended to the general FIR Wiener filter and to ARMA modeling. The size and shape the support region for both the MA and AR coefficients of the filter can be chosen arbitrarly. The ARMA parameter mation problem is also considered for the case when the system input is not available . Computer simulations are presented to illustrate the applications of the algorithm for 2-D parameter estimation, system identification and image coding. Keywords: Theses; Adaptive filters; VLSI (Very large scale integration); Electrical engineering.

Several time-recursive least squares algorithms have been developed in recent years. In this report a geometrical formalism is defined which utilizes a nested family of metric spaces indexed by the data time interval. This approach leads to a simplified derivation of the so-called recursive least squares lattices algorithms (recursive in time and order). In particular, it is found that the resulting structure provides a single framework which encompasses an entire family of fairly complex algorithms as well as providing geometrical insight into their behavior. (Author)

In this recursive method proposed, the gain matrix for the Kalman filter and the convariance of the state vector are computed not via the Riccati equation, but from certain other equations. These differential equations are of Chandrasekhar-type. The 'invariant imbedding' idea resulted in the reduction of the basic boundary value problem of transport theory to an equivalent initial value system, a significant computational advance. Initial value experience showed that there is some computational savings in the method and the loss of positive definiteness of the covariance matrix is less vulnerable.

In this recursive method proposed, the gain matrix for the Kalman filter and the convariance of the state vector are computed not via the Riccati equation, but from certain other equations. These differential equations are of Chandrasekhar-type. The 'invariant imbedding' idea resulted in the reduction of the basic boundary value problem of transport theory to an equivalent initial value system, a significant computational advance. Initial value experience showed that there is some computational savings in the method and the loss of positive definiteness of the covariance matrix is less vulnerable.