Anasazi  Version of the Day
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, there is a non-exclusive
8 // license for use of this work by or on behalf of the U.S. Government.
9 //
10 // This library is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU Lesser General Public License as
12 // published by the Free Software Foundation; either version 2.1 of the
13 // License, or (at your option) any later version.
14 //
15 // This library is distributed in the hope that it will be useful, but
16 // WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 // Lesser General Public License for more details.
19 //
20 // You should have received a copy of the GNU Lesser General Public
21 // License along with this library; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
23 // USA
24 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
25 //
26 // ***********************************************************************
27 // @HEADER
28 
29 #ifndef ANASAZI_GENERALIZED_DAVIDSON_SOLMGR_HPP
30 #define ANASAZI_GENERALIZED_DAVIDSON_SOLMGR_HPP
31 
36 #include "Teuchos_ParameterList.hpp"
37 #include "Teuchos_RCPDecl.hpp"
38 
39 #include "AnasaziConfigDefs.hpp"
40 #include "AnasaziTypes.hpp"
41 #include "AnasaziEigenproblem.hpp"
42 #include "AnasaziSolverManager.hpp"
47 #include "AnasaziBasicSort.hpp"
51 
52 using Teuchos::RCP;
53 
57 namespace Anasazi {
58 
77 template <class ScalarType, class MV, class OP>
78 class GeneralizedDavidsonSolMgr : public SolverManager<ScalarType,MV,OP>
79 {
80  public:
81 
111  Teuchos::ParameterList &pl );
112 
116  const Eigenproblem<ScalarType,MV,OP> & getProblem() const { return *d_problem; }
117 
121  int getNumIters() const { return d_solver->getNumIters(); }
122 
127  ReturnType solve();
128 
129  private:
130 
131  void getRestartState( GeneralizedDavidsonState<ScalarType,MV> &state );
132 
134  typedef Teuchos::ScalarTraits<ScalarType> ST;
135  typedef typename ST::magnitudeType MagnitudeType;
136  typedef Teuchos::ScalarTraits<MagnitudeType> MT;
137 
138  RCP< Eigenproblem<ScalarType,MV,OP> > d_problem;
139  RCP< GeneralizedDavidson<ScalarType,MV,OP> > d_solver;
140  RCP< OutputManager<ScalarType> > d_outputMan;
141  RCP< OrthoManager<ScalarType,MV> > d_orthoMan;
142  RCP< SortManager<MagnitudeType> > d_sortMan;
143  RCP< StatusTest<ScalarType,MV,OP> > d_tester;
144  int d_maxRestarts;
145  int d_restartDim;
146 
147 }; // class GeneralizedDavidsonSolMgr
148 
149 //---------------------------------------------------------------------------//
150 // Prevent instantiation on complex scalar type
151 //---------------------------------------------------------------------------//
152 template <class MagnitudeType, class MV, class OP>
153 class GeneralizedDavidsonSolMgr<std::complex<MagnitudeType>,MV,OP>
154 {
155  public:
156 
157  typedef std::complex<MagnitudeType> ScalarType;
159  const RCP<Eigenproblem<ScalarType,MV,OP> > &problem,
160  Teuchos::ParameterList &pl )
161  {
162  // Provide a compile error when attempting to instantiate on complex type
163  MagnitudeType::this_class_is_missing_a_specialization();
164  }
165 };
166 
167 //---------------------------------------------------------------------------//
168 // Start member definitions
169 //---------------------------------------------------------------------------//
170 
171 //---------------------------------------------------------------------------//
172 // Constructor
173 //---------------------------------------------------------------------------//
174 template <class ScalarType, class MV, class OP>
176  const RCP<Eigenproblem<ScalarType,MV,OP> > &problem,
177  Teuchos::ParameterList &pl )
178  : d_problem(problem)
179 {
180  TEUCHOS_TEST_FOR_EXCEPTION( d_problem == Teuchos::null, std::invalid_argument, "Problem not given to solver manager." );
181  TEUCHOS_TEST_FOR_EXCEPTION( !d_problem->isProblemSet(), std::invalid_argument, "Problem not set." );
182  TEUCHOS_TEST_FOR_EXCEPTION( d_problem->getA() == Teuchos::null &&
183  d_problem->getOperator() == Teuchos::null, std::invalid_argument, "A operator not supplied on Eigenproblem." );
184  TEUCHOS_TEST_FOR_EXCEPTION( d_problem->getInitVec() == Teuchos::null, std::invalid_argument, "No vector to clone from on Eigenproblem." );
185  TEUCHOS_TEST_FOR_EXCEPTION( d_problem->getNEV() <= 0, std::invalid_argument, "Number of requested eigenvalues must be positive.");
186 
187  if( !pl.isType<int>("Block Size") )
188  {
189  pl.set<int>("Block Size",1);
190  }
191 
192  if( !pl.isType<int>("Maximum Subspace Dimension") )
193  {
194  pl.set<int>("Maximum Subspace Dimension",3*problem->getNEV()*pl.get<int>("Block Size"));
195  }
196 
197  if( !pl.isType<int>("Print Number of Ritz Values") )
198  {
199  int numToPrint = std::max( pl.get<int>("Block Size"), d_problem->getNEV() );
200  pl.set<int>("Print Number of Ritz Values",numToPrint);
201  }
202 
203  // Get convergence info
204  MagnitudeType tol = pl.get<MagnitudeType>("Convergence Tolerance", MT::eps() );
205  TEUCHOS_TEST_FOR_EXCEPTION( pl.get<MagnitudeType>("Convergence Tolerance") <= MT::zero(),
206  std::invalid_argument, "Convergence Tolerance must be greater than zero." );
207 
208  // Get maximum restarts
209  if( pl.isType<int>("Maximum Restarts") )
210  {
211  d_maxRestarts = pl.get<int>("Maximum Restarts");
212  TEUCHOS_TEST_FOR_EXCEPTION( d_maxRestarts < 0, std::invalid_argument, "Maximum Restarts must be non-negative" );
213  }
214  else
215  {
216  d_maxRestarts = 20;
217  }
218 
219  // Get maximum restarts
220  d_restartDim = pl.get<int>("Restart Dimension",d_problem->getNEV());
221  TEUCHOS_TEST_FOR_EXCEPTION( d_restartDim < d_problem->getNEV(),
222  std::invalid_argument, "Restart Dimension must be at least NEV" );
223 
224  // Get initial guess type
225  std::string initType;
226  if( pl.isType<std::string>("Initial Guess") )
227  {
228  initType = pl.get<std::string>("Initial Guess");
229  TEUCHOS_TEST_FOR_EXCEPTION( initType!="User" && initType!="Random", std::invalid_argument,
230  "Initial Guess type must be 'User' or 'Random'." );
231  }
232  else
233  {
234  initType = "User";
235  }
236 
237  // Get sort type
238  std::string which;
239  if( pl.isType<std::string>("Which") )
240  {
241  which = pl.get<std::string>("Which");
242  TEUCHOS_TEST_FOR_EXCEPTION( which!="LM" && which!="SM" && which!="LR" && which!="SR" && which!="LI" && which!="SI",
243  std::invalid_argument,
244  "Which must be one of LM,SM,LR,SR,LI,SI." );
245  }
246  else
247  {
248  which = "LM";
249  }
250 
251  // Build sort manager (currently must be stored as pointer to derived class)
252  d_sortMan = Teuchos::rcp( new BasicSort<MagnitudeType>(which) );
253 
254  // Build orthogonalization manager
255  std::string ortho = pl.get<std::string>("Orthogonalization","SVQB");
256  TEUCHOS_TEST_FOR_EXCEPTION( ortho!="DGKS" && ortho!= "SVQB" && ortho!="ICGS", std::invalid_argument,
257  "Anasazi::GeneralizedDavidsonSolMgr::constructor: Invalid orthogonalization type" );
258 
259  if( ortho=="DGKS" )
260  {
261  d_orthoMan = Teuchos::rcp( new BasicOrthoManager<ScalarType,MV,OP>() );
262  }
263  else if( ortho=="SVQB" )
264  {
265  d_orthoMan = Teuchos::rcp( new SVQBOrthoManager<ScalarType,MV,OP>() );
266  }
267  else if( ortho=="ICGS" )
268  {
269  d_orthoMan = Teuchos::rcp( new ICGSOrthoManager<ScalarType,MV,OP>() );
270  }
271 
272  // Build StatusTest
273  bool scaleRes = false; // Always false, scaling the residual is handled by the solver
274  bool failOnNaN = false;
275  RCP<StatusTest<ScalarType,MV,OP> > resNormTest = Teuchos::rcp(
276  new StatusTestResNorm<ScalarType,MV,OP>(tol,d_problem->getNEV(),
277  RES_2NORM,scaleRes,failOnNaN) );
278  d_tester = Teuchos::rcp( new StatusTestWithOrdering<ScalarType,MV,OP>(resNormTest,d_sortMan,d_problem->getNEV()) );
279 
280  // Build output manager
281  int verbosity = pl.get<int>("Verbosity",Errors);
282  d_outputMan = Teuchos::rcp( new BasicOutputManager<ScalarType>() );
283  d_outputMan->setVerbosity( verbosity );
284 
285  // Build solver
286  d_outputMan->stream(Debug) << " >> Anasazi::GeneralizedDavidsonSolMgr: Building solver" << std::endl;
287  d_solver = Teuchos::rcp( new GeneralizedDavidson<ScalarType,MV,OP>( problem, d_sortMan, d_outputMan, d_tester, d_orthoMan, pl ) );
288 }
289 
290 //---------------------------------------------------------------------------//
291 // Solve
292 //---------------------------------------------------------------------------//
293 template <class ScalarType, class MV, class OP>
295 {
297  sol.numVecs = 0;
298  d_problem->setSolution(sol);
299 
300  d_solver->initialize();
301  int restarts = 0;
302  while( 1 )
303  {
304  // Call iterate on the solver
305  d_solver->iterate();
306 
307  // If the solver converged, we're done
308  if( d_tester->getStatus() == Passed )
309  break;
310 
311  // If we're already at maximum number of restarts, wrap it up
312  if( restarts == d_maxRestarts )
313  break;
314 
315  // We need to restart
316  d_solver->sortProblem( d_restartDim );
317  GeneralizedDavidsonState<ScalarType,MV> state = d_solver->getState();
318  getRestartState( state );
319  d_solver->initialize( state );
320  restarts++;
321  }
322 
323  // Output final state
324  if( d_outputMan->isVerbosity(FinalSummary) )
325  d_solver->currentStatus(d_outputMan->stream(FinalSummary));
326 
327  // Fill solution struct
328  sol.numVecs = d_tester->howMany();
329  if( sol.numVecs > 0 )
330  {
331  std::vector<int> whichVecs = d_tester->whichVecs();
332  std::vector<int> origIndex = d_solver->getRitzIndex();
333 
334  // Make sure no conjugate pairs are split
335  // Because these are not sorted we have to check all values
336  for( int i=0; i<sol.numVecs; ++i )
337  {
338  if( origIndex[ whichVecs[i] ] == 1 )
339  {
340  if( std::find( whichVecs.begin(), whichVecs.end(), whichVecs[i]+1 ) == whichVecs.end() )
341  {
342  whichVecs.push_back( whichVecs[i]+1 );
343  sol.numVecs++;
344  }
345  }
346  else if( origIndex[ whichVecs[i] ] == -1 )
347  {
348  if( std::find( whichVecs.begin(), whichVecs.end(), whichVecs[i]-1 ) == whichVecs.end() )
349  {
350  whichVecs.push_back( whichVecs[i]-1 );
351  sol.numVecs++;
352  }
353  }
354  }
355 
356  if( d_outputMan->isVerbosity(Debug) )
357  {
358  d_outputMan->stream(Debug) << " >> Anasazi::GeneralizedDavidsonSolMgr: "
359  << sol.numVecs << " eigenpairs converged" << std::endl;
360  }
361 
362  // Sort converged values
363  std::vector< Value<ScalarType> > origVals = d_solver->getRitzValues();
364  std::vector<MagnitudeType> realParts;
365  std::vector<MagnitudeType> imagParts;
366  for( int i=0; i<sol.numVecs; ++i )
367  {
368  realParts.push_back( origVals[whichVecs[i]].realpart );
369  imagParts.push_back( origVals[whichVecs[i]].imagpart );
370  }
371 
372  std::vector<int> permVec(sol.numVecs);
373  d_sortMan->sort( realParts, imagParts, Teuchos::rcpFromRef(permVec), sol.numVecs );
374 
375  // Create new which vector
376  std::vector<int> newWhich;
377  for( int i=0; i<sol.numVecs; ++i )
378  newWhich.push_back( whichVecs[permVec[i]] );
379 
380  // Check if converged vectors are ordered
381  bool ordered = true;
382  for( int i=0; i<sol.numVecs; ++i )
383  {
384  if( newWhich[i]!=i )
385  {
386  ordered = false;
387  break;
388  }
389  }
390 
391  if( ordered )
392  {
393  // Everything is ordered, pull directly from solver and resize
394  sol.index = origIndex;
395  sol.index.resize(sol.numVecs);
396  sol.Evals = d_solver->getRitzValues();
397  sol.Evals.resize(sol.numVecs);
398  }
399  else
400  {
401  // Manually copy values into sol
402 
403  sol.index.resize(sol.numVecs);
404  sol.Evals.resize(sol.numVecs);
405 
406  for( int i=0; i<sol.numVecs; ++i )
407  {
408  sol.index[i] = origIndex[ newWhich[i] ];
409  sol.Evals[i] = origVals[ newWhich[i] ];
410  }
411  }
412  sol.Evecs = MVT::CloneCopy( *(d_solver->getRitzVectors()), newWhich );
413  }
414  d_problem->setSolution(sol);
415 
416  // Return convergence status
417  if( sol.numVecs < d_problem->getNEV() )
418  return Unconverged;
419 
420  return Converged;
421 }
422 
423 //---------------------------------------------------------------------------//
424 // Update GeneralizedDavidson state for restarting
425 //---------------------------------------------------------------------------//
426 template <class ScalarType, class MV, class OP>
429 {
430  TEUCHOS_TEST_FOR_EXCEPTION( state.curDim <= d_restartDim, std::runtime_error,
431  "Anasazi::GeneralizedDavidsonSolMgr: State dimension at restart is smaller than Restart Dimension" );
432 
433  std::vector<int> ritzIndex = d_solver->getRitzIndex();
434 
435  // Don't split conjugate pair when restarting
436  int restartDim = d_restartDim;
437  if( ritzIndex[d_restartDim-1]==1 )
438  restartDim++;
439 
440  d_outputMan->stream(Debug) << " >> Anasazi::GeneralizedDavidsonSolMgr: Restarting with "
441  << restartDim << " vectors" << std::endl;
442 
443  // We have already sorted the problem with d_restartDim "best" values
444  // in the leading position. If we partition the Schur vectors (Z)
445  // of the projected problem as Z = [Z_wanted Z_unwanted], then the
446  // search subspace after the restart is V_restart = V*Z_wanted
447  // (same for AV,BV)
448 
449  // Get view of wanted portion of Z
450  const Teuchos::SerialDenseMatrix<int,ScalarType> Z_wanted =
451  Teuchos::SerialDenseMatrix<int,ScalarType>(Teuchos::View,*state.Z,state.curDim,restartDim);
452 
453  // Get indices for restart
454  std::vector<int> allIndices(state.curDim);
455  for( int i=0; i<state.curDim; ++i )
456  allIndices[i] = i;
457 
458  RCP<const MV> V_orig = MVT::CloneView( *state.V, allIndices );
459 
460  // Get indices for restart
461  std::vector<int> restartIndices(restartDim);
462  for( int i=0; i<restartDim; ++i )
463  restartIndices[i] = i;
464 
465  // Views of subspace vectors to be updated
466  RCP<MV> V_restart = MVT::CloneViewNonConst( *state.V, restartIndices );
467 
468  // Temp storage
469  RCP<MV> restartVecs = MVT::Clone(*state.V,restartDim);
470 
471  // Reset V
472  MVT::MvTimesMatAddMv(ST::one(),*V_orig,Z_wanted,ST::zero(),*restartVecs);
473  MVT::SetBlock(*restartVecs,restartIndices,*V_restart);
474 
475  // V, Z each have orthonormal columns, therefore V*Z should as well
476  if( d_outputMan->isVerbosity(Debug) )
477  {
478  MagnitudeType orthErr = d_orthoMan->orthonormError(*V_restart);
479  std::stringstream os;
480  os << " >> Anasazi::GeneralizedDavidsonSolMgr: Error in V^T V == I after restart : " << orthErr << std::endl;
481  d_outputMan->print(Debug,os.str());
482  }
483 
484  // Reset AV
485  RCP<MV> AV_restart = MVT::CloneViewNonConst( *state.AV, restartIndices );
486  RCP<const MV> AV_orig = MVT::CloneView( *state.AV, allIndices );
487 
488  MVT::MvTimesMatAddMv(ST::one(),*AV_orig,Z_wanted,ST::zero(),*restartVecs);
489  MVT::SetBlock(*restartVecs,restartIndices,*AV_restart);
490 
491  int err;
492 
493  // Update matrix projection as Z^{*}(V^{*}AV)Z
494  const Teuchos::SerialDenseMatrix<int,ScalarType> VAV_orig( Teuchos::View, *state.VAV, state.curDim, state.curDim );
495  Teuchos::SerialDenseMatrix<int,ScalarType> tmpMat(state.curDim, restartDim);
496  err = tmpMat.multiply( Teuchos::NO_TRANS, Teuchos::NO_TRANS, ST::one(), VAV_orig, Z_wanted, ST::zero() );
497  TEUCHOS_TEST_FOR_EXCEPTION( err!=0, std::runtime_error, "GeneralizedDavidsonSolMgr::getRestartState: multiply returned nonzero error code" );
498 
499  Teuchos::SerialDenseMatrix<int,ScalarType> VAV_restart( Teuchos::View, *state.VAV, restartDim, restartDim );
500  err = VAV_restart.multiply( Teuchos::TRANS, Teuchos::NO_TRANS, ST::one(), Z_wanted, tmpMat, ST::zero() );
501  TEUCHOS_TEST_FOR_EXCEPTION( err!=0, std::runtime_error, "GeneralizedDavidsonSolMgr::getRestartState: multiply returned nonzero error code" );
502 
503  if( d_problem->getM() != Teuchos::null )
504  {
505  // Reset BV
506  RCP<const MV> BV_orig = MVT::CloneView( *state.BV, allIndices );
507  RCP<MV> BV_restart = MVT::CloneViewNonConst( *state.BV, restartIndices );
508 
509  MVT::MvTimesMatAddMv(ST::one(),*BV_orig,Z_wanted,ST::zero(),*restartVecs);
510  MVT::SetBlock(*restartVecs,restartIndices,*BV_restart);
511 
512 
513  // Update matrix projection as Z^{*}(V^{*}BV)Z
514  const Teuchos::SerialDenseMatrix<int,ScalarType> VBV_orig( Teuchos::View, *state.VBV, state.curDim, state.curDim );
515  err = tmpMat.multiply( Teuchos::NO_TRANS, Teuchos::NO_TRANS, ST::one(), VBV_orig, Z_wanted, ST::zero() );
516  TEUCHOS_TEST_FOR_EXCEPTION( err!=0, std::runtime_error, "GeneralizedDavidsonSolMgr::getRestartState: multiply returned nonzero error code" );
517 
518  Teuchos::SerialDenseMatrix<int,ScalarType> VBV_restart( Teuchos::View, *state.VBV, restartDim, restartDim );
519  VBV_restart.multiply( Teuchos::TRANS, Teuchos::NO_TRANS, ST::one(), Z_wanted, tmpMat, ST::zero() );
520  TEUCHOS_TEST_FOR_EXCEPTION( err!=0, std::runtime_error, "GeneralizedDavidsonSolMgr::getRestartState: multiply returned nonzero error code" );
521  }
522 
523  // Set Q,Z to identity
524  state.Q->putScalar( ST::zero() );
525  state.Z->putScalar( ST::zero() );
526  for( int ii=0; ii<restartDim; ii++ )
527  {
528  (*state.Q)(ii,ii)= ST::one();
529  (*state.Z)(ii,ii)= ST::one();
530  }
531 
532  // Update current dimension
533  state.curDim = restartDim;
534 }
535 
536 } // namespace Anasazi
537 
538 #endif // ANASAZI_GENERALIZED_DAVIDSON_SOLMGR_HPP
539 
ReturnType solve()
This method performs possibly repeated calls to the underlying eigensolver&#39;s iterate() routine until ...
Pure virtual base class which describes the basic interface for a solver manager. ...
RCP< MV > V
Orthonormal basis for search subspace.
static void MvTimesMatAddMv(const ScalarType alpha, const MV &A, const Teuchos::SerialDenseMatrix< int, ScalarType > &B, const ScalarType beta, MV &mv)
Update mv with .
std::vector< Value< ScalarType > > Evals
The computed eigenvalues.
This class defines the interface required by an eigensolver and status test class to compute solution...
An implementation of the Anasazi::SortManager that performs a collection of common sorting techniques...
Solves eigenvalue problem using generalized Davidson method.
Teuchos::RCP< MV > Evecs
The computed eigenvectors.
RCP< Teuchos::SerialDenseMatrix< int, ScalarType > > VAV
Projection of A onto V.
An implementation of the Anasazi::GenOrthoManager that performs orthogonalization using iterated clas...
The Anasazi::SolverManager is a templated virtual base class that defines the basic interface that an...
int curDim
The current subspace dimension.
Basic implementation of the Anasazi::SortManager class.
An implementation of the Anasazi::MatOrthoManager that performs orthogonalization using the SVQB iter...
Namespace Anasazi contains the classes, structs, enums and utilities used by the Anasazi package...
A status test for testing the norm of the eigenvectors residuals along with a set of auxiliary eigenv...
Structure to contain pointers to GeneralizedDavidson state variables.
int numVecs
The number of computed eigenpairs.
Basic output manager for sending information of select verbosity levels to the appropriate output str...
Anasazi&#39;s basic output manager for sending information of select verbosity levels to the appropriate ...
Abstract base class which defines the interface required by an eigensolver and status test class to c...
ReturnType
Enumerated type used to pass back information from a solver manager.
A status test for testing the norm of the eigenvectors residuals.
RCP< Teuchos::SerialDenseMatrix< int, ScalarType > > Q
Left generalized Schur vectors from QZ decomposition of (VAV,VBV)
Traits class which defines basic operations on multivectors.
static Teuchos::RCP< MV > CloneCopy(const MV &mv)
Creates a new MV and copies contents of mv into the new vector (deep copy).
std::vector< int > index
An index into Evecs to allow compressed storage of eigenvectors for real, non-Hermitian problems...
int getNumIters() const
Get the iteration count for the most recent call to solve()
const Eigenproblem< ScalarType, MV, OP > & getProblem() const
Return the eigenvalue problem.
Anasazi header file which uses auto-configuration information to include necessary C++ headers...
Orthogonalization manager based on the SVQB technique described in "A Block Orthogonalization Procedu...
static Teuchos::RCP< MV > CloneViewNonConst(MV &mv, const std::vector< int > &index)
Creates a new MV that shares the selected contents of mv (shallow copy).
Struct for storing an eigenproblem solution.
static Teuchos::RCP< const MV > CloneView(const MV &mv, const std::vector< int > &index)
Creates a new const MV that shares the selected contents of mv (shallow copy).
static void SetBlock(const MV &A, const std::vector< int > &index, MV &mv)
Copy the vectors in A to a set of vectors in mv indicated by the indices given in index...
GeneralizedDavidsonSolMgr(const RCP< Eigenproblem< ScalarType, MV, OP > > &problem, Teuchos::ParameterList &pl)
Basic constructor for GeneralizedDavidsonSolMgr.
RCP< Teuchos::SerialDenseMatrix< int, ScalarType > > VBV
Projection of B onto V.
RCP< Teuchos::SerialDenseMatrix< int, ScalarType > > Z
Right generalized Schur vectors from QZ decomposition of (VAV,VBV)
A status test for testing the norm of the eigenvectors residuals along with a set of auxiliary eigenv...
An implementation of the Anasazi::MatOrthoManager that performs orthogonalization using (potentially)...
Types and exceptions used within Anasazi solvers and interfaces.
Solver Manager for GeneralizedDavidson.
A status test for testing the norm of the eigenvectors residuals.
Basic implementation of the Anasazi::OrthoManager class.
Basic implementation of the Anasazi::OrthoManager class.
static Teuchos::RCP< MV > Clone(const MV &mv, const int numvecs)
Creates a new empty MV containing numvecs columns.
Implementation of a block Generalized Davidson eigensolver.