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

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::TimeDependent::AbstractGroup | Interface to underlying groups for time dependent systems |

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

LOCA::Bifurcation::HopfBord::AbstractGroup | Interface to underlying groups for Hopf point calculations |

LOCA::Bifurcation::TPBord::AbstractGroup | Interface to underlying groups for turning point calculations |

LOCA::Continuation::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::Extended::AbstractGroup | 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::Homotopy::AbstractGroup | Interface to underlying groups for homotopy calculations |

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::BorderedSystem::AbstractStrategy | Abstract interface class for solving bordered sets of linear equations |

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

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

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

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

NOX::Parameter::AnyPtr | Implementation of NOX::Parameter::Arbitrary to hold pointers |

NOX::Parameter::Arbitrary | Support for Arbitrary parameters |

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

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

LOCA::Continuation::ArcLengthGroup | Concrete implementation of a LOCA::Continuation::Group for pseudo arc-length continuation |

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

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

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

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

Broyden | Interface to modified Broyden problem defined in Broyden.C |

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

BrusselatorProblemInterface | LOCA-LAPACK problem interface for the Brussselator problem |

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

ChanProblemInterface | LOCA-LAPACK problem interface for the Chan problem |

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

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

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::Predictor::Constant | Constant predictor computation class |

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

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

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::SaveEigenData::DefaultStrategy | Default strategy for saving eigenvector/value data |

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

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

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

NOX::Parameter::DirectionConstructor | Support for user-defined directions |

NOX::Parameter::DirectionConstructorT< T > | Templated instantiation of NOX::Parameter::DirectionConstructor |

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 |

NOX::Parameter::Entry | Manipulating single parameters, including sublists |

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

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

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

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

LOCA::TurningPoint::MooreSpence::ExtendedGroup | |

LOCA::Bifurcation::HopfBord::ExtendedGroup | LOCA's Hopf point group. Implements the bordering algorithm to solve turning point equations |

LOCA::Bifurcation::PitchforkBord::ExtendedGroup | LOCA's generic pitchfork group. Implements the bordering algorithm to solve pitchfork equations |

LOCA::Bifurcation::TPBord::ExtendedGroup | LOCA's generic turning point group. Implements the bordering algorithm to solve turning point equations |

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

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

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

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

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

LOCA::Bifurcation::HopfBord::ExtendedVector | Vector class to hold solution vectors, Newton vectors, etc. for Hopf equations |

LOCA::Bifurcation::PitchforkBord::ExtendedVector | Vector class to hold solution vectors, Newton vectors, etc. for pitchfork equations |

LOCA::Bifurcation::TPBord::ExtendedVector | Vector class to hold solution vectors, Newton vectors, etc. for turning point equations |

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

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::Epetra::Factory | Implementation of the LOCA::Abstract::Factory for Epetra groups |

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

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

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

LOCA::BorderedSystem::Factory | Factory for creating BorderedSystem 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 |

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

NOX::EpetraNew::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 |

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

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

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

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

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

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

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

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

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

LOCA::Predictor::Generic | Generic predictor direction interface |

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

LOCA::StepSize::Generic | Generic step size control 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::AnasaziOperator::Generic | Generic Anasazi operator interface |

LOCA::BorderedSystem::Generic | Generic bordered solver interface |

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

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

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

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

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

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

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

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::Abstract::Group | Compatiblity class for AbstractGroup hierarchy |

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::Continuation::HouseholderGroup | Arc-length continuation group using Householder projection |

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

LOCA::Epetra::Interface | Used by LOCA::Epetra::Group to provide a link to the external code for RHS and Jacobian fills ()if needed |

NOX::Epetra::Interface | Used by NOX::Epetra::Group to provide a link to the external code for RHS and Jacobian fills ()if needed |

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

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 |

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::EpetraNew::Interface::Jacobian | Used by NOX::EpetraNew to provide a link to the external code for Jacobian fills |

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

NOX::Epetra::JacobiPreconditioner | Concrete implementation of the NOX::Epetra::Preconditioner class for Jacobi (Diagonal) Preconditioning |

LOCA::BorderedSystem::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::Parameter::Library | Class to provide a centralized library for setting/retrieving numerical parameter values in application codes |

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

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

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

NOX::Parameter::LineSearchConstructor | Support for user-defined line searches |

NOX::Parameter::LineSearchConstructorT< T > | Templated instantiation of NOX::Parameter::LineSearchConstructor |

NOX::Parameter::List | Manipulating lists of parameters |

Anasazi::LOCAMatrix | Implementation of the Anasazi::Matrix for LOCA operators |

Anasazi::LOCAMultiVec | Implementation of the Anasazi::MultiVec for NOX::Abstract::Vectors |

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

LOCA::MultiContinuation::Manager | A manager class for creating different continuation groups |

NOX::Direction::Manager | Manager for all direction computations |

NOX::LineSearch::Manager | Manager for all different line searches |

LOCA::Predictor::Manager | Manager for all predictor direction computations |

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

LOCA::StepSize::Manager | Manager for step size control strategies |

LOCA::AnasaziOperator::Manager | Manager for all Anasazi operators |

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

LOCA::Bifurcation::Manager | A manager class for creating different bifurcation groups |

LOCA::BorderedSystem::Manager | Manager for all bordered system solver methods. See LOCA::BorderedSystem::Generic for a description of what these classes compute |

LOCA::Continuation::Manager | A manager class for creating different continuation groups |

LOCA::EpetraNew::Interface::MassMatrix | Used by LOCA::EpetraNew::Group to provide a link to the external code for the MassMatrix (coefficient of time dependent terms). This is used for: Hopf bifurcation tracking, linear stability analysis, and space-time solutions (xyzt) |

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

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

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 |

NOX::Parameter::MeritFunction | Derived from NOX::Parameter::Arbitrary class to support a user defined merit function that can be passed to line searches through the parameter list |

LOCA::Bifurcation::TPBord::ModifiedBorderingGroup | Turning point group implementing a modified bordering algorithm |

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::Epetra::MultiVector | Implementation of NOX::Abstract::MultiVector for Epetra 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::Abstract::MultiVector | Abstract interface for multi-vectors used by NOX |

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

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

LOCA::Continuation::NaturalGroup | Concrete implementation of a LOCA::Continuation::Group for natural continuation |

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

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 |

LOCA::Bifurcation::TPBord::NicDayModifiedBorderingGroup | Turning point group implementing a modified bordering algorithm |

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 |

NOX::Epetra::Operator | Pure virtual class for creating an Operator for NOX. This class derives from the Epetra_Operator class with a single additional method: compute(). This allows the user to supply their own preconditioner or jacobian 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::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 |

PitchforkProblemInterface | LOCA-LAPACK problem interface for a 1D finite difference discretization of a simple PDE exhibiting a pitchfork bifurcation |

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

NOX::EpetraNew::Interface::Preconditioner | Used by NOX::EpetraNew 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::Parameter::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 |

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

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

LOCA::Predictor::Random | Random predictor computation class |

NOX::Parameter::Rcp | Implementation of NOX::Parameter::Arbitrary to ref-count pointers |

LOCA::EpetraNew::Interface::Required | Used by LOCA::EpetraNew::Group to provide a link to the external code for RHS and Jacobian fills if needed |

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

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

LOCA::Predictor::Restart | Restart predictor computation class |

Rosenbrock | An interface to the example described in Rosenbrock.C |

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

NOX::Epetra::Scaling | Object to control scaling of a linear system |

NOX::EpetraNew::Scaling | Object to control scaling of a linear system |

LOCA::Predictor::Secant | Secant predictor computation class |

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 |

NOX::Epetra::SharedOperator | Shared operator object for NOX::Epetra::Group objects |

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::TPBord::SingularSolveGroup | Concrete class that provides concrete implementations of the singular Jacobian solve methods of the LOCA::Bifurcation::TPBord::AbstractGroup |

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::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 |

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 |

LOCA::Predictor::Tangent | Tangent predictor computation class |

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

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

NOX::Parameter::Teuchos2NOX | |

LOCA::EpetraNew::Interface::TimeDependent | Used by LOCA::EpetraNew::Group to provide a link to the external code for RHS and Jacobian fills if needed |

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

NOX::Parameter::UserNorm | Derived from NOX::Parameter::Arbitrary class to support a user defined norm that can be passed in throught the parameter list |

LOCA::Utils | Provides static parallel communication and printing utilities |

NOX::Utils | Provides parallel communication and 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::Abstract::Vector | NOX's pure abstract vector interface for vectors that are used by the nonlinear solver |

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

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::Epetra::Vector | Implementation of NOX::Abstract::Vector for Epetra vectors |

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

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

Generated on Thu Sep 18 12:40:40 2008 for NOX by 1.3.9.1