LOCA::Parameter::AbstractEntry | Abstract interface for all entries in LOCA::Parameter::Library |

LOCA::BorderedSystem::AbstractGroup | An interface for groups that are bordered systems |

LOCA::Homotopy::AbstractGroup | Interface to underlying groups for homotopy calculations |

LOCA::Hopf::MinimallyAugmented::AbstractGroup | Interface to underlying groups for Hopf calculations using the minimally augmented formulation |

LOCA::Hopf::MooreSpence::AbstractGroup | Interface to underlying groups for Hopf point calculations using the Moore-Spence formulation |

LOCA::MultiContinuation::AbstractGroup | LOCA abstract interface for continuation, derived from the NOX::Abstract::Group. This abstract class provides the interface necessary to perform continuation, i.e., compute families of solutions to |

LOCA::Pitchfork::MinimallyAugmented::AbstractGroup | Interface to underlying groups for pitchfork calculations using the minimally augmented formulation |

LOCA::Pitchfork::MooreSpence::AbstractGroup | Interface to underlying groups for pitchfork calculations using the Moore-Spence formulation |

LOCA::TimeDependent::AbstractGroup | Interface to underlying groups for time dependent systems |

LOCA::TurningPoint::MinimallyAugmented::AbstractGroup | Interface to underlying groups for turning point calculations using the minimally augmented formulation |

LOCA::TurningPoint::MooreSpence::AbstractGroup | Interface to underlying groups for turning point calculations using the Moore-Spence formulation |

LOCA::BorderedSolver::AbstractOperator | Abstract interface class representing an operator for solving bordered sets of linear equations |

LOCA::AnasaziOperator::AbstractStrategy | Abstract interface class for Anasazi operator strategies |

LOCA::BorderedSolver::AbstractStrategy | Abstract interface class for solving bordered sets of linear equations |

LOCA::EigenvalueSort::AbstractStrategy | Abstract interface for eigenvalue sorting strategies |

LOCA::Eigensolver::AbstractStrategy | Abstract interface class for Eigensolver strategies |

LOCA::MultiContinuation::AbstractStrategy | Abstract interface class for continuation strategies |

LOCA::MultiPredictor::AbstractStrategy | Abstract interface class for predictor strategies |

LOCA::SaveEigenData::AbstractStrategy | Abstract interface class strategies to save eigenvector/value data |

LOCA::StepSize::AbstractStrategy | Abstract interface class for step size control strategies |

LOCA::Epetra::TransposeLinearSystem::AbstractStrategy | A pure virtual interface for solving the transpose of a linear system |

LOCA::StepSize::Adaptive | Adaptive step size control strategy |

LOCA::Eigensolver::AnasaziStrategy | Anasazi eigensolver strategy |

LOCA::MultiContinuation::ArcLengthConstraint | Implementation of LOCA::MultiContinuation::ConstraintInterfaceMVDX for arclength continuation |

LOCA::MultiContinuation::ArcLengthGroup | Specialization of LOCA::MultiContinuation::ExtendedGroup to pseudo-arclength continuation |

LOCA::Epetra::AugmentedOp | Epetra operator representing a bordered matrix |

NOX::LineSearch::Backtrack | Generic backtracking line search |

LOCA::BorderedSolver::BorderedOperator | Bordered solver operator representing as bordered Jacobian as operator as implemented in the NOX::Abstract::Group |

LOCA::BorderedSolver::Bordering | Bordered system solver strategy based on bordering |

NOX::Direction::Broyden | Broyden direction |

NOX::Direction::Broyden::BroydenMemory | Utility class for NOX::Direction::Broyden method to manage the information stored in "limited" memory |

NOX::Direction::Broyden::BroydenMemoryUnit | Utility class for NOX::Direction::Broyden::BroydenMemory |

NOX::Epetra::BroydenOperator | A concrete implementation of a Broyden-type operator for NOX |

LOCA::AnasaziOperator::Cayley | Anasazi operator for computing generalized eigenvalues using Cayley transformations |

NOX::StatusTest::Combo | Arbitrary combination of status tests |

LOCA::Epetra::CompactWYOp | An Epetra operator for solving extended sets of equations using Householder transformations |

LOCA::Hopf::ComplexMultiVector | Multi-vector class to hold two multi-vectors to represent a complex multi-vector |

LOCA::BorderedSolver::ComplexOperator | Bordered solver operator representing the as implemented in the LOCA::Hopf::MooreSpence::AbstractGroup |

LOCA::Hopf::ComplexVector | Vector class to hold two vectors to represent a complex vector |

LOCA::MultiContinuation::CompositeConstraint | Implementation of LOCA::MultiContinuation::ConstraintInterface for composite constraints, i.e., a constraint comprised of multiple, separate constraints |

LOCA::MultiContinuation::CompositeConstraintMVDX | Implementation of LOCA::MultiContinuation::ConstraintInterfaceMVDX for composite constraints, i.e., a constraint comprised of multiple, separate constraints |

LOCA::MultiPredictor::Constant | Constant predictor strategy |

LOCA::StepSize::Constant | Constant step size control strategy |

LOCA::MultiContinuation::ConstrainedGroup | Extended group representing a constrained nonlinear problem |

LOCA::Hopf::MinimallyAugmented::Constraint | Implementation of LOCA::MultiContinuation::ConstraintInterfaceMVDX for computing Hopf bifurcations for the minimally augmented Hopf formulation |

LOCA::Pitchfork::MinimallyAugmented::Constraint | Implementation of LOCA::MultiContinuation::ConstraintInterfaceMVDX for computing pitchforks for the minimally augmented pitchfork formulation |

LOCA::TurningPoint::MinimallyAugmented::Constraint | Implementation of LOCA::MultiContinuation::ConstraintInterfaceMVDX for computing turning points for the minimally augmented turning point formulation |

LOCA::MultiContinuation::ConstraintInterface | Abstract interface for the constraint portion of a constrained nonlinear system |

LOCA::MultiContinuation::ConstraintInterfaceMVDX | Abstract interface for the constraint portion of a constrained nonlinear system for constraints that support computing a solution component derivative as a multi-vector |

NOX::LineSearch::Utils::Counters | Common counters that all line search algorithms should report |

LOCA::SingularJacobianSolve::Default | Default singular Jacobian solve computation class |

LOCA::Parameter::DefaultFunctor< ObjectType, ValueType > | Default function object for setting a single parameter in a single object using a data member pointer |

LOCA::Eigensolver::DefaultStrategy | Default eigensolver strategy |

LOCA::SaveEigenData::DefaultStrategy | Default strategy for saving eigenvector/value data |

LOCA::Homotopy::DeflatedGroup | LOCA's Homotopy Algorithm |

LOCA::DerivUtils | LOCA's generic derivative computation class to compute various derivatives via finite differencing |

LOCA::Eigensolver::DGGEVStrategy | LAPACK DGGEV eigensolver strategy |

NOX::StatusTest::Divergence | Failure test based on a threshold value of the norm of F |

LOCA::Parameter::Entry< ValueType > | Parameter entry interface class templated on ValueType |

LOCA::BorderedSolver::EpetraAugmented | Bordered system solver strategy based on augmenting the Jacobian operator |

LOCA::BorderedSolver::EpetraHouseholder | Bordered system solver strategy based on Householder transformations |

LOCA::ErrorCheck | An Error checking algorithm for NOX/LOCA routines |

LOCA::Epetra::TransposeLinearSystem::ExplicitTranspose | Method for solving the transpose of a linear system by explicitly forming the transpose of the matrix |

LOCA::Hopf::MinimallyAugmented::ExtendedGroup | A group representing the minimally augemented Hopf equations |

LOCA::Hopf::MooreSpence::ExtendedGroup | A group representing the Moore-Spence Hopf equations |

LOCA::MultiContinuation::ExtendedGroup | Base class for all continuation groups |

LOCA::Pitchfork::MinimallyAugmented::ExtendedGroup | A group representing the minimally augemented pitchfork equations |

LOCA::Pitchfork::MooreSpence::ExtendedGroup | A group representing the Moore-Spence pitchfork equations |

LOCA::TurningPoint::MinimallyAugmented::ExtendedGroup | A group representing the minimally augemented turning point equations |

LOCA::TurningPoint::MooreSpence::ExtendedGroup | A group representing the Moore-Spence turning point equations |

LOCA::Hopf::MooreSpence::ExtendedMultiVector | Multi-vector class to hold solution vectors, Newton vectors, etc.for the Moore-Spence Hopf eqautions |

LOCA::MultiContinuation::ExtendedMultiVector | MultiVector class to hold solution vectors, Newton vectors, etc. for continuation equations |

LOCA::Pitchfork::MooreSpence::ExtendedMultiVector | MultiVector class to hold solution vectors, Newton vectors, etc.for the Moore-Spence pitchfork formulation |

LOCA::TurningPoint::MooreSpence::ExtendedMultiVector | MultiVector class to hold solution vectors, Newton vectors, etc.for the Moore-Spence turning point formulation |

LOCA::Hopf::MooreSpence::ExtendedVector | Vector class to hold solution vectors, Newton vectors, etc. for Moore-Spence Hopf equations |

LOCA::MultiContinuation::ExtendedVector | Vector class to hold solution vectors, Newton vectors, etc. for continuation equations |

LOCA::Pitchfork::MooreSpence::ExtendedVector | Vector class to hold solution vectors, Newton vectors, etc. for the Moore-Spence turning point formulation |

LOCA::TurningPoint::MooreSpence::ExtendedVector | Vector class to hold solution vectors, Newton vectors, etc. for the Moore-Spence turning point formulation |

NOX::Solver::Factory | Factory class to control the creation of solvers derived from the NOX::Solver::Generic object |

NOX::StatusTest::Factory | Factory to build a set of status tests from a parameter list |

LOCA::Abstract::Factory | Abstract interface for providing a user-defined factory |

LOCA::AnasaziOperator::Factory | Factory for creating Anasazi operator strategy objects |

LOCA::Bifurcation::Factory | Factory for creating bifurcation strategy objects |

LOCA::BorderedSolver::Factory | Factory for creating BorderedSolver strategy objects |

LOCA::Eigensolver::Factory | Factory for creating Eigensolver strategy objects |

LOCA::EigenvalueSort::Factory | Factory for creating EigenvalueSort strategy objects |

LOCA::Factory | Factory class for creating strategies |

LOCA::MultiContinuation::Factory | Factory for creating continuation strategy objects |

LOCA::MultiPredictor::Factory | Factory for creating Predictor strategy objects |

LOCA::SaveEigenData::Factory | Factory for creating strategy objects to save eigenvectors/values |

LOCA::StepSize::Factory | Factory for creating step size control strategy objects |

LOCA::Epetra::Factory | Implementation of the LOCA::Abstract::Factory for Epetra groups |

LOCA::Epetra::TransposeLinearSystem::Factory | Factory for creating transpose linear system strategy objects |

LOCA::LAPACK::Factory | Implementation of the LOCA::Abstract::Factory for LAPACK groups |

NOX::Direction::Factory | Factory to build direction objects derived from NOX::Direction::Generic |

NOX::LineSearch::Factory | Factory to build line search objects derived from NOX::LineSearch::Generic |

NOX::Epetra::FiniteDifference | Concrete implementation for creating an Epetra_RowMatrix Jacobian via finite differencing of the residual |

NOX::Epetra::FiniteDifferenceColoring | Concrete implementation for creating an Epetra_RowMatrix Jacobian via finite differencing of the residual using coloring |

LOCA::Hopf::MinimallyAugmented::FiniteDifferenceGroup | Concrete class that provides concrete implementations of the derivative computation methods of the LOCA::Hopf::MinimallyAugmented::AbstractGroup using first-order finite differencing |

LOCA::Hopf::MooreSpence::FiniteDifferenceGroup | Concrete class that provides concrete implementations of the derivative computation methods of the LOCA::Hopf::MooreSpence::AbstractGroup using first-order finite differencing |

LOCA::MultiContinuation::FiniteDifferenceGroup | Concrete class that provides a concrete implementation of the computeDfDp() method of the LOCA::Continuation::AbstractGroup using first-order finite differencing |

LOCA::TurningPoint::MinimallyAugmented::FiniteDifferenceGroup | Concrete class that provides concrete implementations of the derivative computation methods of the LOCA::TurningPoint::MinimallyAugmented::AbstractGroup using first-order finite differencing |

LOCA::TurningPoint::MooreSpence::FiniteDifferenceGroup | Concrete class that provides concrete implementations of the derivative computation methods of the LOCA::TurningPoint::MooreSpence::AbstractGroup using first-order finite differencing |

NOX::StatusTest::FiniteValue | Failure test based on whether the norm of a vector has a finite value |

NOX::Multiphysics::Solver::FixedPointBased | Nonlinear solver based on a line search (i.e., damping) |

LOCA::Epetra::AnasaziOperator::Floquet | Anasazi operator for computing generalized eigenvalues using Cayley transformations |

NOX::LineSearch::FullStep | Simplest line search - always take the full step |

NOX::MeritFunction::Generic | Base class to support a user defined merit function that can be passed to line searches and directions through the parameter list |

NOX::Multiphysics::Solver::Generic | Abstract nonlinear solver method interface |

NOX::Solver::Generic | Abstract nonlinear solver method interface |

NOX::StatusTest::Generic | Generic status test to check for convergence or failure of the nonlinear solver |

LOCA::SingularJacobianSolve::Generic | Generic singular jacobian solve interface |

NOX::Direction::Generic | Generic direction interface |

NOX::LineSearch::Generic | Base class line search interface |

LOCA::GlobalData | Container class to hold "global" LOCA objects |

NOX::GlobalData | Container class to hold "global" NOX objects |

NOX::Multiphysics::Group | NOX pure abstract interface to a "group"; i.e., a solution vector and the corresponding F-vector, Jacobian matrix, gradient vector, and Newton vector |

LOCA::Abstract::Group | Compatiblity class for AbstractGroup hierarchy |

LOCA::Homotopy::Group | LOCA's Homotopy Algorithm |

NOX::Epetra::Group | Concrete implementation of NOX::Abstract::Group for Trilinos/Epetra |

LOCA::Epetra::Group | Extension of the NOX::Epetra::Group to LOCA |

NOX::Abstract::Group | NOX pure abstract interface to a "group"; i.e., a solution vector and the corresponding F-vector, Jacobian matrix, gradient vector, and Newton vector |

LOCA::LAPACK::Group | Extension of the NOX::LAPACK::Group to LOCA |

LOCA::Thyra::Group | Extension of the NOX::Thyra::Group to LOCA |

NOX::Thyra::Group | A simple example of a group structure, based on Thyra |

NOX::Petsc::Group | Concrete implementation of NOX::Abstract::Group for Petsc |

NOX::LAPACK::Group | A simple example of a group structure, based on BLAS/LAPACK |

LOCA::BorderedSolver::HouseholderQR | A convenience class to compute the QR factorization of a an extended multi-vector |

LOCA::Epetra::IdentityOp | An Epetra operator representing the identity matrix |

NOX::Direction::Utils::InexactNewton | Inexact Newton Utilities |

NOX::Solver::InexactTrustRegionBased | Newton-like solver using a trust region |

NOX::Multiphysics::DataExchange::Interface | Provides a set of interfaces for users to provide information about exchanging data between registered NOX solvers |

NOX::LAPACK::Interface | Virtual interface for NOX::BLAS::Group to provide a link to the external code for RHS and Jacobian fills |

LOCA::LAPACK::Interface | Virtual interface for LOCA::LAPACK::Group to provide a link to the external code for RHS and Jacobian fills |

NOX::Petsc::Interface | Used by NOX::Petsc::Group to provide a link to the external code for F and Jacobian evaluations (if needed) |

LOCA::Abstract::Iterator | An abstract interface for implementing iteration |

LOCA::SingularJacobianSolve::ItRef | This class computes the solution to using one step of iterative refinement |

NOX::Epetra::Interface::Jacobian | Used by NOX::Epetra to provide a link to the external code for Jacobian fills |

LOCA::AnasaziOperator::JacobianInverse | Anasazi operator for computing eigenvalues of the inverse-Jacobian |

LOCA::BorderedSolver::JacobianOperator | Bordered solver operator representing the Jacobian as implemented in the NOX::Abstract::Group |

LOCA::BorderedSolver::LAPACKDirectSolve | Bordered system solver strategy based on direct factorization |

LOCA::EigenvalueSort::LargestImaginary | Largest-imaginary sorting strategy |

LOCA::EigenvalueSort::LargestMagnitude | Largest-magnitude sorting strategy |

LOCA::EigenvalueSort::LargestReal | Largest-real sorting strategy |

LOCA::EigenvalueSort::LargestRealInverseCayley | Largest-Real Cayley sorting strategy |

LOCA::Epetra::LeftPreconditionedOp | An Epetra operator for implementing the operator |

LOCA::Epetra::TransposeLinearSystem::LeftPreconditioning | Method for solving the transpose of a linear system by transposing the preconditioner and switching to left preconditioning |

LOCA::Parameter::Library | Class to provide a centralized library for setting/retrieving numerical parameter values in application codes |

NOX::LAPACK::LinearSolver< T > | A simple linear solver for use by NOX::LAPACK::Group |

NOX::Epetra::LinearSystem | Pure virtual class interface for allowing different linear solvers to be used by the NOX::Epetra::Group |

NOX::Epetra::LinearSystemAztecOO | Concrete implementation of NOX::Epetra::LinearSolver for AztecOO |

NOX::Solver::LineSearchBased | Nonlinear solver based on a line search (i.e., damping) |

Anasazi::LOCASort | An implementation of the Anasazi::SortManager that performs a collection of common sorting techniques |

LOCA::BorderedSolver::LowerTriangularBlockElimination | Block elimination strategy for solving a block lower-triangular system |

LOCA::Epetra::LowRankUpdateOp | An Epetra operator for implementing the operator |

LOCA::Epetra::LowRankUpdateRowMatrix | An Epetra row matrix for implementing the operator |

NOX::Multiphysics::Solver::Manager | Manager class to control the instantiation of the objects derived from the NOX::Solver::Generic object |

LOCA::SingularJacobianSolve::Manager | Manager for all singular Jacobian solve computations |

LOCA::Epetra::Interface::MassMatrix | Used by LOCA::Epetra::Group to provide a link to the external code for the MassMatrix (coefficients of time dependent terms) |

NOX::LAPACK::Matrix< T > | A simple square matrix class for use by NOX::LAPACK::Group |

NOX::Epetra::MatrixFree | Concrete implementation for creating an Epetra_Operator Jacobian based on the Matrix-Free Newton-Krylov method |

NOX::StatusTest::MaxIters | Failure test based on the maximum number of nonlinear solver iterations |

LOCA::Epetra::ModelEvaluatorInterface | Wrapper for an EpetraExt::ModelEvaluator |

NOX::Epetra::ModelEvaluatorInterface | Wrapper for an EpetraExt::ModelEvaluator |

LOCA::TurningPoint::MinimallyAugmented::ModifiedConstraint | Implementation of LOCA::MultiContinuation::ConstraintInterfaceMVDX for computing turning points for the minimally augmented turning point formulation |

NOX::LineSearch::MoreThuente | More'-Thuente Line Search. Original code by Dianne O'Leary, modfified by Tammy Kolda and Roger Pawlowski for the NOX project. This version has been slightly optimized and also supports Homer Walker's work on adaptive forcing terms and Ared/Pred conditions. It also allows for arbitrary merit functions and norms to be supplied by the user |

LOCA::Extended::MultiAbstractGroup | LOCA abstract interface for extended groups, derived from the NOX::Abstract::Group, i.e., an abstract interface for "super" groups that have an underlying group component |

LOCA::MultiStepper | Implementation of LOCA::Abstract::Iterator for computing points along a continuation curve |

LOCA::MultiContinuation::MultiVecConstraint | Implementation of LOCA::MultiContinuation::ConstraintInterfaceMVDX for a simple linear multivector constraint |

NOX::MultiVector | Default implementation for NOX::Abstract::MultiVector using an array of NOX::Abstract::MultiVector's |

NOX::Thyra::MultiVector | Implementation of NOX::Abstract::MultiVector for Thyra multi-vectors |

LOCA::Extended::MultiVector | Implemenatation of the NOX::Abstract::MultiVector class for extended multi-vectors comprised of an arbitrary number of multi-vectors and scalars |

NOX::Epetra::MultiVector | Implementation of NOX::Abstract::MultiVector for Epetra multi-vectors |

NOX::Abstract::MultiVector | Abstract interface for multi-vectors used by NOX |

Anasazi::MultiVecTraits< double, NOX::Abstract::MultiVector > | Implementation of the Anasazi::MultiVecTraits for NOX::Abstract::MultiVectors |

LOCA::MultiContinuation::NaturalConstraint | Implementation of LOCA::MultiContinuation::ConstraintInterface for natural continuation |

LOCA::MultiContinuation::NaturalGroup | Specialization of LOCA::MultiContinuation::ExtendedGroup to natural continuation |

LOCA::BorderedSolver::Nested | Bordered system solver strategy for nested bordered systems |

NOX::Direction::Newton | Newton direction computation |

LOCA::SingularJacobianSolve::Nic | This class computes the solution to using the Nic method |

LOCA::SingularJacobianSolve::NicDay | This class computes the solution to using the Nic-Day method |

NOX::Direction::NonlinearCG | Calculates a search direction using the Nonlinear Conjugate Gradient method |

NOX::LineSearch::NonlinearCG | Use NonlinearCG linesearch |

NOX::StatusTest::NormF | Various convergence tests based on the norm of the residual |

NOX::StatusTest::NormUpdate | Various convergence tests based on the norm of the change in the solution vector, , between outer iterations |

NOX::StatusTest::NormWRMS | Convergence test based on the weighted root mean square norm fo the solution update between iterations |

LOCA::Bifurcation::PitchforkBord::StatusTest::NullVectorNormWRMS | A convergence test based on the weighted root-mean-square norm of the update to the null vector component for pitchfork location |

LOCA::Bifurcation::TPBord::StatusTest::NullVectorNormWRMS | A convergence test based on the weighted root-mean-square norm of the update to the null vector component for turning point location |

Anasazi::OperatorTraits< double, NOX::Abstract::MultiVector, LOCA::AnasaziOperator::AbstractStrategy > | Implementation of the Anasazi::OperatorTraits for LOCA operators |

NOX::Petsc::Options | Class to convert solver options from command line (or command input file) into a form usable by NOX |

LOCA::Continuation::StatusTest::ParameterResidualNorm | A convergence test based on the parameter component of the residual for continuation |

LOCA::Bifurcation::PitchforkBord::StatusTest::ParameterUpdateNorm | A convergence test based on the update of the parameter component for pitchfork location |

LOCA::Bifurcation::TPBord::StatusTest::ParameterUpdateNorm | A convergence test based on the update of the parameter component for turning point location |

LOCA::Continuation::StatusTest::ParameterUpdateNorm | A convergence test based on the update of the parameter component for continuation |

LOCA::ParameterVector | LOCA's container for holding a set of parameters that are used by the LOCA continuation routines |

LOCA::Pitchfork::MooreSpence::PhippsBordering | Moore-Spence pitchfork solver strategy based on "Phipps" bordering which is the 7-solve modified pitchfork bordering algorithm that uses bordered linear solves |

LOCA::TurningPoint::MooreSpence::PhippsBordering | Moore-Spence turning point solver strategy based on "Phipps" bordering which is the 5-solve modified turning point bordering algorithm that uses bordered linear solves |

NOX::LineSearch::Polynomial | A polynomial line search, either quadratic or cubic |

NOX::Epetra::Interface::Preconditioner | Used by NOX::Epetra to provide a link to the external code for Precondtioner fills |

NOX::Solver::PrePostOperator | Functor to process the pre/post operator object in the parameter list |

NOX::Abstract::PrePostOperator | NOX's pure virtual class to allow users to insert pre and post operations into nox's solvers (before and after the NOX::Solver::Generic::iterate() and NOX::Solver::Generic::solve() methods) |

NOX::LineSearch::Utils::Printing | Common line search utilites for printing line search information to the screen |

NOX::Random | A class to compute uniformly distributed random numbers in (-1,1) |

LOCA::MultiPredictor::Random | Random predictor strategy |

NOX::Epetra::Interface::Required | Supplies NOX with the set nonlinear equations |

LOCA::Epetra::Interface::Required | Used by LOCA::Epetra::Group to provide a link to the external code for setting problem parameters |

LOCA::MultiPredictor::Restart | Restart predictor strategy |

LOCA::TurningPoint::MooreSpence::SalingerBordering | Moore-Spence turning point solver strategy based on "Salinger" bordering. This is the classic 4-solve bordering method |

LOCA::Pitchfork::MooreSpence::SalingerBordering | Moore-Spence pitchfork solver strategy based on "Salinger" bordering. This is the classic 6-solve bordering method |

LOCA::Hopf::MooreSpence::SalingerBordering | Moore-Spence Hopf solver strategy based on "Salinger" bordering. This is the classic 5-solve Hopf bordering method |

LOCA::Thyra::SaveDataStrategy | Abstract interface class strategies to save continuation data |

NOX::Epetra::Scaling | Object to control scaling of vectors and linear systems |

LOCA::MultiPredictor::Secant | Secant predictor strategy |

NOX::Petsc::SharedJacobian | Shared Jacobian for NOX::Petsc::Group objects |

NOX::SharedObject< Object, Owner > | Holder for objects that are shared between NOX::Abstract::Groups |

LOCA::AnasaziOperator::ShiftInvert | Anasazi operator for computing generalized eigenvalues using shift-invert |

LOCA::Epetra::ShiftInvertInterface | Interface for LOCA::Epetra::ShifterInvertOperator |

LOCA::Epetra::ShiftInvertOperator | Epetra operator for |

LOCA::Bifurcation::PitchforkBord::StatusTest::SlackUpdateNorm | A convergence test based on the update of the slack variable component for pitchfork location |

NOX::LineSearch::Utils::Slope | Common line search utilites for computing the slope of a function |

LOCA::EigenvalueSort::SmallestImaginary | Smallest-imaginary sorting strategy |

LOCA::EigenvalueSort::SmallestMagnitude | Smallest-magnitude sorting strategy |

LOCA::EigenvalueSort::SmallestReal | Smallest-real sorting strategy |

LOCA::Pitchfork::MooreSpence::SolverFactory | Factory for creating solver objects for solving Moore-Spence pitchfork equations |

LOCA::Hopf::MooreSpence::SolverFactory | Factory for creating solver objects for solving Moore-Spence Hopf equations |

LOCA::TurningPoint::MooreSpence::SolverFactory | Factory for creating solver objects for solving Moore-Spence turning point equations |

LOCA::TurningPoint::MooreSpence::SolverStrategy | Abstract strategy for solving the Moore-Spence turning point equations |

LOCA::Pitchfork::MooreSpence::SolverStrategy | Abstract strategy for solving the Moore-Spence pitchfork equations |

LOCA::Hopf::MooreSpence::SolverStrategy | Abstract strategy for solving the Moore-Spence Hopf equations |

NOX::StatusTest::Stagnation | Failure test based on the convergence rate between nonlinear iterations |

LOCA::Parameter::StandardEntry< FunctorType, ValueType > | Standard parameter entry class using a function object |

NOX::Direction::SteepestDescent | Calculates the steepest descent direction |

LOCA::Stepper | Implementation of LOCA::Abstract::Iterator for computing points along a continuation curve |

LOCA::Parameter::SublistParser | Class to parse a parameter list for sublists |

NOX::MeritFunction::SumOfSquares | Sum of squares merit function |

LOCA::MultiPredictor::Tangent | Tangent predictor strategy |

NOX::Solver::TensorBased | Nonlinear solver based on a rank-1 tensor method |

LOCA::Epetra::Interface::TimeDependent | Used by LOCA::Epetra::Group to provide a link to the external code for computing the shifted matrix |

LOCA::Epetra::Interface::TimeDependentMatrixFree | Used by LOCA::Epetra::Group to provide a link to the external code for applying the shifted matrix in a matrix-free setting |

LOCA::Epetra::TransposeLinearSystem::TransposePreconditioner | Method for solving the transpose of a linear system by using the transpose of the preconditioner |

LOCA::Abstract::TransposeSolveGroup | Abstract group interface class for solving the transpose of the Jacobian |

NOX::Solver::TrustRegionBased | Newton-like solver using a trust region |

LOCA::BorderedSolver::UpperTriangularBlockElimination | Block elimination strategy for solving a block upper-triangular system |

NOX::Direction::UserDefinedFactory | Pure virtual interface for users to supply their own direction objects |

NOX::LineSearch::UserDefinedFactory | Pure virtual interface for users to supply their own line search objects |

NOX::Direction::UserDefinedFactoryT< T > | Concrete instantiation of a NOX::Direction::UserDefinedFactory object that uses the base objects only for constuction |

NOX::LineSearch::UserDefinedFactoryT< T > | Concrete instantiation of a NOX::LineSearch::UserDefinedFactory object that uses the base objects only for constuction |

NOX::Utils | Provides printing utilities |

NOX::Utils::Fill | Fill object - used to print the given character the number of times specified |

NOX::Utils::Sci | Sci object - used to print the given value with the specified precision |

NOX::Epetra::Vector | Implementation of NOX::Abstract::Vector for Epetra vectors |

NOX::Abstract::Vector | NOX's pure abstract vector interface for vectors that are used by the nonlinear solver |

NOX::Petsc::Vector | Implementation of NOX::Abstract::Vector for Petsc vectors |

LOCA::Extended::Vector | Implemenatation of the NOX::Abstract::Vector class for extended vectors comprised of an arbitrary number of vectors and scalars |

NOX::LAPACK::Vector | Implementation of NOX::Abstract::Vector for STL vector<double> (using LAPACK for some computations) |

NOX::Thyra::Vector | Implementation of NOX::Thyra::Vector |

NOX::Epetra::VectorSpace | Pure virtual base class for the vector space used by NOX::Epetra::Vectors |

NOX::Epetra::VectorSpaceL2 | Concrete class for an L2 vector space |

NOX::Epetra::VectorSpaceScaledL2 | Concrete class for a weighted L2 vector space |

LOCA::Solver::Wrapper | A wrapper class for wrapping a NOX solver |

LOCA::StatusTest::Wrapper | A wrapper class for wrapping a NOX status test |

LOCA::Epetra::xyztPrec | Preconditioner operator class for solving space-time (XYZT) systems |

Generated on Tue Oct 20 12:46:28 2009 for NOX by 1.4.7