One of the most frequently encountered problems in
scientific computing is the manipulation and solution of large-scale,
sparse, unstructured systems of equations *Ax = b*. Here
* large* now means *O*(10^{4})
to *O*(10^{6}) unknowns or more.
The term * sparse* means most of the entries in the matrix
are zeros. By storing only the nonzero terms, the memory
requirements are often reduced from *O*(n^{2})
to *O*(n), where *n* is the number of unknowns.
Here * unstructured* means the nonzeros in the
matrix do not follow a simple pattern, such as tridiagonal or
upper Hessenberg (see
http://www.ee.ic.ac.uk/hp/staff/dmb/matrix/ for a dictionary of
some of the matrix terminology used here).
In particular, this means the matrix is
nonsymmetric - which introduces severe robustness problems
for many solution methods.
Much research in the past thirty years has targeted solving
these systems, and several sophisticated techniques and codes are available.
Often these are classified as direct or iterative methods.

All of these techniques (reordering, Markovitz pivoting, blocking parameterization) can lead to large differences in the numerical quality of solution, amount of additional storage required, and computational efficiency achieved. Choosing good settings for the parameters involved requires experimentation and extensive testing.

Iterative solvers also present a large parameter space to navigate: solver method, preconditioner method, target sparsity patterns for preconditioners, numerical cut-offs for numerical dropping, stopping tests and tolerances, etc. Furthermore, analyzing what has happened in the iterative solution of a particular problem can be difficult.

For the applications user who tries to manage all of this without expert help the situation is worse; much of the time and effort is spent in recompiling code, trying to understand adjustable parameters in the solution methods, and trying to form a coherent picture of results from a variety of output from the codes. The LSA is built to address these problems.

The LSA allows a user to

- Create a solution strategy without knowing the implementation details of the computational routines.
- Navigate a potentially large parameter space quickly, with expert advice supplied by the LSA when needed.
- Analyze and compare results from multiple solution strategies.
- Encapsulate a solution strategy as exportable Fortran/C code which can then be incorporated into an application code.

bramley@cs.indiana.edu

*
Last updated: Tue Jan 26 12:31:05 1999
*