Solving Large Sparse Linear Systems Over Finite Fields

The Lanczos algorithm is among the most frequently used iterative techniques for computing a few dominant eigenvalues of a large sparse non-symmetric matrix. At the same time, it serves as a building block within biconjugate gradient (BiCG) and quasi-minimal residual (QMR) methods for solving large sparse non-symmetric systems of linear equations. It is well known that, when implemented on distributed-memory computers with a huge number of processes, the synchronization time spent on computing dot products increasingly limits the parallel scalability. Therefore, we propose synchronization-reducing variants of the Lanczos, as well as BiCG and QMR methods, in an attempt to mitigate these negative performance effects. These so-called s-step algorithms are based on grouping dot products for joint execution and replacing time-consuming matrix operations by efficient vector recurrences. The purpose of this paper is to provide a rigorous derivation of the recurrences for the s-step Lanczos algorithm, introduce s-step BiCG and QMR variants, and compare the parallel performance of these new s-step versions with previous algorithms.

Simultaneous analysis of large INTEGRAL/SPI11Based on observations with INTEGRAL, an ESA project with instruments and science data center funded by ESA member states (especially the PI countries: Denmark, France, Germany, Italy, Spain, and Switzerland), Czech Republic and Poland with participation of Russia and the USA. datasets: Optimizing the computation of the solution and its variance using sparse matrix algorithms

We compare the relative performances of two iterative schemes based on projection techniques for the solution of large sparse nonsymmetric systems of linear equations, encountered in the numerical solution of partial differential equations. The Block–Symmetric Successive Over‐Relaxation (Block‐SSOR) method and the Symmetric–Kaczmarz method are derived from the simplest of projection methods, that is, the Kaczmarz method. These methods are then accelerated using the conjugate gradient method, in order to improve their convergence. We study their behavior on various test problems and comment on the conditions under which one method would be better than the other. We show that while the conjugate‐gradient‐accelerated Block‐SSOR method is more amenable to implementation on vector and parallel computers, the conjugate‐gradient accelerated Symmetric–Kaczmarz method provides a viable alternative for use on a scalar machine.

In recent years a number of solvers for the direct solution of large sparse symmetric linear systems of equations have been developed. These include solvers that are designed for the solution of positive definite systems as well as those that are principally intended for solving indefinite problems. In this study, we use performance profiles as a tool for evaluating and comparing the performance of serial sparse direct solvers on an extensive set of symmetric test problems taken from a range of practical applications.

Many applications in science and engineering give rise to large sparse linear systems of equations that need to be solved as efficiently as possible. As the size of the problems of interest increases, it can become necessary to consider exploiting multiprocessors to solve these systems. We report on the design and development of parallel frontal solvers for the numerical solution of large sparse linear systems. Three codes have been developed for the mathematical software library HSL (www.cse.clrc.ac.uk/Activity/HSL). The first is for unsymmetric finite-element problems; the second is for symmetric positive definite finite-element problems; and the third is for highly unsymmetric linear systems such as those that arise in chemical process engineering. In each case, the problem is subdivided into a small number of loosely connected subproblems and a frontal method is then applied to each of the subproblems in parallel. We discuss how our software is designed to achieve the goals of portability, ease of use, efficiency, and flexibility, and illustrate the performance using problems arising from real applications.

A projection method for solving nonsymmetric linear systems on multiprocessors

If one removes some variables and equations from a large sparse system of linear equations, the resulting subsystem may have characteristics which render it amenable to rapid and economic solution. There are then various methods for obtaining a solution to the original system. This class of techniques is often termed ‘tearing’ and has been widely used in several application areas including linear programming, chem¬ ical engineering, and economic modelling.

P aS tiX: a high-performance parallel direct solver for sparse symmetric positive definite systems

Data Flow Analysis of Orthogonal Properties on the Conjugate Gradient and the Lanczos Algorithm

In this paper, a class of parallel blockwise matrix multisplitting block relaxation methods, including the blockwise matrix multisplitting block symmetric accelerated overrelaxation method, the blockwise matrix multisplitting block unsymmetric and symmetric successive overrelaxation methods and the blockwise matrix multisplitting block unsymmetric and symmetric Gauss-Seidel methods, etc., is established for the large sparse block system of linear equations, and its convergence theory is set up thorouthly when the coefficient matrix is a block H-matrix. Also, the new methods are further extended by relaxing different block elements of the iterations with different relaxation parameters and, therefore, general frameworks of parallel blockwise matrix multisplitting block relaxation methods for solving the block system of linear equations are naturally obtained.

This paper proposes an image fusion algorithm based on a sparse linear equation system, which uses local extreme of high resolution image and intensity of multi-spectral image to construct the system. Based on this sparse system, the multi-scale image decomposition algorithm can be implemented. This algorithm extracts the details of the high-resolution image and integrates with the multi-spectral information to derive the fused image.

This paper describes and tests a parallel implementation of a factorized approximate inverse preconditioner (FSAI) to accelerate iterative linear system solvers. Such a preconditioner reveals an efficient accelerator of both Conjugate gradient and BiCGstab iterative methods in the parallel solution of large linear systems arising from the discretization of the advection-diffusion equation. The resulting message passing code allows the solution of large problems leading to a very cost-effective algorithm for the solution of large and sparse linear systems.

During the past few years, algorithmic improvements alone have reduced the time required for the direct solution of unsymmetric sparse systems of linear equations by almost an order of magnitude. This paper compares the performance of some well-known software packages for solving general sparse systems. In particular, it demonstrates the consistently high level of performance achieved by WSMP---the most recent of such solvers. It compares the various algorithmic components of these solvers and discusses their impact on solver performance. Our experiments show that the algorithmic choices made in WSMP enable it to run more than twice as fast as the best among similar solvers and that WSMP can factor some of the largest sparse matrices available from real applications in only a few seconds on a 4-CPU workstation. Thus, the combination of advances in hardware and algorithms makes it possible to solve those general sparse linear systems quickly and easily that might have been considered too large until recently.

This paper presents a novel hardware solution for solving sparse matrices using emulation technology. The proposed solution introduces a bio-inspired technique, which is Genetic Algorithm (GA) to solve the sparse system of linear equations (SLEs). The proposed solution can be used with any physical system that can be modeled as SLEs. Computations involved in Finite Element Method (FEM) consume too much time, which affects the final time-to-market value. Profiling shows that the most time-consuming part in the simulation process is the solver part which is responsible for solving the resultant SLEs generated from the FEM. The total number of equations may reach thousands or millions of linear equations. Hardware implementation of GA and making a good use of parallelism in implementing the architecture accelerate the time taken by the solver part. Solving the system by classical numerical methods, such as conjugate gradient (CG) implemented in software is performed sequentially, here the architecture allows the parallelism in performing GA operators, such as selection, crossover, and mutation. The parallelism in the proposed architecture is the superiority point which we rely on. The results show that our proposed method to solve the SLEs outperforms the classical CG software implementation on run time and number of equations.

During my visit to LLNL during the summer of 2010, I worked on algebraic multilevel solvers for large sparse systems of linear equations arising from discretizations of partial differential equations. The particular solver of interest is based on ILU decomposition. The setup phase for this AMG solve is just the single ILU decomposition, and its corresponding error matrix. Because the ILU uses a minimum degree or similar sparse matrix ordering, most of the fill-in, and hence most of the error, is concentrated in the lower right corner of the factored matrix. All of the major multigrid components - the smoother, the coarse level correction matrices, and the fine-to-coarse and coarse-to-fine rectangular transfer matrices, are defined in terms of various blocks of the ILU factorization. Although such a strategy is not likely to be optimal in terms of convergence properties, it has a relatively low setup cost, and therefore is useful in situations where setup costs for more traditional AMG approaches cannot be amortized over the solution of many linear systems using the same matrix. Such a situation arises in adaptive methods, where often just one linear system is solved at each step of an adaptive feedback loop, or in solving nonlinear equations by approximate Newton methods, where the approximate Jacobian might change substantially from iteration to iteration. In general terms, coarse levels are defined in terms of successively smaller lower right blocks of the matrix, typically decreasing geometrically in order. The most difficult issue was the coarse grid correction matrix. The preconditioner/smoother for a given level is just the corresponding lower right blocks of the ILU factorization. The coarse level matrix itself is just the Schur complement; this matrix is not known exactly using just the ILU decomposition in the setup phase. Thus we approximate this matrix using various combinations of the preconditioning matrix and the error matrix. During my visit, several approximations of this type were implemented and tested. While some improved the convergence rate of the overall method, these gains had to be balanced against the additional costs involved in creating and applying these matrices. By this more stringent criterion, none of the improved approximations could be characterized as an unqualified success.