Showing papers on "Sparse approximation published in 1990"
TL;DR: The role of elimination trees in the direct solution of large sparse linear systems is examined and its relation to sparse Cholesky factorization is discussed.
Abstract: In this paper, the role of elimination trees in the direct solution of large sparse linear systems is examined. The notion of elimination trees is described and its relation to sparse Cholesky factorization is discussed. The use of elimination trees in the various phases of direct factorization are surveyed: in reordering, sparse storage schemes, symbolic factorization, numeric factorization, and different computing environments.
519 citations
11 Aug 1990
TL;DR: It is shown that very large sparse systems can be solved efficiently by using combinations of structured Gaussian elimination and the conjugate gradient, Lanczos, and Wiedemann methods.
Abstract: Many of the fast methods for factoring integers and computing discrete logarithms require the solution of large sparse linear systems of equations over finite fields. This paper presents the results of implementations of several linear algebra algorithms. It shows that very large sparse systems can be solved efficiently by using combinations of structured Gaussian elimination and the conjugate gradient, Lanczos, and Wiedemann methods.
218 citations
TL;DR: It is shown that within this black box representation the polynomial greatest common divisor and factorization problems, as well as the problem of extracting the numerator and denominator of a rational function, can all be solved in randomPolynomial-time.
180 citations
TL;DR: The structural and computation properties of the sparse matrixes encountered in various power system network analysis problems are discussed and the inverses of the factors of sparse matrixe produced by factorization or decomposition are discussed.
Abstract: The structural and computation properties of the sparse matrixes encountered in various power system network analysis problems are discussed. Specifically, the inverses of the factors of sparse matrixes produced by factorization or decomposition are discussed. These inverse factors are themselves sparse, at least under suitable ordering and partitioning, and lend themselves to parallel operations in the direct or repeat solution phase of sparse matrix problems. Partitioning reduces the buildup of nonzero elements in the inverse factors, and parallel computation reduces the number of serial steps in the multiplications. >
89 citations
01 Dec 1990
TL;DR: A class of vector-space bases is introduced for the sparse representation of discretizations of integral operators with smooth, non-oscillatory kernel possessing a finite number of singularities in each row or column as a sparse matrix, to high precision.
Abstract: : A class of vector-space bases is introduced for the sparse representation of discretizations of integral operators. An operator with a smooth, non-oscillatory kernel possessing a finite number of singularities in each row or column is represented in these bases as a sparse matrix, to high precision. A method is presented that employs these bases for the numerical solution of second-kind integral equations in time bounded by O(nlog squared n) , where n is the number of points in the discretization. Numerical results are given which demonstrate the effectiveness of the approach, and several generalizations and applications of the method are discussed.
58 citations
01 Jul 1990
TL;DR: This paper compares the performance of three distributed schemes to compute the Cholesky factor of a large sparse symmetric positive definite matrix on a local-memory parallel processor.
Abstract: : The solution of large sparse systems of linear is an important application of parallel computers. In this paper, we give a unified presentation and compare the performance of three distributed schemes to compute the Cholesky factor of a large sparse symmetric positive definite matrix on a local-memory parallel processor. (kr)
51 citations
TL;DR: A new algorithm for the computation of a pseudoperipheral node of a graph that accesses the adjacency structure of the sparse matrix in a regular pattern is presented and the application of this algorithm to reordering algorithms for the solution of sparse linear systems is discussed.
Abstract: A new algorithm for the computation of a pseudoperipheral node of a graph is presented, and the application of this algorithm to reordering algorithms for the solution of sparse linear systems is discussed. Numerical tests on large sparse matrix problems show the efficiency of the new algorithm. When used for some of the reordering algorithms for reducing the profile and bandwidth of a sparse matrix, the results obtained with the pseudoperipheral nodes of the new algorithm are comparable to the results obtained with the pseudoperipheral nodes produced by the SPARSPAK version of the Gibbs—Poole—Stockmeyer algorithm. The advantage of the new algorithm is that it accesses the adjacency structure of the sparse matrix in a regular pattern. Thus this algorithm is much more suitable both for a parallel and for an out-of-core implementation of the ordering phase for sparse matrix problems.
31 citations
22 Oct 1990
TL;DR: The authors present the first algorithm for the (black box) interpolation of t-sparse, n-variate, rational functions without knowing bounds on exponents of their sparse representation, with the number of queries independent of exponents.
Abstract: The authors present the first algorithm for the (black box) interpolation of t-sparse, n-variate, rational functions without knowing bounds on exponents of their sparse representation, with the number of queries independent of exponents. In fact, the algorithm uses O(nt/sup t/) queries to the black box, and it can be implemented for a fixed t in a polynomially bounded storage (or polynomial parallel time). >
27 citations
TL;DR: An open architecture software environment for handling sparse matrices and interchanging sparse matrix data, and a prototype implementation of the Sparse Matrix Manipulation System, which is to be applied to a comparative study of linear least squares methods.
Abstract: An open architecture software environment for handling sparse matrices and interchanging sparse matrix data is proposed. The proposed educational and research environment includes tools for the visualization of sparse matrices. A prototype implementation of these ideas called the Sparse Matrix Manipulation System is described. Two applications of these ideas are illustrated. The first application is to a comparative study of linear least squares methods, the second to the graphic description of the properties of partitioned sparse A−1 methods. The proposed system is built around three concepts: matrices, permutation vectors and partition vectors. Each concept is implemented as a stream of ASCII data. These streams are operated upon by filters (commands that accept data from standard input and direct output to standard output). Examples of commands include: permutations, addition of fills, factorization, computation of condition number and many others. Other commands generate sparse matrices and display to...
24 citations
Book•
01 Oct 1990
TL;DR: A novel way of solving systems of linear equations with sparse coefficient matrices using iterative methods on a VLSI array that yields a superior time performance, greater ease of programmability and an area efficient design is proposed.
Abstract: Abstract We propose a novel way of solving systems of linear equations with sparse coefficient matrices using iterative methods on a VLSI array. The nonzero entries of the coefficient matrix are mapped onto a processor array of size √e × √e, where e is the number of nonzero elements, n is the number of equations and e ⩾ n. The data transport problem that arises because of this mapping is solved using an efficient routing technique. Preprocessing is carried out on the iteration matrix of the system to compute the routing control-words that are used in the data transfer. This results in O(√e) time for each iteration of the method, with a small constant factor. As compared to existing VLSI methods for solving the problem, the proposed method yields a superior time performance, greater ease of programmability and an area efficient design. We also develop a second implementation of our algorithm that uses a slightly higher number of communication steps, but reduces the number of arithmetic operations to O(log e). The latter algorithm is suitable for many other architectures as well. The algorithm can be implemented in O(log e) time using e processors on a hypercube, shuffle-exchange, and cube-connected-cycles.
01 Jun 1990
TL;DR: A package is proposed to evaluate the performance of supercomputers on sparse computations, but also to analyze the machine-algorithm interaction.
Abstract: As the diversity of novel architectures expands rapidly there is a growing interest in studying the behavior of these architectures for computations arising in different applications There has been significant efforts in evaluating the performance of supercomputers on typical dense computations, and several packages for this purpose have been developed, such as the Linpack benchmark, the Lawrence Livermore Loops, and the Los Alamos Kernels On the other hand there has been little effort put into evaluating the performance of these architectures on the more complicated and perhaps more important sparse computations In this paper a package is proposed to fill this gap Its goal is not only to evaluate the performance of supercomputers on sparse computations, but also to analyze the machine-algorithm interaction
TL;DR: A new type of storage, by sparse diagonals, has been defined, which still exhibits long vectors, with performances as good as previously, but it is also well-suited to symmetric matrices.
Abstract: An important kernel of scientific software is the multiplication of a sparse matrix by a vector. The efficiency of the algorithm on a vector computer depends on the storage scheme. With storage by rows, performances are limited in general by the small vector length. Therefore a storage by so-called generalized columns has been designed, which provides long vectors and consequent good performance. However, it is not suitable for the symmetric case. A new type of storage, by sparse diagonals, has thus been defined. It still exhibits long vectors, with performances as good as previously, but it is also well-suited to symmetric matrices. Results on a CRAY 2, with various sparse matrices, compare the three algorithms and show the efficiency of the storage by sparse diagonals.
13 May 1990
TL;DR: A segmentation technique for very sparse surfaces is described, which models the surfaces with reproducing kernel-based splines which can be shown to solve a regularized surface reconstruction problem.
Abstract: A segmentation technique for very sparse surfaces is described. It is based on minimizing the energy of the surfaces in the scene. While it could be used in almost any system as part of surface reconstruction/model recovery, the algorithm is designed to be usable when the depth information is scattered and very sparse, as is generally the case with depth generated by stereo algorithms. Results from a sequential algorithm are presented, and a working prototype that executes on the massively parallel Connection Machine is discussed. The technique presented models the surfaces with reproducing kernel-based splines which can be shown to solve a regularized surface reconstruction problem. From the functional form of these splines the authors derive computable upper and lower bounds on the energy of a surface over a given finite region. The computation of the spline, and the corresponding surface representation are quite efficient for very sparse data. >
01 May 1990
TL;DR: In this paper, an efficient approach for solving sparse linear systems using direct methods on a shared-memory vector multiprocessor computer is described, where parallelism is accomplished by using a nested bordered block diagonal matrix partitioning technique.
Abstract: An efficient approach is described for solving sparse linear systems using direct methods on a shared-memory vector multiprocessor computer. Parallelism is accomplished by using a nested bordered block diagonal matrix partitioning technique. A nested block structure is used to represent the sparse matrix, making possible the use of vectorization to achieve high performance. This approach is suitable for many applications that require the repeated direct solution of sparse linear systems with identical matrix structure, such as circuit simulation. The approach has been implemented in a program that runs on an ALLIANT FX/8 vector multiprocessor with shared memory. The performance of the program is described. >
01 Jan 1990
TL;DR: The performance data on the NCUBE are reported which provide the guidance for blending algorithm components to achieve high performance and for creating new, efficient POE solvers.
Abstract: A complete PDE sparse matrix solver consists of several components. Its overall performance strongly depends on their mutual interactions and the effect of application properties, especially when exploiting the parallelism of a distributed memory, message passing multiprocessor. This paper systematically investigates various aspects of the structure and performance of direct methods for solving sparse, nonsymmetric linear systems from PDE applications on hypercube machines. a geometric approach is. used to construct and test these POE solvers. The performance data on the NCUBE are reported which provide the guidance for blending algorithm components to achieve high performance and for creating new, efficient POE solvers. IWork supported in part by National Science Foundation grant CCR-8619817. 2Work supported in part by lhe Air Force Office of scientific Research grant, 88-0243 and the Strategic Ddense Initiative Office contracl DAAL03-86·J(-Ol06.
01 Jul 1990
TL;DR: This paper compares the performance of three distributed schemes to compute the Cholesky factor of a large sparse symmetric positive definite matrix on a local-memory parallel processor.
Abstract: The solution of large sparse systems of linear is an important application of parallel computers. In this paper, we give a unified presentation and compare the performance of three distributed schemes to compute the Cholesky factor of a large sparse symmetric positive definite matrix on a local-memory parallel processor.
05 Apr 1990
TL;DR: Graph-theoretical properties of an adaptive fill-in strategy for the construction of sparse approximate inverses of sparse matrices and algorithms for the location of filling within each column of the approximate inverse preconditioning are described using level sets.
Abstract: Graph-theoretical properties of an adaptive fill-in strategy for the construction of sparse approximate inverses of sparse matrices are discussed. The approximate inverse is based on minimization of the Frobenius norm and lends itself naturally to a parallel implementation. General sparsity can be exploited in a straightforward fashion. Sparse-graph algorithms for the location of fill-in within each column of the approximate inverse preconditioning are described using level sets. Examples illustrating the approach are presented. Properties of the fill-in strategy for regularly structured sparsity patterns are established. >
01 May 1990
TL;DR: The Sparse Matrix Manipulation System, an environment for handling sparse matrices of all types in a flexible manner via ASCII file interfaces, is used, and two commands in this environment are ShowMatrix and ShowTree, which illustrate the pattern of nonzeroes of a sparse matrix.
Abstract: A description is given of ideas and tools that help with the visualization of sparse matrix computations. The Sparse Matrix Manipulation System, an environment for handling sparse matrices of all types in a flexible manner via ASCII file interfaces, is used. Two commands in this environment are ShowMatrix and ShowTree. The first illustrates the pattern of nonzeroes of a sparse matrix. The second illustrates dependencies among matrix elements. Other tools in the package are described, including tools for ordering, factoring and multiplying sparse matrices. This software environment is then used to study the effect of several recent ordering and partitioning algorithms for working with the sparse inverses of L and U. These new algorithms have been proposed as a means of enhancing the parallelism of sparse matrix computations. The effect of these algorithms on parallelism and fill-in is illustrated in a graphic manner. >
01 Jan 1990
TL;DR: In this paper, a sparse Gallai-Witt theorem is proved and a result of the authors (Trans. Am. Math. Soc. 309,113,137, 1988) and simplifying the proof thereof is proved.
Abstract: Generalizing a result of the authors (Trans. Am. Math. Soc. 309,113–137, 1988) and simplifying the proof thereof a sparse Gallai-Witt theorem is proved.
TL;DR: The proposed sparse vector method (ESVM) based on the node-reordering technique for a problem that requires only one factorization path reveals it to be much faster than the standard sparse vector methods (SSVM).
30 Oct 1990
TL;DR: An algorithm for computing ordering for efficiently factoring sparse symmetric, positive definite systems in parallel and an efficient reliable method for detecting the rank of a sparse matrix without column exhanges are developed.
Abstract: : The project proposal discussed two problem areas: (1) The solution of large sparse of linear equations; and (2) The solution of sparse least squares problems. We report significant progress in both of these areas and in a third area, the solution of the algebraic eigenvalue problem. The progress in solving systems of linear equations included an algorithm for computing ordering for efficiently factoring sparse symmetric, positive definite systems in parallel. We also made important progress in computing the ordering itself in parallel. Other progress included a method for handling singular blocks in a one-way dissection ordering and an error analysis of Gaussian elimination in unnormalized arithmetic. For linear least squares problems we developed an efficient reliable method for detecting the rank of a sparse matrix without column exhanges. The method used a static data structure. We also analyzed and compared methods for computing sparse and dense QR factorizations on message passing architectures. On the algebraic eigenvalue problem, we participated in resolving long standing open questions on relative perturbation bounds on certain diagonally dominant eigenvalue problems. (KR)
01 Jan 1990
TL;DR: A special extended system is introduced for simple bifurcation problems to approximate its nonsingular solutions with a simplified Newton-like method which is related to the modifications of Newton’s method for the singular problems.
Abstract: A special extended system is introduced for simple bifurcation problems. The block structure of this system allows us to approximate its nonsingular solutions with a simplified Newton-like method which is related to the modifications of Newton’s method for the singular problems. Rank-1 corrections are discussed for large sparse problems to reduce the computational cost.
01 Jan 1990
TL;DR: This report assumes the reader is familiar with the general approach of parallel sparse and it provides detailed information on three aspects of PARALLEL SPARSE: the data structures used to represent the mamx, the modifications in eliminating unknowns and the dependencies between processors.
Abstract: PARALLEL SPARSE is an algorithm for the direct solution of general sparse linear systems using Gauss elimination. It is designed for distributed memory machines and has been implemented on the NCUBE-7, a hypercube machine with 128 processors. The algorithm is intended to be particularly efficient for linear systems arising from solving partial differential equations using domain decomposition with a nested dissection ordering. PARALLEL SPARSE is part of the Parallel ELLPACK system. This report assumes the reader is familiar with the general approach of parallel sparse and it provides detailed information on three aspects of PARALLEL SPARSE: 1. The data structures used to represent the mamx, the modifications in eliminating unknowns and the dependencies between processors. 2. The data structures that relate the assignment of actual hypercube processors to computational processes. 3. The organization of the codes that run on the hypercube host and on the hypercube nodes: Dynamic data structures are used unlike most other sparse mamx codes. These are more complex but provide better flexibility to handle PDE problems. Much of the complexity seen here compared to traditional other codes is due to the fact that we handle general matrices instead of only symrnemc ones. * Work supported in part by National Science Foundation grant CCR-8619817. ** Work supported in part by the Air Force Office of Scientific Research grant. 88-0243 and the Suategic Defense Initiative Office conuact DAAL03-86-K-0106. i