Project: ArangoDB (App Definition and Development / Database)
File: iscope99.pdf

Generic GraphAlgorithmsforSparse MatrixOrdering
/?
Lie-QuanLee JeremyG.Siek AndrewLumsdaine
Laboratory for ScientiﬁcComputing, Department of Computer Science and Engineering,
University of NotreDame, Notre Dame, IN 46556,fllee1,jsiek,lums g@lsc.nd.edu ,
WWWhome page: http://lsc.nd.edu/ /#18lsc
Abstract. Fill-reducing sparse matrix orderings have been a topic of active re-
search for many years. Although most such algorithms are developed and ana-
lyzed within a graph-theoretical framework, for reasons of performance, the cor-
responding implementations are typically realized with programming languagesdevoid of language features necessary to explicitly represent graph abstractions.
Recently,genericprogramminghasemergedasaprogrammingparadigmcapable
ofproviding high levelsofperformance inthepresence ofprogramming abstrac-tions. In this paper we present an implementation of the Minimum Degree or-
dering algorithm using the newly-developed Generic Graph Component Library.
Experimental comparisons show that, despite our heavy use of abstractions, ourimplementation has performance indistinguishable from that of the Fortran im-plementation.
1 Introduction
Computationswith symmetric positive deﬁnite sparse matrices are a commonand im-
portanttaskinscientiﬁccomputing.Forefﬁcientmatrixfactorizationandlinearsystem
solution,theorderingoftheequationsplaysanimportantrole.BecauseGaussianelim-
ination (without numerical pivoting) of symmetric positive deﬁnite systems is stable,
such systems can be ordered before factorization takes place based only on the struc-
tureofthesparsematrix.Unfortunately,determiningtheoptimalordering(inthesenseof minimizing ﬁll-in) is an NP-complete problem [1], so greedy heuristic algorithms
aretypicallyusedinstead.
The development of algorithms for sparse matrix ordering has been an active re-
searchtopicformanyyears.Thealgorithmsaretypicallydevelopedingraph-theoretical
terms,whilethemostwidelyusedimplementationsarecodedinFortran77.SinceFor-
tran 77 supports no abstract data types other than arrays, the graph abstractions used
to develop and describe the ordering algorithms must be discarded for the actual im-
plementation.Althoughgraphalgorithmsarewell-developedand widely-implementedin higher-level languages such as C or C++, performance concerns (which are often
paramountinscientiﬁccomputing)havecontinuedtorestrictimplementationsofsparse
matrixorderingalgorithmstoFortran.
Efforts to develop sparse matrix orderings with modern programming techniques
include [2] and [3]. These were based on an object-oriented, rather than generic, pro-
gramming paradigm and although they were well programmed, the reported perfor-
mancewas still afactorof4-5slowerthanFortran77implementations./?This work was supported by NSFgrants ASC94-22380 and CCR95-02710.2
Therecentlyintroducedprogrammingparadigmknownas genericprogramming [4,
5] has demonstratedthat abstraction and performanceare not necessarily mutually ex-clusive. One example of a graph library that incorporates the generic programming
paradigmisthe recentlydevelopedGenericGraphComponentLibrary(GGCL)[6].In
this paper we present an implementation of the minimum degree algorithm for sparse
matrix ordering using the GGCL. Although the implementation uses powerful graph
abstractions, its performance is indistinguishable from that of one of the most widelyusedFortran77codes.
Therestofthispaperisorganizedasfollows.Weprovideabriefoverviewofgeneric
programming and the Generic Graph Component Library in Sections 2 and 3. Algo-rithms for sparse matrix orderingare reviewedin Section 4 and our implementationof
theMinimumDegreealgorithmisgiveninSection5alongwithperformanceresultsin
Section6.
2 Generic Programming
Recently, genericprogramminghas emergedas a powerfulnewparadigmfor software
development,particularlyforthedevelopmentof(anduseof)componentlibraries.The
most visible (and perhaps most important) popular example of generic programmingis the celebrated Standard Template Library (STL) [7]. The fundamental principle of
generic programming is to separate algorithms from the concrete data structures on
whichtheyoperatebasedontheunderlyingabstractproblemdomainconcepts,allowingthe algorithms and data structures to freely interoperate. That is, in a generic library,
algorithms do not manipulate concrete data structures directly, but instead operate on
abstract interfaces deﬁned for entire equivalence classes of data structures. A single
generic algorithm can thus be applied to any particular data structure that conformsto
therequirementsofits equivalenceclass.
InSTL the data structuresare containers such asvectorsandlinked lists and itera-
torsformtheabstractinterfacebetween algorithms andcontainers.EachSTLalgorithm
is written in terms of the iterator interface and as a result each algorithm can operatewith any of the STL containers. In addition, many of the STL algorithms are parame-
terizednotonlyonthe typeofiteratorbeingaccessed,butonthe typeofoperationthat
isappliedduringthetraversalofacontaineraswell. Forexample,the transform()
algorithmhasaparameterfora UnaryOperator functionobject (aka“functor”).Fi-
nally,STLcontainsclassesknownas adaptors thatareusedtomodifyunderlyingclass
interfaces.
The generic programming approach to software development can provide tremen-
dous beneﬁts to such aspects of software quality as functionality, reliability, usability,maintainability, portability, and efﬁciency. The last point, efﬁciency, is of particular
(and sometimes paramount)concernin scientiﬁc applications. Performanceis often of
suchimportanceto scientiﬁcapplicationsthat otheraspectsofsoftwarequalitymaybe
deliberately sacriﬁced if nice programming abstractions and high performance cannot
be simultaneously achieved. Until quite recently, the common wisdom has been thathighlevelsof abstractionandhighlevelsof performancewere, per se, mutuallyexclu-
sive. However, beginningwith STL for general-purposeprogramming,and continuing3
withtheMatrixTemplateLibrary(MTL)[5]forbasiclinearalgebra,ithasbeenclearly
demonstratedthatabstractiondoesnotnecessarilycomeattheexpenseofperformance.Infact,MTLprovidesperformanceequivalenttothatofhighly-optimizedvendor-tuned
mathlibraries.
3 The Generic GraphComponent Library
The Generic Graph Component Library (GGCL) is a collection of high-performancegraph algorithms and data structures, written in C++ using the generic programming
style. Although the domain of graphs and graph algorithms is a natural one for the
applicationofgenericprogramming,thereareimportant(andfundamental)differences
betweenthe typesofalgorithmsanddatastructuresin STLandthetypesofalgorithmsanddatastructuresin agenericgraphlibrary.
3.1 GraphConcepts
The graph interface used by GGCL can be derived directly from the formal deﬁnition
ofagraph[8].Agraph Gisapair(V,E),whereVisaﬁnitesetand Eisabinaryrelation
onV.Viscalleda vertex set whoseelementsarecalled vertices.Eiscalledan edgeset
whose elements are called edges. An edge is an ordered or unorderedpair (u,v)where
u,v/2V.I f(u,v)is and edge in graph G, then vertex visadjacent to vertex u. Edge
(u,v)isanout-edgeofvertex uandanin-edgeofvertex v.Inadirectedgraphedgesare
orderedpairswhileina undirected graphedgesareunorderedpairs.Ina directedgraph
anedge(u,v)leavesfromthe sourcevertexutothetargetvertexv.
TodescribethegraphinterfaceofGGCLweusegenericprogrammingterminology
from the SGI STL [4]. In the parlance of the SGI STL, the set of requirements on a
template parameter for a generic algorithm or data structure is called a concept.T h e
various classes that fulﬁll the requirements of a concept are said to be modelsof the
concept. Concepts can extend other concepts, which is referred to as reﬁnement .W e
useabold sansserif fontforallconceptidentiﬁers.
The three main concepts necessary to deﬁne our graph are Graph,Vertex,a n d
Edge. Theabstractiteratorinterfaceusedby STLis notsufﬁcientlyrich to encompass
the numerous ways that graph algorithms may compute with a graph. Instead, we for-
mulate an abstract interface, based on VisitorandDecorator concepts, that serves the
same purpose for graphs that iterators do for basic containers. These two concepts are
similar in spirit to the “Gang of Four” [9] patterns of the same name, however the im-plementationtechniquesusedarebasedonstaticpolymorphismandmixins[10]instead
ofdynamicpolymorphism.Fig.1depictstheanalogybetweentheSTLandtheGGCL.
Graph:TheGraphconcept merely contains a set of vertices and a set of edges and
a tag to specify whether it is a directed graph or an undirected graph. The only
requirement is the vertex set be a model of Container and its value
typea
modelofVertex.Theedgesetmustbeamodelof Container anditsvalue type
amodelof Edge.
Vertex:TheVertexconceptprovidesaccess to the adjacent vertices, the out-edgesof
thevertexandoptionallythein-edges.4
STL AlgorithmsSTL Containers
(a) (b)Graph AlgorithmsGraph
Data Structures
Vertex, Edge,
Visitor, DecoratorIterator
Functor
Fig.1.Theanalogy between theSTLandtheGGCL.
Edge:AnEdgeisapairofvertices,oneisthe sourcevertexandtheotheristhe target
vertex. In the unorderedcase it is just assumed that the position of the sourceand
targetverticesareinterchangeable.
Decorator: As mentioned in the introduction, we would like to have a generic way
to access vertex and edge properties, such as color and weight, from within an
algorithm. The generic access method is necessary because there are many ways
in which the properties can be stored, and ways in which access to that storage isimplemented. We give the name Decorator to the concept for this generic access
method. The implementation of graph Decorator s is similar in spirit to the GoF
decoratorpattern [9]. A Decorator is very similar to a functor,or functionobject.
We use the operator[] instead of operator() since it is a better match for
thecommonlyusedgraphalgorithmnotations.
Visitor:In the same way that functionobjects are used to make STL algorithmsmore
ﬂexible,wecanusefunctor-likeobjectstomakethegraphalgorithmsmoreﬂexible.
We use the name Visitorfor this concept, since we are basically just using a tem-
plate version of the well known visitor pattern [9]. Our Visitoris somewhat more
complexthan a functionobject, since there are severalwell deﬁned entrypointsat
whichtheusermaywanttointroduceacall-back.
TheDecorator andVisitorconceptsare used in the GGCL graph algorithminterfaces
toallowformaximumﬂexibility.BelowistheprototypefortheGGCLdepthﬁrstsearchalgorithm,whichincludesparametersforbotha Decorator andaVisitorobject.There
aretwooverloadedversionsoftheinterface,oneinwhichthereisadefault ColorDec-
orator.Thedefaultdecoratoraccessesthecolorpropertydirectlyfromthegraphvertex.
This is analogous to the STL algorithms. For example, there are two overloaded ver-
sions of the lower
bound() algorithm. One uses operator< by default and the
othertakesa BinaryOperator functorargument.
template <class Graph, class Visitor>
void dfs(Graph& G, Visitor visit);
template <class Graph, class Visitor, class ColorDecorator>
void dfs(Graph& G, Visitor visit, ColorDecorator color);5
3.2 GenericGraphAlgorithms
Withtheabstractgraphinterfacedeﬁned,genericgraphalgorithmscanbewrittensolely
in termsof thegraphinterface.Thealgorithmsdonotmake anyassumptionsabouttheactualunderlyinggraphdatastructure.
TheBreadthFirstSearch(BFS)algorithm,asanexample,isshowninFig.2.Inthis
algorithm we use the expression u.out
edges() to access the Container of edges
leaving vertex u. We can then use the iterators of this Container to access each of the
edges.In thisalgorithm,the Visitoris usedto abstract the kindofoperationperformed
oneachedgeasitisdiscovered.Thealgorithmalsoinsertseachdiscoveredvertexonto
Q.Thevertexisaccessedthrough e.target vertex() .
template <class Graph, class QType, class Visitor>
void generalized_BFS(Graph& G, Graph::vertex_type s,
QType& Q, Visitor visitor)
{
typename Vertex::edgelist_type::iterator ei;
visitor.start(s);Q.push(s);
while (! Q.empty()) {
Vertex u = Q.front();Q.pop();
visitor.discover(u);
for (ei = u.out_edges().begin();
ei != u.out_edges().end(); ++ei) {
Edge e = *ei;
if (visitor.visit(e))
Q.push(e.target_vertex());
}
visitor.finish(u);
}
}
Fig.2.The generalized Breadth FirstSearch algorithm.
TheconciseimplementationofalgorithmsisenabledbythegenericityoftheGGCL
algorithms,allowingustoexploitthereusethatisinherentinthesegraphalgorithmsin
aconcretefashion.
4 Sparse Matrix Ordering
Theprocessforsolvingasparsesymmetricpositivedeﬁnitelinearsystem, Ax /= b,can
bedividedintofourstagesasfollows:
Ordering: Finda permutation Pofmatrix A,6
Symbolicfactorization: Setupa datastructureforCholeskyfactor Lof PA P
T,
Numericalfactorization: Decompose PA P
Tinto LL
T,
Triangularsystemsolution: Solve LL
TPx /= Pbfor x.
Because the choice of permutation Pwill directly determine the number of ﬁll-in ele-
ments (elements present in the non-zero structure of Lthat are not present in the non-
zero structure of A), the ordering has a signiﬁcant impact on the memory and compu-
tationalrequirementsforthelatter stages. However,ﬁndingtheoptimalorderingfor A
(in the sense of minimizing ﬁll-in) has been proven to be NP-complete [1] requiring
thatheuristicsbeusedforall butsimple(orspeciallystructured)cases.
Developingalgorithmsforhigh-qualityorderingshas beenan activeresearch topic
for many years. Most orderingalgorithmsin wide use are based on a greedy approachsuch that the orderingis chosen to minimize some quantityat each step of a simulatedn-stepsymmetricGaussianeliminationprocess.Thealgorithmsusingsuchanapproach
aretypicallydistinguishedbytheirgreedyminimizationcriteria[11].
4.1 GraphModels
In1961,Parter introducedthe graphmodelofsymmetricGaussianelimination[12].A
sequenceofeliminationgraphsrepresentasequenceofGaussianeliminationsteps.The
initial Elimination graph is the original graph for matrix A. The elimination graph of
k'sstepisobtainedbyaddingedgesbetweenadjacentverticesofthecurrenteliminated
vertextoforma clique,removingtheeliminatedvertexanditsedges.
In graph terms, the basic ordering process used by most greedy algorithms is as
follows:
1.Start:Constructundirectedgraph G
/0correspondingtomatrix A
2.Iterate:For k /=/1 /; /2 /;/:/:/: /;until G
k/= /;do:
–Chooseavertex v
kfrom G
kaccordingto somecriterion
–Eliminate v
kfrom G
ktoform G
k /+/1
The resulting ordering is the sequence of vertices f v
/0/;v
/1/;/:/:/: gselected by the algo-
rithm.
One of the most important examples of such an algorithm is the Minimum Degree
algorithm. At each step the minimum degree algorithm chooses the vertex with mini-
mumdegreein thecorrespondinggraphas v
k. Anumberofenhancementsto thebasic
minimum degree algorithm have been developed, such as the use of a quotient graphrepresentation, mass elimination, incomplete degree update, multiple elimination, and
external degree. See [13] for a historical survey of the minimum degree algorithm.
Many of these enhancements, although initially proposed for the minimum degree al-gorithm, can be applied to other greedy approaches as well. Other greedy approaches
differ from minimum degree by the choice of minimization criteria for choosing new
vertices.Forexample,to accelerateoneoftheprimarybottlenecksoftheorderingpro-
cess, theApproximate Minimum Degree (AMD) algorithm uses an estimate of the de-
gree(orexternaldegree)ofa vertex[14].The MinimumDeﬁciency classof algorithms
insteadchoosethevertexthatwouldcreatethe minimumnumberof ﬁll-inelements.A
nicecomparisonofmanyofthesedifferentapproachescanbefoundin[11].7
5 Implementation
Our GGCL-based implementation of MMD closely follows the algorithmic descrip-
tions of MMD given, e.g., in [15,13]. The implementation presently includes the en-
hancementsfor mass elimination,incomplete degreeupdate, multiple elimination,and
external degree. In addition, we use a quotient-graph representation. Some particulardetailsofourimplementationaregivenbelow.
Prototype Theprototypeforouralgorithmis
template<class Graph, class RandomAccessContainer,
class Decorator>
void mmd(Graph& G, RandomAccessContainer& Permutation,
RandomAccessContainer& InversePermutation,
Decorator SuperNodeSize, int delta = 0)
Theparametersareusedinthefollowingway.
G(input/output) is the graph representing the matrixAto be ordered on input. On
output, Gcontainstheresultsoftheorderedeliminationprocess.Maybeusedsub-
sequentlybysymbolicfactorization.
Permutation ,InversePermutation (output) respectively contain the permu-
tationandinversepermutationproducedbythealgorithm.
SuperNodeSize (output) contains the size of supernodes or supernode representa-
tive node produced by the the algorithm. May be used subsequently by symbolicfactorization.
delta(input)controlsmultipleelimination.
Abstract Graph Representation Our minimum degree algorithm is expressed only in
termsoftheGGCL abstractgraphinterface.Thus,anyunderlyingconcreterepresenta-
tionthatmodelstheGGCL Graphconceptcanbeused.Notallconcreterepresentations
will provide the same levels of performance,however. A particular representationthat
offershighperformanceinourapplicationis describedbelow.
Concrete Graph Representation We use an adjacency list representation within the
GGCL framework. In particular the graph is based on a templated “vector of vectors.”The vectorcontainer used is an adaptorclass built on top the STL vector class. Par-
ticularcharacteristicsofthisadaptorclassincludethefollowing:
–Erasing elements does not shrink the associated memory. Adding new elements
aftererasingwillnotneedtoallocateadditionalmemory.
–Additional memory is allocated efﬁciently on demand when new elements are
added(doublingthe capacityeverytime itisincreased).Thispropertycomesfrom
STL vector.
We note that this representation is similar to that used in Liu's implementation, with
someimportantdifferencesduetodynamicmemoryallocation.Withthedynamicmem-ory allocation we do not need to over-write portions of the graph that have been elim-
inated, allowing for a more efﬁcient graph traversal. More importantly, information8
about the elimination graph is preserved allowing for trivial symbolic factorization.
Since symbolic factorization can be an expensive part of the entire solution process,improvingits performancecanresultin signiﬁcantcomputationalsavings.
The overhead of dynamic memory allocation could conceivably compromise per-
formance in some cases. However, in practice, memory allocation overhead does not
contributesigniﬁcantlytorun-timeforourMMDimplementation.Finally,withourap-
proach,somewhatmoretotalmemorymayberequiredforgraphrepresentation.Inthecontextoftheentiresparsematrixsolutionprocessthisisnotanimportantissuebecause
thememoryusedforthegraphduringorderingcanbereturnedtothesystemforusein
subsequentstages(whichwouldusemorememorythaneventhedynamically-allocatedgraphatanyrate).
6 Experimental Results
6.1 Test Matrices
We tested the performance of our implementation using selected matrices from the
Harwell-Boeingcollection[16],theUniversityofFlorida'ssparsematrixcollection[17],aswell aslocally-generatedmatricesrepresentingdiscretizedLaplacians.
Forour tests, we comparethe executiontime of ourimplementationagainstthat of
theequivalentSPARSPAKalgorithm(GENMMD).ThetestswererunonaSunSPARC
Station U-30 having a 300MHz UltraSPARC-II processor, 256MB RAM, and Solaris
2.6. The GENMMD code was compiled with Solaris F77 4.2 with optimizing ﬂags-fast -xdepend -xtarget=ultra2 -xarch=v8plus -xO4 -stackvar
-xsafe=mem . The C++ code was compiled with Kuck and Associates KCC version
3.3e using aggressive optimization for the C++ front-end.The back-end compiler wasSolarisccversion4.2,usingoptimizationsbasicallyequivalenttothosegivenabovefor
theFortrancompiler.
Table1givestheperformanceresults.Foreachcase,ourimplementationandGEN-
MMD produced identical orderings. Note that the performanceof our implementation
isessentiallyequaltothatoftheFortranimplementationandevensurpassestheFortranimplementationina fewcases.
7 Future Work
The work reported here only scratches the surface of what is possible using GGCL
for sparse matrix orderings (or more generally, using generic programming for sparse
matrixcomputations).Thehighlymodularnatureofgenericprogramsmakestheimple-mentations of entire classes of algorithms possible. For instance, a generalized greedy
ordering algorithm (currently being developed) will enable the immediate implemen-
tation of most (if not all) of the greedy algorithms related to MMD (e.g., minimum
deﬁciency).Wearealsoworkingtodevelopsuper-nodebasedsparsematricesaspartof
theMatrixTemplateLibraryandinfacttodevelopallofthenecessaryinfrastructurefora complete generic high-performancesparse matrix package. Future work will extend
theseapproachesfromthesymmetricpositivedeﬁnitecase tothe generalcase.9
Matrix nnnz GENMMD GGCL
BCSPWR09 17232394 0.00728841 0.007807
BCSPWR10 53008271 0.0306503 0.033222
BCSSTK15 394856934 0.13866 0.142741
BCSSTK18 1194868571 0.251257 0.258589
BCSSTK21 360011500 0.0339959 0.039638
BCSSTK23 313421022 0.150273 0.146198
BCSSTK24 356278174 0.0305037 0.031361
BCSSTK26 192214207 0.0262676 0.026178
BCSSTK27 122427451 0.00987525 0.010078
BCSSTK28 4410107307 0.0435296 0.044423
BCSSTK29 13992302748 0.344164 0.352947
BCSSTK31 35588572914 0.842505 0.884734
BCSSTK35 30237709963 0.532725 0.580499
BCSSTK36 23052560044 0.302156 0.333226
BCSSTK37 25503557737 0.347472 0.369738
CRYSTK02 13965477309 0.239564 0.250633
CRYSTK03 24696863241 0.455818 0.480006
CRYSTM03 24696279537 0.293619 0.366581
CT20STIF 523291323067 1.59866 1.59809
LA2D32 10241984 0.00489657 0.006476
LA2D64 40968064 0.022337 0.028669
LA2D128 1638432512 0.0916937 0.119037
LA3D16 409611520 0.0765908 0.077862
LA3D32 3276895232 0.87223 0.882814
PWT 36519144794 0.312136 0.383882
SHUTTLE EDDY1042946585 0.0546211 0.066164
NASASRB 548701311227 1.34424 1.30256
Table 1.Test matrices and ordering time in seconds, for GENMMD (Fortran) and GGCL (C++)
implementations ofminimumdegree ordering.Alsoshown arethematrixorder(n)andthenum-
ber of off-diagonal non-zero elements (nnz).10
References
1. MYannanakis. Computing theminimum ﬁll-inisNP-complete. SIAM Journal ofAlgebraic
and Discrete Methods , 1981.
2. Kaixiang Zhong. A sparse matrix package using the standard template library. Master's
thesis, University of NotreDame, 1996.
3. Gary Kumfert and Alex Pothen. An object-oriented collection of minimum degree algo-
rithms. In Computing inObject-OrientedParallel Environments , pages 95–106, 1998.
4. Matthew H. Austern. Generic Programming and the STL . Addison Wesley Longman, Inc,
October 1998.
5. Jeremy G. Siek and Andrew Lumsdaine. The matrix template library: A generic program-
ming approach to high performance numerical linear algebra. In Denis Carmel, Rodney R.
Oldhhoeft,andMarydellTholburn,editors, ComputinginObject-OrientedParallelEnviron-
ments, pages 59–70, 1998.
6. Lie-Quan Lee, Jeremy G. Siek, and Andrew Lumsdaine. The generic graph component
library. In OOPSLA'99 ,1999. Accepted.
7. Meng Lee and Alexander Stepanov. The standard template library. Technical report, HP
Laboratories, February 1995.
8. ThomasH.Cormen,CharlesE.Leiserson,andRonaldL.Rivest. IntroductiontoAlgorithms .
The MITPress, 1990.
9. ErichGamma,RichardHelm,RalphJohnson,andJohnVlissides. DesignPatterns:Elements
ofReusableObject-OrientedSoftware . AddiaonWesleyPublishingCompany,October1994.
10. Yannis Samaragdakis and Don Batory. Implementing layered designs with mixin layers. In
The Europe Conference on Object-Oriented Programming , 1998.
11. Esmond G.Ng amd Padma Raghavan. Performance of greedy ordering heuristics for sparse
Cholesky factorization. SIAM Journal on Matrix Analysis and Applications , Toappear.
12. S.Parter. Theuse of planar graph in Gaussian elimination. SIAMReview , 3:364–369, 1961.
13. Alan George and Joseph W. H. Liu. The evolution of the minimum degree ordering algo-
rithm.SIAMReview , 31(1):1–19, March 1989.
14. Patrick Amestoy, Timothy A. Davis, and Iain S. Duff. An approximation minimum degree
ordering algorithm. SIAMJ.MatrixAnalysisand Applications , 17(4):886–905, 1996.
15. Joseph W. H. Liu. Modiﬁcation of the minimum-degree algorithm by multiple elimination.
ACMTransaction on Mathematical Software , 11(2):141–153, 1985.
16. Roger G. Grimes, John G. Lewis, and Iain S. Duff. User's guide for the harwell-boeing
sparsematrixcollection. User'sManual Release1,BoeingComputer Services,Seattle,WA,
October 1992.
17. UniversityofFloridasparsematrixcollection. http://www-pub.cise.ufl.edu/ davis/sparse/ .