FROM NUMERICAL LINEAR ALGEBRA TO COMPILER TECHNOLOGY FOR DESIGN PATTERNS

17

[1]  R. Parsons,et al.  A++/P++ array classes for architecture independent finite difference computations , 1994 .

[2]  Ian Foster,et al.  The Grid 2 - Blueprint for a New Computing Infrastructure, Second Edition , 1998, The Grid 2, 2nd Edition.

[3]  Rajiv Gupta,et al.  Optimizing array bound checks using flow analysis , 1993, LOPL.

[4]  Ulrik Pagh Schultz,et al.  Towards Automatic Specialization of Java Programs , 1999, ECOOP.

[5]  Nigel Bishop,et al.  Java gently for engineers and scientists , 2000 .

[6]  Peter Olsson,et al.  Object-Oriented Construction of Parallel PDE Solvers , 1996, SciTools.

[7]  Alex Pothen,et al.  An Object-Oriented Collection of Minimum Degree Algorithms , 1998, ISCOPE.

[8]  G. Stewart.  Introduction to matrix computations , 1973 .

[9]  Alan B. Williams,et al.  ISIS++Reference Guide (Iterative Scalable Implicit Solver in C++) Version 1.1 , 1997 .

[10]  Michael Philippsen,et al.  Complex numbers for Java , 2000 .

[11]  Anthony Skjellum,et al.  The Parallel Mathematical Libraries Project (PMLP) - A Next Generation Scalable, Sparse, Object-Oriented, Mathematical Library Suite , 1999, PPSC.

[12]  Joseph W. H. Liu.  The role of elimination trees in sparse factorization , 1990 .

[13]  Charles D. Norton.  Object-oriented programming paradigms in scientific computing , 1998 .

[14]  E. Gallopoulos,et al.  Computer as thinker/doer: problem-solving environments for computational science , 1994, IEEE Computational Science and Engineering.

[15]  Florin Dobrian,et al.  The design of sparse direct solvers using object-oriented techniques , 1999 .

[16]  John R. Gilbert,et al.  Sparse Matrices in MATLAB: Design and Implementation , 1992, SIAM J. Matrix Anal. Appl..

[17]  Geir Evensen.  JavaGrande : High performance computing with Java , 2001 .

[18]  Jeremy G. Siek,et al.  The Matrix Template Library: A Generic Programming Approach to High Performance Numerical Linear Algebra , 1998, ISCOPE.

[19]  George K. Thiruvathukal.  Java at middle age: enabling Java for computational science , 2002, Comput. Sci. Eng..

[20]  Philippe Kruchten,et al.  Architecture blueprints—the “4+1” view model of software architecture , 1995, TRI-Ada '95.

[21]  I. Duff,et al.  Direct Methods for Sparse Matrices , 1987 .

[22]  James Demmel,et al.  Templates for Linear Algebra Problems , 1995, Computer Science Today.

[23]  Charles L. Lawson,et al.  Basic Linear Algebra Subprograms for Fortran Usage , 1979, TOMS.

[24]  Mikel Luján.  Building an object oriented problem solving environment for the parallel numerical solution of PDEs , 2000, OOPSLA '00.

[25]  Ulrik Pagh Schultz,et al.  Harissa: A Hybrid Approach to Java Execution , 1999, IEEE Softw..

[26]  Michael J. Vilot,et al.  Standard template library , 1996 .

[27]  Matthew H. Austern.  Generic programming and the STL - using and extending the C++ standard template library , 1999, Addison-Wesley professional computing series.

[28]  Jeremy G. Siek,et al.  The Matrix Template Library: generic components for high-performance scientific computing , 1999, Comput. Sci. Eng..

[29]  Frank Pfenning,et al.  Eliminating array bound checking through dependent types , 1998, PLDI.

[30]  Hilding Elmqvist,et al.  Physical system modeling with Modelica , 1998 .

[31]  Alexander A. Stepanov,et al.  C++ Standard Template Library , 2000 .

[32]  Keith H. Randall,et al.  Field analysis: getting useful and low-cost interprocedural information , 2000, PLDI '00.

[33]  John Alan McDonald.  Object-oriented programming for linear algebra , 1989, OOPSLA 1989.

[34]  Aart J. C. Bik,et al.  Automatic Nonzero Structure Analysis , 1999, SIAM J. Comput..

[35]  Martin Odersky,et al.  Pizza into Java: translating theory into practice , 1997, POPL '97.

[36]  Guy L. Steele,et al.  The Java Language Specification , 1996 .

[37]  Peter Fritzson,et al.  High-level Mathematical Modeling And Programming , 1995, IEEE Softw..

[38]  Michael Philippsen,et al.  Java and numerical computing , 2001, Comput. Sci. Eng..

[39]  Hans Petter Langtangen,et al.  Solving systems of partial differential equations using object-oriented programming techniques with coupled heat and fluid flow as example , 2001, TOMS.

[40]  Douglas C. Schmidt,et al.  Pattern-Oriented Software Architecture, Patterns for Concurrent and Networked Objects , 2013 .

[41]  R. Pressman.  Software Engineering: a Practioner''s approach , 1987 .

[42]  Urs Hölzle,et al.  Eliminating Virtual Function Calls in C++ Programs , 1996, ECOOP.

[43]  Jack Dongarra,et al.  LAPACK Working Note 61: An Object Oriented Design for High Performance Linear Algebra on Distributed Memory Architectures , 1993 .

[44]  Stephen J. Mellor,et al.  Object Oriented Systems Analysis: Modeling the World in Data , 1988 .

[45]  D. W. Walker,et al.  LAPACK++: a design overview of object-oriented extensions for high performance linear algebra , 1993, Supercomputing '93.

[46]  Todd L. Veldhuizen,et al.  Arrays in Blitz++ , 1998, ISCOPE.

[47]  Stephen J. Chapman.  Java for Engineers and Scientists , 1999 .

[48]  Michael A. Malcolm,et al.  Computer methods for mathematical computations , 1977 .

[49]  Michael Wolfe,et al.  Elimination of redundant array subscript range checks , 1995, PLDI '95.

[50]  Jack J. Dongarra,et al.  Software Libraries for Linear Algebra Computations on High Performance Computers , 1995, SIAM Rev..

[51]  Niklaus Wirth,et al.  Algorithms + Data Structures = Programs , 1976 .

[52]  Roldan Pozo,et al.  Template Numerical Toolkit for Linear Algebra: High Performance Programming With C++ and the Standard Template Library , 1997, Int. J. High Perform. Comput. Appl..

[53]  Jean-Marc Jézéquel,et al.  An object-oriented framework for supercomputing , 1996, J. Syst. Softw..

[54]  G. Arango.  Domain analysis: from art form to engineering discipline , 1989, IWSSD '89.

[55]  Seth D. Bergmann,et al.  Compilers , 1973, CSC '73.

[56]  Jong-Deok Choi,et al.  Optimizing Java Programs in the Presence of Exceptions , 2000, ECOOP.

[57]  Dirk Grunwald,et al.  Reducing indirect function call overhead in C++ programs , 1994, POPL '94.

[58]  Mei Han An,et al.  accuracy and stability of numerical algorithms , 1991 .

[59]  Benno Geißelmann,et al.  Program Design by Informal English Descriptions , 2001 .

[60]  F. R. Gantmakher.  The Theory of Matrices , 1984 .

[61]  Todd L. Veldhuizen,et al.  Expression templates , 1996 .

[62]  Fred G. Gustavson,et al.  A recursive formulation of Cholesky factorization of a matrix in packed storage , 2001, TOMS.

[63]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[64]  Murray Silverstein,et al.  A Pattern Language , 1977 .

[65]  Fred G. Gustavson,et al.  Recursion leads to automatic variable blocking for dense linear-algebra algorithms , 1997, IBM J. Res. Dev..

[66]  Hans Petter Langtangen,et al.  Object-oriented design of preconditioned iterative methods in diffpack , 1997, TOMS.

[67]  Samuel P. Midkiff,et al.  Efficient support for complex numbers in Java , 1999, JAVA '99.

[68]  William Gropp,et al.  Efficient Management of Parallelism in Object-Oriented Numerical Software Libraries , 1997, SciTools.

[69]  C. van Reeuwijk,et al.  Spar: a set of extensions Java for scientific computation , 2001, JGI '01.

[70]  Edith Cohen,et al.  Structure Prediction and Computation of Sparse Matrix Products , 1998, J. Comb. Optim..

[71]  Ken Kennedy,et al.  JaMake: A Java Compiler Environment , 2001, LSSC.

[72]  Urs Hölzle,et al.  Removing unnecessary synchronization in Java , 1999, OOPSLA '99.

[73]  Roger S. Pressman,et al.  Software Engineering: A Practitioner's Approach , 1982 .

[74]  Samuel P. Midkiff,et al.  A Standard Java Array Package for Technical Computing , 1999, PPSC.

[75]  Iain S. Duff,et al.  MA28 --- A set of Fortran subroutines for sparse unsymmetric linear equations , 1980 .

[76]  Jack J. Dongarra,et al.  An extended set of FORTRAN basic linear algebra subprograms , 1988, TOMS.

[77]  J. Demmel,et al.  Sun Microsystems , 1996 .

[78]  Peter Fritzson,et al.  Variant Handling, Inheritance and Composition in the ObjectMath Computer Algebra Environment , 1993, DISCO.

[79]  Ronald F. Boisvert,et al.  Developing numerical libraries in Java , 1998, Concurr. Pract. Exp..

[80]  David Grove,et al.  Profile-guided receiver class prediction , 1995, OOPSLA.

[81]  Aart J. C. Bik,et al.  Compiler support for sparse matrix computations , 1996 .

[82]  Stephen N. Freund,et al.  Adding type parameterization to the Java language , 1997, OOPSLA '97.

[83]  William W. Symes,et al.  C++ classes for linking optimization with complex simulations , 1999, TOMS.

[84]  David Detlefs,et al.  Inlining of Virtual Methods , 1999, ECOOP.

[85]  Aneesh Aggarwal,et al.  Related field analysis , 2001, PLDI '01.

[86]  Mikel Luján,et al.  Elimination of Java array bounds checks in the presence of indirection , 2002, JGI '02.

[87]  Steve Karmesin,et al.  Array Design and Expression Evaluation in POOMA II , 1998, ISCOPE.

[88]  B. S. Garbow,et al.  Matrix Eigensystem Routines — EISPACK Guide , 1974, Lecture Notes in Computer Science.

[89]  Douglas C. Schmidt,et al.  Patterns for concurrent and networked objects , 2000 .

[90]  Mary E. Mace.  Memory storage patterns in parallel processing , 1987, The Kluwer international series in engineering and computer science.

[91]  Samuel P. Midkiff,et al.  The NINJA project , 2001, CACM.

[92]  Ivar Jacobson,et al.  Object-oriented software engineering - a use case driven approach , 1993, TOOLS.

[93]  Jack J. Dongarra,et al.  Automatic translation of Fortran to JVM bytecode , 2001, JGI '01.

[94]  Peter Fritzson,et al.  Modelica - A Unified Object-Oriented Language for System Modelling and Simulation , 1998, ECOOP.

[95]  Alan George,et al.  The Design of a User Interface for a Sparse Matrix Package , 1979, TOMS.

[96]  Jarmo Rantakokko.  Object-oriented software tools for composite-grid methods on parallel computers , 1995 .

[97]  이승일.  Efficient Java exception handling in Just-in-Time compilation , 2000 .

[98]  Aart J. C. Bik,et al.  A Note on Native Level 1 BLAS in Java , 1997, Concurrency Practice and Experience.

[99]  Jeremy G. Siek,et al.  The generic graph component library , 1999, OOPSLA '99.

[100]  Doug Lea,et al.  Concurrent programming in Java - design principles and patterns , 1996, Java series.

[101]  Johnathan M. Asuru.  Optimization of array subscript range checks , 1992, LOPL.

[102]  David Grove,et al.  Optimization of Object-Oriented Programs Using Static Class Hierarchy Analysis , 1995, ECOOP.

[103]  Rajiv Gupta.  A fresh look at optimizing array bound checking , 1990, PLDI '90.

[104]  Gene H. Golub,et al.  Matrix computations , 1983 .

[105]  Toshiaki Yasue,et al.  A study of devirtualization techniques for a Java Just-In-Time compiler , 2000, OOPSLA '00.

[106]  Keshav Pingali,et al.  Next-generation generic programming and its application to sparse matrix computations , 2000, ICS '00.

[107]  Paul Vinson Stodghill,et al.  A Relational Approach to the Automatic Generation of Sequential Sparse matrix Codes , 1997 .

[108]  Jack J. Dongarra,et al.  Matrix Eigensystem Routines — EISPACK Guide Extension , 1977, Lecture Notes in Computer Science.

[109]  Norihisa Suzuki,et al.  Implementation of an array bound checker , 1977, POPL.

[110]  Krister Åhlander.  An object-oriented approach to construct PDE solvers , 1996 .

[111]  Ken Kennedy,et al.  The cost of being object-oriented: A preliminary study , 1999, Sci. Program..

[112]  Grady Booch,et al.  Object-Oriented Analysis and Design with Applications , 1990 .

[113]  Keshav Pingali,et al.  A Relational Approach to the Compilation of Sparse Matrix Programs , 1997, Euro-Par.

[114]  Jack J. Dongarra,et al.  Algorithm 679: A set of level 3 basic linear algebra subprograms: model implementation and test programs , 1990, TOMS.

[115]  Florin Dobrian,et al.  Object-Oriented Design for Sparse Direct Solvers , 1998, ISCOPE.

[116]  J. Pasciak,et al.  Computer solution of large sparse positive definite systems , 1982 .

[117]  Ulrik Pagh Schultz,et al.  Specialization patterns , 2000, Proceedings ASE 2000. Fifteenth IEEE International Conference on Automated Software Engineering.

[118]  Eric Noulard,et al.  Object Oriented Design for Reusable Parallel Linear Algebra Software , 1999, Euro-Par.

[119]  Yousef Saad,et al.  Iterative methods for sparse linear systems , 2003 .

[120]  강문설.  [서평]「The Unified Modeling Language User Guide」 , 1999 .

[121]  Yves Robert,et al.  Dense linear algebra kernels on heterogeneous platforms: Redistribution issues , 2002, Parallel Comput..

[122]  Samuel P. Midkiff,et al.  From Flop to MegaFlops: Java for Technical Computing , 1998, LCPC.

[123]  Tony Hoare,et al.  Notes on Data Structuring , 1972 .

[124]  Edmond Chow,et al.  An object-oriented framework for block preconditioning , 1998, TOMS.

[125]  Jean-Marc Jézéquel,et al.  Polymorphic Matrices in Paladin , 1995, OBPDC.

[126]  Bret A Marsolf,et al.  Techniques for the Interactive Development of Numerical Linear Algebra Libraries for Scientific Computation , 1997 .

[127]  Fred G. Gustavson,et al.  LAWRA: Linear Algebra with Recursive Algorithms , 2000, PARA.

[128]  Daniel J. Quinlan,et al.  OVERTURE: An Object-Oriented Software System for Solving Partial Differential Equations in Serial and Parallel Environments , 1997, PPSC.

[129]  José E. Moreira,et al.  Design and evaluation of a linear algebra package for Java , 2000, JAVA '00.

[130]  Samuel P. Midkiff,et al.  Quicksilver: a quasi-static compiler for Java , 2000, OOPSLA '00.

[131]  Laurie J. Hendren,et al.  Practical virtual method call resolution for Java , 2000, OOPSLA '00.

[132]  Boleslaw K. Szymanski,et al.  How to Express C++ Concepts in Fortran90 , 1997, Sci. Program..

[133]  Frank Yellin,et al.  The Java Virtual Machine Specification , 1996 .

[134]  N. Sloane.  A Handbook Of Integer Sequences , 1973 .

[135]  Richard F. Barrett,et al.  Matrix Market: a web resource for test matrix collections , 1996, Quality of Numerical Software.

[136]  Jack J. Dongarra,et al.  A set of level 3 basic linear algebra subprograms , 1990, TOMS.

[137]  Wie-Ngan Chin,et al.  A reexamination of “Optimization of array subscript range checks” , 1995, TOPL.

[138]  Ken Kennedy,et al.  Prospects for Scientific Computing in Polymorphic, Object-Oriented Style , 1999, PPSC.

[139]  Hans Petter Langtangen,et al.  Computational Partial Differential Equations - Numerical Methods and Diffpack Programming , 1999, Lecture Notes in Computational Science and Engineering.

[140]  Samuel P. Midkiff,et al.  Optimizing Array Reference Checking in Java Programs , 1998, IBM Syst. J..

[141]  Duane S. Boning,et al.  A Matrix Math Library for Java , 1997, Concurr. Pract. Exp..

[142]  Jack Dongarra,et al.  LINPACK Users' Guide , 1987 .

[143]  Denis Caromel,et al.  Computing in Object-Oriented Parallel Environments , 2002, Lecture Notes in Computer Science.

[144]  D. Quinlan,et al.  Overture: an objectoriented framework for solving partial differential equations on overlapping grids , 1998 .

[145]  Sathish S. Vadhiyar,et al.  Numerical Libraries and the Grid , 2001, Int. J. High Perform. Comput. Appl..

[146]  Martin C. Rinard,et al.  Symbolic bounds analysis of pointers, array indices, and accessed memory regions , 2000, PLDI '00.

[147]  Vladimir Getov,et al.  Multi-language programming environments for high performance Java computing , 1999, Sci. Program..

[148]  Yves Robert,et al.  Matrix Multiplication on Heterogeneous Platforms , 2001, IEEE Trans. Parallel Distributed Syst..

[149]  Ami Marowka,et al.  The GRID: Blueprint for a New Computing Infrastructure , 2000, Parallel Distributed Comput. Pract..

[150]  Jack J. Dongarra,et al.  JLAPACK-compiling LAPACK Fortran to Java , 1999, Sci. Program..

[151]  Jong-Deok Choi,et al.  Escape analysis for Java , 1999, OOPSLA '99.

[152]  James R. Rice,et al.  From Scientific Software Libraries to Problem Solving Environments John R. Rice , 1996 .

[153]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[154]  Mikel Luján,et al.  OoLaLa: Transformations for Implementations of Matrix Operations at High Abstraction Levels , 2002 .

[155]  O. Axelsson.  Iterative solution methods , 1995 .

[156]  Paul F. Dubois.  Object technology for scientific computing: object-oriented numerical software in Eiffel and C , 1996 .

[157]  Paul Walton Purdom,et al.  The Analysis of Algorithms , 1995 .

[158]  Stanley C. Eisenstat,et al.  Yale sparse matrix package I: The symmetric codes , 1982 .

[159]  Vivek Sarkar,et al.  ABCD: eliminating array bounds checks on demand , 2000, PLDI '00.

[160]  Matteo Frigo.  A Fast Fourier Transform Compiler , 1999, PLDI.

[161]  Mikel Luján,et al.  OoLALA: an object oriented analysis and design of numerical linear algebra , 2000, OOPSLA '00.

[162]  David J. Lilja,et al.  Techniques for obtaining high performance in Java programs , 2000, CSUR.

[163]  Peter Fritzson,et al.  Industrial application of object-oriented mathematical modeling and computer algebra in mechanical analysis , 1992 .

[164]  Satoshi Matsuoka,et al.  AJaPACK: experiments in performance portable parallel Java numerical libraries , 2000, JAVA '00.

[165]  Yves Robert,et al.  Algorithmic Issues on Heterogeneous Computing Platforms , 1999, Parallel Process. Lett..

[166]  Sadashiva S. Godbole,et al.  On Efficient Computation of Matrix Chain Products , 1973, IEEE Transactions on Computers.

[167]  Ken Kennedy,et al.  Blocking Linear Algebra Codes for Memory Hierarchies , 1989, PPSC.

[168]  Cleve Ashcraft,et al.  SPOOLES: An Object-Oriented Sparse Matrix Library , 1999, PPSC.

[169]  Bruno Blanchet,et al.  Escape analysis for object-oriented languages: application to Java , 1999, OOPSLA '99.

[170]  Charles L. Lawson,et al.  Algorithm 539: Basic Linear Algebra Subprograms for Fortran Usage [F1] , 1979, TOMS.

[171]  Boleslaw K. Szymanski,et al.  Expressing object-oriented concepts in Fortran 90 , 1997, FORF.

[172]  Michael Thuné,et al.  Object-Oriented Software Tools for the Construction of Preconditioners , 1997, Sci. Program..

[173]  Boleslaw K. Szymanski,et al.  How to support inheritance and run-time polymorphism in Fortran 90 , 1998 .

[174]  Mary F. Fernández,et al.  Simple and effective link-time optimization of Modula-3 programs , 1995, PLDI '95.

[175]  J. Gilbert.  Predicting Structure in Sparse Matrix Computations , 1994 .

[176]  Barton P. Miller,et al.  Safety checking of machine code , 2000, PLDI '00.

[177]  Alan George,et al.  An Object-Oriented Approach to the Design of a User Interface for a Sparse Matrix Package , 1999, SIAM J. Matrix Anal. Appl..

[178]  Peter Fritzson,et al.  Generating Parallel Code from Equations in the ObjectMath Programming Environments , 1993, ACPC.

[179]  Martin C. Rinard,et al.  Compositional pointer and escape analysis for Java programs , 1999, OOPSLA '99.

[180]  George C. Necula,et al.  The design and implementation of a certifying compiler , 1998, PLDI.

[181]  Jeremy G. Siek,et al.  Generic Programming for High Performance Numerical Linear Algebra , 2004 .

[182]  Siddhartha Chatterjee,et al.  An Evaluation of Java for Numerical Computing , 1998, ISCOPE.

[183]  J. Mark Bull,et al.  Benchmarking Java against C and Fortran for scientific applications , 2001, JGI '01.

[184]  Aart J. C. Bik,et al.  Automatic Data Structure Selection and Transformation for Sparse Matrix Computations , 1996, IEEE Trans. Parallel Distributed Syst..

[185]  Henk J. Sips,et al.  Spar: a set of extensions to Java for scientific computation , 2003, Concurr. Comput. Pract. Exp..

[186]  David F. Bacon,et al.  Compiler transformations for high-performance computing , 1994, CSUR.

[187]  John R. Rice.  Scalable Scientific Software Libraries and Problem Solving Environments , 1996 .

[188]  Aart J. C. Bik,et al.  The automatic generation of sparse primitives , 1998, TOMS.

[189]  Robert L. Johnston,et al.  Numerical methods: A software approach , 1982 .

[190]  Jack Dongarra,et al.  Sparse Matrix Libraries in C++ for High Performance Architectures , 1997 .

[191]  John Glossner,et al.  Java signal processing: FFTs with bytecodes , 1998 .

[192]  Jeremy G. Siek,et al.  Generic Graph Algorithms for Sparse Matrix Ordering , 1999, ISCOPE.

[193]  Steven G. Johnson,et al.  FFTW: an adaptive software architecture for the FFT , 1998, Proceedings of the 1998 IEEE International Conference on Acoustics, Speech and Signal Processing, ICASSP '98 (Cat. No.98CH36181).

[194]  David F. Bacon,et al.  Fast static analysis of C++ virtual function calls , 1996, OOPSLA '96.

[195]  Anthony Skjellum,et al.  The Parallel Mathematical Libraries Project (PMLP): Overview, Design Innovations, and Preliminary Results , 1999, PaCT.

[196]  Charles Blilie,et al.  Patterns in scientific software: an introduction , 2002, Comput. Sci. Eng..

[197]  James Crotinger,et al.  How templates enable high-performance scientific computing in C++ , 1999, Comput. Sci. Eng..

[198]  Yuefan Deng,et al.  New trends in high performance computing , 2001, Parallel Computing.

[199]  Rupak Biswas,et al.  High‐performance Java codes for computational fluid dynamics , 2003, Concurr. Comput. Pract. Exp..

[200]  Peter Fritzson,et al.  Generating parallel code from object oriented mathematical models , 1995, PPOPP '95.

[201]  Yves Robert,et al.  A Proposal for a Heterogeneous Cluster ScaLAPACK (Dense Linear Solvers) , 2001, IEEE Trans. Computers.

[202]  Geoffrey C. Fox,et al.  Java for parallel computing and as a general language for scientific and engineering simulation and modeling , 1997, Concurr. Pract. Exp..

[203]  Samuel P. Midkiff,et al.  Java programming for high-performance numerical computing , 2000, IBM Syst. J..

[204]  Crispin Cowan,et al.  Declarative specialization of object-oriented programs , 1997, OOPSLA '97.

[205]  Jack J. Dongarra,et al.  Automated empirical optimizations of software and the ATLAS project , 2001, Parallel Comput..

[206]  Bruce Eckel.  Thinking in Java , 1998 .

[207]  Richard Barrett,et al.  Templates for the Solution of Linear Systems: Building Blocks for Iterative Methods , 1994, Other Titles in Applied Mathematics.