Anasazi Version of the Day
Loading...
Searching...
No Matches
AnasaziGeneralizedDavidsonSolMgr.hpp
Go to the documentation of this file.
1// @HEADER
2// ***********************************************************************
3//
4// Anasazi: Block Eigensolvers Package
5// Copyright 2004 Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
8// the U.S. Government retains certain rights in this software.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38//
39// ***********************************************************************
40// @HEADER
41
42#ifndef ANASAZI_GENERALIZED_DAVIDSON_SOLMGR_HPP
43#define ANASAZI_GENERALIZED_DAVIDSON_SOLMGR_HPP
44
49#include "Teuchos_ParameterList.hpp"
50#include "Teuchos_RCPDecl.hpp"
51
52#include "AnasaziConfigDefs.hpp"
53#include "AnasaziTypes.hpp"
61#include "AnasaziBasicSort.hpp"
65
66using Teuchos::RCP;
67
71namespace Anasazi {
72
91template <class ScalarType, class MV, class OP>
92class GeneralizedDavidsonSolMgr : public SolverManager<ScalarType,MV,OP>
93{
94 public:
95
127 GeneralizedDavidsonSolMgr( const RCP< Eigenproblem<ScalarType,MV,OP> > &problem,
128 Teuchos::ParameterList &pl );
129
133 const Eigenproblem<ScalarType,MV,OP> & getProblem() const { return *d_problem; }
134
138 int getNumIters() const { return d_solver->getNumIters(); }
139
145
146 private:
147
148 void getRestartState( GeneralizedDavidsonState<ScalarType,MV> &state );
149
150 typedef MultiVecTraits<ScalarType,MV> MVT;
151 typedef Teuchos::ScalarTraits<ScalarType> ST;
152 typedef typename ST::magnitudeType MagnitudeType;
153 typedef Teuchos::ScalarTraits<MagnitudeType> MT;
154
155 RCP< Eigenproblem<ScalarType,MV,OP> > d_problem;
156 RCP< GeneralizedDavidson<ScalarType,MV,OP> > d_solver;
157 RCP< OutputManager<ScalarType> > d_outputMan;
158 RCP< OrthoManager<ScalarType,MV> > d_orthoMan;
159 RCP< SortManager<MagnitudeType> > d_sortMan;
160 RCP< StatusTest<ScalarType,MV,OP> > d_tester;
161 int d_maxRestarts;
162 int d_restartDim;
163
164}; // class GeneralizedDavidsonSolMgr
165
166//---------------------------------------------------------------------------//
167// Prevent instantiation on complex scalar type
168//---------------------------------------------------------------------------//
169template <class MagnitudeType, class MV, class OP>
170class GeneralizedDavidsonSolMgr<std::complex<MagnitudeType>,MV,OP>
171{
172 public:
173
174 typedef std::complex<MagnitudeType> ScalarType;
176 const RCP<Eigenproblem<ScalarType,MV,OP> > &problem,
177 Teuchos::ParameterList &pl )
178 {
179 // Provide a compile error when attempting to instantiate on complex type
180 MagnitudeType::this_class_is_missing_a_specialization();
181 }
182};
183
184//---------------------------------------------------------------------------//
185// Start member definitions
186//---------------------------------------------------------------------------//
187
188//---------------------------------------------------------------------------//
189// Constructor
190//---------------------------------------------------------------------------//
191template <class ScalarType, class MV, class OP>
193 const RCP<Eigenproblem<ScalarType,MV,OP> > &problem,
194 Teuchos::ParameterList &pl )
195 : d_problem(problem)
196{
197 TEUCHOS_TEST_FOR_EXCEPTION( d_problem == Teuchos::null, std::invalid_argument, "Problem not given to solver manager." );
198 TEUCHOS_TEST_FOR_EXCEPTION( !d_problem->isProblemSet(), std::invalid_argument, "Problem not set." );
199 TEUCHOS_TEST_FOR_EXCEPTION( d_problem->getA() == Teuchos::null &&
200 d_problem->getOperator() == Teuchos::null, std::invalid_argument, "A operator not supplied on Eigenproblem." );
201 TEUCHOS_TEST_FOR_EXCEPTION( d_problem->getInitVec() == Teuchos::null, std::invalid_argument, "No vector to clone from on Eigenproblem." );
202 TEUCHOS_TEST_FOR_EXCEPTION( d_problem->getNEV() <= 0, std::invalid_argument, "Number of requested eigenvalues must be positive.");
203
204 if( !pl.isType<int>("Block Size") )
205 {
206 pl.set<int>("Block Size",1);
207 }
208
209 if( !pl.isType<int>("Maximum Subspace Dimension") )
210 {
211 pl.set<int>("Maximum Subspace Dimension",3*problem->getNEV()*pl.get<int>("Block Size"));
212 }
213
214 if( !pl.isType<int>("Print Number of Ritz Values") )
215 {
216 int numToPrint = std::max( pl.get<int>("Block Size"), d_problem->getNEV() );
217 pl.set<int>("Print Number of Ritz Values",numToPrint);
218 }
219
220 // Get convergence info
221 MagnitudeType tol = pl.get<MagnitudeType>("Convergence Tolerance", MT::eps() );
222 TEUCHOS_TEST_FOR_EXCEPTION( pl.get<MagnitudeType>("Convergence Tolerance") <= MT::zero(),
223 std::invalid_argument, "Convergence Tolerance must be greater than zero." );
224
225 // Get maximum restarts
226 if( pl.isType<int>("Maximum Restarts") )
227 {
228 d_maxRestarts = pl.get<int>("Maximum Restarts");
229 TEUCHOS_TEST_FOR_EXCEPTION( d_maxRestarts < 0, std::invalid_argument, "Maximum Restarts must be non-negative" );
230 }
231 else
232 {
233 d_maxRestarts = 20;
234 }
235
236 // Get maximum restarts
237 d_restartDim = pl.get<int>("Restart Dimension",d_problem->getNEV());
238 TEUCHOS_TEST_FOR_EXCEPTION( d_restartDim < d_problem->getNEV(),
239 std::invalid_argument, "Restart Dimension must be at least NEV" );
240
241 // Get initial guess type
242 std::string initType;
243 if( pl.isType<std::string>("Initial Guess") )
244 {
245 initType = pl.get<std::string>("Initial Guess");
246 TEUCHOS_TEST_FOR_EXCEPTION( initType!="User" && initType!="Random", std::invalid_argument,
247 "Initial Guess type must be 'User' or 'Random'." );
248 }
249 else
250 {
251 initType = "User";
252 }
253
254 // Get sort type
255 std::string which;
256 if( pl.isType<std::string>("Which") )
257 {
258 which = pl.get<std::string>("Which");
259 TEUCHOS_TEST_FOR_EXCEPTION( which!="LM" && which!="SM" && which!="LR" && which!="SR" && which!="LI" && which!="SI",
260 std::invalid_argument,
261 "Which must be one of LM,SM,LR,SR,LI,SI." );
262 }
263 else
264 {
265 which = "LM";
266 }
267
268 // Build sort manager (currently must be stored as pointer to derived class)
269 d_sortMan = Teuchos::rcp( new BasicSort<MagnitudeType>(which) );
270
271 // Build orthogonalization manager
272 std::string ortho = pl.get<std::string>("Orthogonalization","SVQB");
273 TEUCHOS_TEST_FOR_EXCEPTION( ortho!="DGKS" && ortho!= "SVQB" && ortho!="ICGS", std::invalid_argument,
274 "Anasazi::GeneralizedDavidsonSolMgr::constructor: Invalid orthogonalization type" );
275
276 if( ortho=="DGKS" )
277 {
278 d_orthoMan = Teuchos::rcp( new BasicOrthoManager<ScalarType,MV,OP>() );
279 }
280 else if( ortho=="SVQB" )
281 {
282 d_orthoMan = Teuchos::rcp( new SVQBOrthoManager<ScalarType,MV,OP>() );
283 }
284 else if( ortho=="ICGS" )
285 {
286 d_orthoMan = Teuchos::rcp( new ICGSOrthoManager<ScalarType,MV,OP>() );
287 }
288
289 // Build StatusTest
290 bool scaleRes = false; // Always false, scaling the residual is handled by the solver
291 bool failOnNaN = false;
292 RCP<StatusTest<ScalarType,MV,OP> > resNormTest = Teuchos::rcp(
293 new StatusTestResNorm<ScalarType,MV,OP>(tol,d_problem->getNEV(),
294 RES_2NORM,scaleRes,failOnNaN) );
295 d_tester = Teuchos::rcp( new StatusTestWithOrdering<ScalarType,MV,OP>(resNormTest,d_sortMan,d_problem->getNEV()) );
296
297 // Build output manager
298
299 // Create a formatted output stream to print to.
300 // See if user requests output processor.
301 int osProc = pl.get("Output Processor", 0);
302
303 // If not passed in by user, it will be chosen based upon operator type.
304 Teuchos::RCP<Teuchos::FancyOStream> osp;
305
306 if (pl.isParameter("Output Stream")) {
307 osp = Teuchos::getParameter<Teuchos::RCP<Teuchos::FancyOStream> >(pl,"Output Stream");
308 }
309 else {
310 osp = OutputStreamTraits<OP>::getOutputStream (*d_problem->getOperator(), osProc);
311 }
312
313 // verbosity
314 int verbosity = Anasazi::Errors;
315 if (pl.isParameter("Verbosity")) {
316 if (Teuchos::isParameterType<int>(pl,"Verbosity")) {
317 verbosity = pl.get("Verbosity", verbosity);
318 } else {
319 verbosity = (int)Teuchos::getParameter<Anasazi::MsgType>(pl,"Verbosity");
320 }
321 }
322
323 d_outputMan = Teuchos::rcp( new OutputManager<ScalarType>(verbosity,osp) );
324
325 // Build solver
326 d_outputMan->stream(Debug) << " >> Anasazi::GeneralizedDavidsonSolMgr: Building solver" << std::endl;
327 d_solver = Teuchos::rcp( new GeneralizedDavidson<ScalarType,MV,OP>( problem, d_sortMan, d_outputMan, d_tester, d_orthoMan, pl ) );
328
329 TEUCHOS_TEST_FOR_EXCEPTION(d_solver->getMaxSubspaceDim() < d_restartDim, std::invalid_argument,
330 "The maximum size of the subspace dimension (" << d_solver->getMaxSubspaceDim() << ") must "
331 "not be smaller than the size of the restart space (" << d_restartDim << "). "
332 "Please adjust \"Restart Dimension\" and/or \"Maximum Subspace Dimension\" parameters.");
333
334}
335
336//---------------------------------------------------------------------------//
337// Solve
338//---------------------------------------------------------------------------//
339template <class ScalarType, class MV, class OP>
341{
342 Eigensolution<ScalarType,MV> sol;
343 sol.numVecs = 0;
344 d_problem->setSolution(sol);
345
346 d_solver->initialize();
347 int restarts = 0;
348 while( 1 )
349 {
350 // Call iterate on the solver
351 d_solver->iterate();
352
353 // If the solver converged, we're done
354 if( d_tester->getStatus() == Passed )
355 break;
356
357 // If we're already at maximum number of restarts, wrap it up
358 if( restarts == d_maxRestarts )
359 break;
360
361 // We need to restart
362 d_solver->sortProblem( d_restartDim );
363 GeneralizedDavidsonState<ScalarType,MV> state = d_solver->getState();
364 getRestartState( state );
365 d_solver->initialize( state );
366 restarts++;
367 }
368
369 // Output final state
370 if( d_outputMan->isVerbosity(FinalSummary) )
371 d_solver->currentStatus(d_outputMan->stream(FinalSummary));
372
373 // Fill solution struct
374 sol.numVecs = d_tester->howMany();
375 if( sol.numVecs > 0 )
376 {
377 std::vector<int> whichVecs = d_tester->whichVecs();
378 std::vector<int> origIndex = d_solver->getRitzIndex();
379
380 // Make sure no conjugate pairs are split
381 // Because these are not sorted we have to check all values
382 for( int i=0; i<sol.numVecs; ++i )
383 {
384 if( origIndex[ whichVecs[i] ] == 1 )
385 {
386 if( std::find( whichVecs.begin(), whichVecs.end(), whichVecs[i]+1 ) == whichVecs.end() )
387 {
388 whichVecs.push_back( whichVecs[i]+1 );
389 sol.numVecs++;
390 }
391 }
392 else if( origIndex[ whichVecs[i] ] == -1 )
393 {
394 if( std::find( whichVecs.begin(), whichVecs.end(), whichVecs[i]-1 ) == whichVecs.end() )
395 {
396 whichVecs.push_back( whichVecs[i]-1 );
397 sol.numVecs++;
398 }
399 }
400 }
401
402 if( d_outputMan->isVerbosity(Debug) )
403 {
404 d_outputMan->stream(Debug) << " >> Anasazi::GeneralizedDavidsonSolMgr: "
405 << sol.numVecs << " eigenpairs converged" << std::endl;
406 }
407
408 // Sort converged values
409 std::vector< Value<ScalarType> > origVals = d_solver->getRitzValues();
410 std::vector<MagnitudeType> realParts;
411 std::vector<MagnitudeType> imagParts;
412 for( int i=0; i<sol.numVecs; ++i )
413 {
414 realParts.push_back( origVals[whichVecs[i]].realpart );
415 imagParts.push_back( origVals[whichVecs[i]].imagpart );
416 }
417
418 std::vector<int> permVec(sol.numVecs);
419 d_sortMan->sort( realParts, imagParts, Teuchos::rcpFromRef(permVec), sol.numVecs );
420
421 // Create new which vector
422 std::vector<int> newWhich;
423 for( int i=0; i<sol.numVecs; ++i )
424 newWhich.push_back( whichVecs[permVec[i]] );
425
426 // Check if converged vectors are ordered
427 bool ordered = true;
428 for( int i=0; i<sol.numVecs; ++i )
429 {
430 if( newWhich[i]!=i )
431 {
432 ordered = false;
433 break;
434 }
435 }
436
437 if( ordered )
438 {
439 // Everything is ordered, pull directly from solver and resize
440 sol.index = origIndex;
441 sol.index.resize(sol.numVecs);
442 sol.Evals = d_solver->getRitzValues();
443 sol.Evals.resize(sol.numVecs);
444 }
445 else
446 {
447 // Manually copy values into sol
448
449 sol.index.resize(sol.numVecs);
450 sol.Evals.resize(sol.numVecs);
451
452 for( int i=0; i<sol.numVecs; ++i )
453 {
454 sol.index[i] = origIndex[ newWhich[i] ];
455 sol.Evals[i] = origVals[ newWhich[i] ];
456 }
457 }
458 sol.Evecs = MVT::CloneCopy( *(d_solver->getRitzVectors()), newWhich );
459 }
460 d_problem->setSolution(sol);
461
462 // Return convergence status
463 if( sol.numVecs < d_problem->getNEV() )
464 return Unconverged;
465
466 return Converged;
467}
468
469//---------------------------------------------------------------------------//
470// Update GeneralizedDavidson state for restarting
471//---------------------------------------------------------------------------//
472template <class ScalarType, class MV, class OP>
474 GeneralizedDavidsonState<ScalarType,MV> &state )
475{
476 TEUCHOS_TEST_FOR_EXCEPTION( state.curDim <= d_restartDim, std::runtime_error,
477 "Anasazi::GeneralizedDavidsonSolMgr: State dimension at restart is smaller than Restart Dimension" );
478
479 std::vector<int> ritzIndex = d_solver->getRitzIndex();
480
481 // Don't split conjugate pair when restarting
482 int restartDim = d_restartDim;
483 if( ritzIndex[d_restartDim-1]==1 )
484 restartDim++;
485
486 d_outputMan->stream(Debug) << " >> Anasazi::GeneralizedDavidsonSolMgr: Restarting with "
487 << restartDim << " vectors" << std::endl;
488
489 // We have already sorted the problem with d_restartDim "best" values
490 // in the leading position. If we partition the Schur vectors (Z)
491 // of the projected problem as Z = [Z_wanted Z_unwanted], then the
492 // search subspace after the restart is V_restart = V*Z_wanted
493 // (same for AV,BV)
494
495 // Get view of wanted portion of Z
496 const Teuchos::SerialDenseMatrix<int,ScalarType> Z_wanted =
497 Teuchos::SerialDenseMatrix<int,ScalarType>(Teuchos::View,*state.Z,state.curDim,restartDim);
498
499 // Get indices for restart
500 std::vector<int> allIndices(state.curDim);
501 for( int i=0; i<state.curDim; ++i )
502 allIndices[i] = i;
503
504 RCP<const MV> V_orig = MVT::CloneView( *state.V, allIndices );
505
506 // Get indices for restart
507 std::vector<int> restartIndices(restartDim);
508 for( int i=0; i<restartDim; ++i )
509 restartIndices[i] = i;
510
511 // Views of subspace vectors to be updated
512 RCP<MV> V_restart = MVT::CloneViewNonConst( *state.V, restartIndices );
513
514 // Temp storage
515 RCP<MV> restartVecs = MVT::Clone(*state.V,restartDim);
516
517 // Reset V
518 MVT::MvTimesMatAddMv(ST::one(),*V_orig,Z_wanted,ST::zero(),*restartVecs);
519 MVT::SetBlock(*restartVecs,restartIndices,*V_restart);
520
521 // V, Z each have orthonormal columns, therefore V*Z should as well
522 if( d_outputMan->isVerbosity(Debug) )
523 {
524 MagnitudeType orthErr = d_orthoMan->orthonormError(*V_restart);
525 std::stringstream os;
526 os << " >> Anasazi::GeneralizedDavidsonSolMgr: Error in V^T V == I after restart : " << orthErr << std::endl;
527 d_outputMan->print(Debug,os.str());
528 }
529
530 // Reset AV
531 RCP<MV> AV_restart = MVT::CloneViewNonConst( *state.AV, restartIndices );
532 RCP<const MV> AV_orig = MVT::CloneView( *state.AV, allIndices );
533
534 MVT::MvTimesMatAddMv(ST::one(),*AV_orig,Z_wanted,ST::zero(),*restartVecs);
535 MVT::SetBlock(*restartVecs,restartIndices,*AV_restart);
536
537 int err;
538
539 // Update matrix projection as Z^{*}(V^{*}AV)Z
540 const Teuchos::SerialDenseMatrix<int,ScalarType> VAV_orig( Teuchos::View, *state.VAV, state.curDim, state.curDim );
541 Teuchos::SerialDenseMatrix<int,ScalarType> tmpMat(state.curDim, restartDim);
542 err = tmpMat.multiply( Teuchos::NO_TRANS, Teuchos::NO_TRANS, ST::one(), VAV_orig, Z_wanted, ST::zero() );
543 TEUCHOS_TEST_FOR_EXCEPTION( err!=0, std::runtime_error, "GeneralizedDavidsonSolMgr::getRestartState: multiply returned nonzero error code" );
544
545 Teuchos::SerialDenseMatrix<int,ScalarType> VAV_restart( Teuchos::View, *state.VAV, restartDim, restartDim );
546 err = VAV_restart.multiply( Teuchos::TRANS, Teuchos::NO_TRANS, ST::one(), Z_wanted, tmpMat, ST::zero() );
547 TEUCHOS_TEST_FOR_EXCEPTION( err!=0, std::runtime_error, "GeneralizedDavidsonSolMgr::getRestartState: multiply returned nonzero error code" );
548
549 if( d_problem->getM() != Teuchos::null )
550 {
551 // Reset BV
552 RCP<const MV> BV_orig = MVT::CloneView( *state.BV, allIndices );
553 RCP<MV> BV_restart = MVT::CloneViewNonConst( *state.BV, restartIndices );
554
555 MVT::MvTimesMatAddMv(ST::one(),*BV_orig,Z_wanted,ST::zero(),*restartVecs);
556 MVT::SetBlock(*restartVecs,restartIndices,*BV_restart);
557
558
559 // Update matrix projection as Z^{*}(V^{*}BV)Z
560 const Teuchos::SerialDenseMatrix<int,ScalarType> VBV_orig( Teuchos::View, *state.VBV, state.curDim, state.curDim );
561 err = tmpMat.multiply( Teuchos::NO_TRANS, Teuchos::NO_TRANS, ST::one(), VBV_orig, Z_wanted, ST::zero() );
562 TEUCHOS_TEST_FOR_EXCEPTION( err!=0, std::runtime_error, "GeneralizedDavidsonSolMgr::getRestartState: multiply returned nonzero error code" );
563
564 Teuchos::SerialDenseMatrix<int,ScalarType> VBV_restart( Teuchos::View, *state.VBV, restartDim, restartDim );
565 VBV_restart.multiply( Teuchos::TRANS, Teuchos::NO_TRANS, ST::one(), Z_wanted, tmpMat, ST::zero() );
566 TEUCHOS_TEST_FOR_EXCEPTION( err!=0, std::runtime_error, "GeneralizedDavidsonSolMgr::getRestartState: multiply returned nonzero error code" );
567 }
568
569 // Set Q,Z to identity
570 state.Q->putScalar( ST::zero() );
571 state.Z->putScalar( ST::zero() );
572 for( int ii=0; ii<restartDim; ii++ )
573 {
574 (*state.Q)(ii,ii)= ST::one();
575 (*state.Z)(ii,ii)= ST::one();
576 }
577
578 // Update current dimension
579 state.curDim = restartDim;
580}
581
582} // namespace Anasazi
583
584#endif // ANASAZI_GENERALIZED_DAVIDSON_SOLMGR_HPP
585
Basic implementation of the Anasazi::OrthoManager class.
Basic implementation of the Anasazi::SortManager class.
Anasazi header file which uses auto-configuration information to include necessary C++ headers.
Abstract base class which defines the interface required by an eigensolver and status test class to c...
Implementation of a block Generalized Davidson eigensolver.
Basic implementation of the Anasazi::OrthoManager class.
Abstract class definition for Anasazi Output Managers.
Abstract class definition for Anasazi output stream.
Orthogonalization manager based on the SVQB technique described in "A Block Orthogonalization Procedu...
Pure virtual base class which describes the basic interface for a solver manager.
A status test for testing the norm of the eigenvectors residuals.
A status test for testing the norm of the eigenvectors residuals along with a set of auxiliary eigenv...
Types and exceptions used within Anasazi solvers and interfaces.
Solver Manager for GeneralizedDavidson.
GeneralizedDavidsonSolMgr(const RCP< Eigenproblem< ScalarType, MV, OP > > &problem, Teuchos::ParameterList &pl)
Basic constructor for GeneralizedDavidsonSolMgr.
int getNumIters() const
Get the iteration count for the most recent call to solve()
ReturnType solve()
This method performs possibly repeated calls to the underlying eigensolver's iterate() routine until ...
const Eigenproblem< ScalarType, MV, OP > & getProblem() const
Return the eigenvalue problem.
The Anasazi::SolverManager is a templated virtual base class that defines the basic interface that an...
Namespace Anasazi contains the classes, structs, enums and utilities used by the Anasazi package.
ReturnType
Enumerated type used to pass back information from a solver manager.
Output managers remove the need for the eigensolver to know any information about the required output...