Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

AbstractLinAlgPack
GenPermMatrixSliceIteratorPack
external_row_col_value_type	External storage of a row and column indice. This is required for creating a temporary in an assignment operation in a sorting algorithm (like std::sort(...))
row_col_value_type	Internal storage for the iterator of the row and column indices
row_col_iterator	This is a full random access iterator for accessing row and colunmn indices
SparseVectorUtilityPack
DoesNotExistException
NotSortedException
DuplicateIndexesException
OutOfRoomException
UnsizedException
NoNonZeroElementsException
SpVecIndexLookup	Sparse Vector Index Lookup and Caching class
InvalidInternalStateException
NoSpVecSetException
poss_type	Struct with members: size_type poss; ElementRelation rel;
COOMatrixPartitionedViewUtilityPack
Partition	Class for a partition or a set of continous partitions in a partitioned COO matrix
TransposedPartition	Class for the transpose of a Partition
UtilityPack
BasisSystem	Interface for the creation and maintainance of a basis matrix for a decomposition of linearlized constriants
SingularBasis
BasisSystemFactory	Interface for a factory object that will create BasisSystem objects
BasisSystemPerm	Interface for setting and selecting a basis from the Jacobian from a set of equations
compare_element_indexes_less	Ele1.index() < ele2.index()
compare_element_indexes_equal_to	Ele.index() == i
EtaVector	Create an eta vector (scaled by alpha = default 1)
GenPermMatrixSlice	Concrete matrix type to represent general permutation (mapping) matrices
InnerProduct	Abstract interface for inner products
InnerProductDot	Implements the inner product as the dot product
MatrixBase	Base class for all polymorphic matrices
IncompatibleMatrices	Thrown if matrices are incompatible
MatrixNonsing	Abstract base class for all nonsingular polymorphic matrices that can solve for linear system with but it may not be convienent to compute matrix vector products {abstract}
SingularMatrix	This exception will be thrown if it turns out at runtime that the matrix is numerically singular
MatrixOp	Base class for all matrices that support basic matrix operations
IncompatibleMatrices	Thrown if matrices are not compatible
MatNorm	Returned form calc_norm()
MethodNotImplemented	Thrown if a method is not implemented
MatrixOpNonsing	Abstract base class for all nonsingular polymorphic matrices that can be used to compute matrix-vector products and solve for linear systems efficiently
MatrixOpNonsingAggr	Aggregate matrix class pulling together a MatrixOp object and a MatrixNonsing object into a unified matrix object
MatrixOpSubView	Standard subclass for representing a sub, possibly transposed, view of a matrix
MatrixPermAggr	Aggregate matrix class for a matrix and its permuted view
MatrixSymDiag	Interface to all diagonal matrices {abstract}
MatrixSymInitDiag	Mix-in Interface for setting a matrix to a diagonal {abstract}
MatrixSymNonsing	Abstract base class for all polymorphic symmetrix nonsingular matrices that can be used to solve for linear systems relatively efficently
MatrixSymOp	Interface adding operations specific for a symmetric matrix {abstract}
MatrixSymOpNonsing	Abstract base class for all polymorphic symmetrix nonsingular matrices that can be used to compute matrix-vector products and solve for linear systems relatively efficently
MatrixSymSecant	Mix-in interface for all polymorphic symmetric matrices that support secant updating
UpdateFailedException
UpdateSkippedException
MultiVector	Interface for a collection of non-mutable vectors (multi-vector, matrix)
MultiVectorMutable	Interface for a collection of mutable vectors (multi-vector, matrix)
Permutation	Abstract interface to permutation matrices
SparseElement	Sparse storage element type
index_and_padding
SparseVectorSlice	Sparse Vector Slice class template
SparseVector	Sparse Vector class template
Vector	Abstract interface for immutable, finite dimensional, coordinate vectors {abstract}
VectorApplyOpSerialBase	This is a base class that is meant to be inherited by Vector subclasses that wish to call TSFCore::apply_op_serial() when vectors are in core
VectorMutable	Abstract interface for mutable coordinate vectors {abstract}
VectorMutableSubView	Concrete subclass for a sub-view of a VectorMutable object
VectorSpace	Abstract interface for objects that represent a space for mutable coordinate vectors
IncompatibleVectorSpaces	Thrown if vector spaces are incompatible
VectorSpaceFactory	Abstract interface for objects that can create vector spaces of a specified dimension
VectorSpaceSubSpace	Concrete subclass for a default sub-space of a vector
VectorSubView	Concrete subclass for a default sub-view implementation for a Vector object
NaNInfException
BasisSystemComposite	Simple BasisSystem subclass the case where the client sets up seperate C and N matrices
BasisSystemTester	Testing class for BasisSystem interface
BasisSystemTesterSetOptions	Set options for BasisSystemTester from an OptionsFromStream object
MatrixComposite	Matrix class for matrices composed out of a set of other matrices and vectors
SubMatrixEntry	Matrix list entry for a sub-matrix
SubVectorEntry	Vector list entry for a sub-vector
MatrixOpNonsingTester	Testing class for MatrixOpNonsing interface
MatrixSymDiagStd	Simple diagonal matrix class
PostMod	PostMod class to use with MemMngPack::AbstractFactorStd
MatrixSymIdent	Matrix subclass for a scaled identity matrix
MatrixZero	Implementation of a matrix with all zeros
VectorMutableBlocked	Concrete subclass for a blocked vector
VectorSpaceBlocked	VectorSpace subclass for the composite of one or more VectorSpace objects
VectorSpaceTester	Testing class for VectorSpace, Vector and VectorMutable
VectorSpaceTesterSetOptions	Set options for VectorSpaceTester from an OptionsFromStream object
PreConditionException	Base class for precondition exceptions
PostConditionException	Base class for postcondition exceptions
InputException	Base class for input exceptions (Preconditions)
SetupException	Base class for invalid setup for a class object when an exception is thrown
COOMatrix	Sparse Coordinate Matrix abstraction storage class
COOMatrixPartitionedView	COO Matrix partitioning view class
UninitializedException
COOMatrixPartitionViewSubclass	Implementation of MatrixOp abstract interface for COOMatrixWithPartitionedView::partition_type
COOMatrixWithPartitionedView	Aggregation of a COO matrix and a partitioned view of it
MatrixCOORTmplItfcItrEleView	Templated class for objects that support the SparseCOOElementTemplatInterface specification
MatrixCOORTmplItfcItr	Templated class for iterator returning objects that support the SparseCOOElementTemplatInterface specification
MatrixCOORTmplItfc	Templated class that supports the COOMatrixTemplateInterface template interface
MatrixSparseCOORSerial	Coordinate matrix subclass
ReleaseValRowColArrays	Subclass to delete dynamically allocated memory with delete[]
MatrixSymDiagSparseStd	Concrete subclass for a serial symmetric diagonal matrix with many zeros on the diagonal
MatrixWithOpConcreteEncap	This template class defines the storage for a concrete matrix class that operations are based on
SortByDescendingAbsValue	Function object class for sorting a sparse vectors in descending order by abs(v(i))
sparse_bounds_itr	Iterate through a set of sparse bounds
SparseCOOPtrElement	Sparse pointer element type for a COO matrix (val, ivect, jvect)
SparsePtrElement	Sparse pointer element type
TransSparseCOOElementViewIter	Templateded iterator for iterating through a set of COO Matix elements but viewing them in transpose
ElementView	Type for the object that is returned for the transpose sparse element
VectorDenseEncap	Extract a constant DenseLinAlgPack::DVectorSlice view of a Vector object
VectorDenseMutableEncap	Extract a non-const DenseLinAlgPack::DVectorSlice view of a VectorMutable object
MatrixConvertToSparse	Mix-in interface for extracing explicit elements from a sparse matrix in one of several Fortran compatible formats
MatrixConvertToSparseEncap	Sparse conversion subclass based on views of a MatrixExtractSparseElements object
MatrixExtractInvCholFactor	Mix-in Interface for extracting the inverse cholesky factor of a dense symmetric positive definite matrix
MatrixExtractSparseElements	Interface for extracting nonzero elements from a banded subregion of a permuted sparse matrix in one of several Fortran compatible formats
MatrixLoadSparseElements	Mix-in interface for loading nonzero elements into a sparse matrix data structure
MatrixNonsingSerial	Abstract base class for all AbstractLinAlgPack::MatrixNonsing objects implemented in shared memory space
MatrixOpGetGMS	Abstract interface that allows the extraction of a const DMatrixSlice view of an abstract matrix
MatrixDenseEncap	Helper class type that simplifies the usage of the MatrixOpGetGMS interface for clients
MatrixOpGetGMSMutable	Abstract interface that allows the extraction of a non-const DMatrixSlice view of an abstract matrix
MatrixDenseMutableEncap	Helper class type that simplifies the usage of the MatrixOpGetGMSMutable interface for clients
MatrixOpGetGMSTri	Mix-in interface that allows the extraction of a const DenseLinAlgPack::DMatrixSliceTri view of an non-singular abstract matrix
MatrixDenseTriEncap	Helper class type that simplifies the usage of the MatrixOpGetGMSTri interface for clients
MatrixOpNonsingSerial	Abstract base class for all serial nonsingular polymorphic matrices that can be used to compute matrix-vector products and solve for linear systems efficiently
MatrixOpSerial	Base class for all matrices implemented in a shared memory address space
MatrixSymAddDelUpdateable	Mix-in Interface for updating a serial symmetric matrix by adding and deleting rows and columns
Inertia	Struct for the inertia of the matrix
MaxSizeExceededException	Thrown if the maximum size is exceeded in augment_update(...)
PivotTolerances	Struct for pivot tolerances to be used when initializing, and augmenting and deleting rows and columns
SingularUpdateException	Thrown if the matrix is singular and should not have been
WarnNearSingularUpdateException	Thrown if the matrix is near singular as a warning
WrongInertiaUpdateException	Thrown if matrix has the wrong inertia from what was expected
MatrixSymDenseInitialize	Mix-in Interface for initializing a matrix with a dense symmetric matrix
MatrixSymDiagSparse	Abstract base class for all serial symmetric diagonal matrices with significant zeros along the diagonal
MatrixSymNonsingSerial	Abstract base class for all serial polymorphic symmetrix nonsingular matrices that can be used to solve for linear systems relatively efficiently
MatrixSymOpGetGMSSym	Abstract interface that allows the extraction of a const DenseLinAlgPack::DMatrixSliceSym view of an abstract matrix
MatrixDenseSymEncap	Helper class type that simplifies the usage of the MatrixSymOpGetGMSSym interface for clients
MatrixSymOpGetGMSSymMutable	Abstract interface that allows the extraction of a non-const DenseLinAlgPack::DMatrixSliceSym view of a symmetry abstract matrix
MatrixDenseSymMutableEncap	Helper class type that simplifies the usage of the MatrixSymOpGetGMSSymMutable interface for clients
MatrixSymOpNonsingSerial	Abstract base class for all serial polymorphic symmetric nonsingular matrices that can be used to compute matrix-vector products and solve for linear systems relatively efficiently
MatrixSymOpSerial	Abstract base class for all AbstractLinAlgPack::MatrixSymOp objects implemented in shared memory space
MultiVectorMutableCols	Default subclass for MultiVectorMutable implemented using columns of separate abstract vectors
MultiVectorMutableDense	MultiVectorMutable "Adapter" subclass for DenseLinAlgPack::DMatrixSlice or DenseLinAlgPack::DMatrix object
VectorMutableDense	DVector "Adaptor" subclass for DenseLinAlgPack::DVectorSlice or DenseLinAlgPack::DVector objects
VectorSpaceFactorySerial	Abstract interface for objects that can create vector spaces of a specified dimension
VectorSpaceSerial	Subclass for serial vector space objects that create VectorMutableDense vector and MultiVectorMutableDense multi-vector objects
BasisSystemFactoryStd	Default implementation for BasisSystemPermDirectSparse obejcts using DirectSparseSolver object
BasisSystemPermDirectSparse	Permutatble basis system subclass that uses a direct sparse solver
DirectSparseSolver	Abstract interface to serial direct sparse linear solvers
BasisMatrix	Abstract class for objects that represent the factorized matrix and can be used to solve for different right-hand-sides
FactorizationFailure
FactorizationStructure	Abstract class for objects that represent the factorization structure of a particular matrix
IncompatibleMatrixStructureException
InvalidObjectType
NoCurrentBasisException
UnsymmetricRankDeficientException
DirectSparseSolverDense	Concreate sparse solver subclass that uses the dense LAPACK routines
BasisMatrixDense	Implements the BasisMatrix object for Dense
FactorizationNonzerosDense	Stores the factorization nonzeros for Dense
FactorizationStructureDense	Stores the factorization structure for Dense
DirectSparseSolverImp	Implementation node class for DirectSparseSolver that takes care of the memory management details
BasisMatrixImp	Implementation node subclass that combines factorization structure and factorization nonzeros into a single basis matrix object
FactorizationNonzeros	Abstract class for objects that represent the factorization nonzeros of a particular matrix
DirectSparseSolverMA28	Concreate sparse solver subclass that uses MA28
BasisMatrixMA28	Implements the BasisMatrix object for MA28
FactorizationNonzerosMA28	Stores the factorization nonzeros for MA28
FactorizationStructureMA28	Stores the factorization structure for MA28
DirectSparseSolverMA28SetOptions	Set options for DirectSparseSolverMA28 from OptionsFromStream object
MatrixScaling_Strategy	Abstract interface for sparse matrix scaling strategies
InnerProductThyra	Implements the inner product using Thyra::VectorSpaceBase::scalarProd()
MatrixOpNonsingThyra	MatrixOpNonsing adapter subclass for Thyra::Nonlin::LinearOpWithSolve
MatrixOpThyra	MatrixOp adapter subclass for Thyra::LinearOpBase
MultiVectorMutableThyra	MultiVectorMutable adapter subclass for Thyra::MultiVectorBase
VectorMutableThyra	VectorMutable adapter subclass for Thyra::VectorBase
VectorSpaceFactoryThyra	VectorSpaceFactory adapter subclass for Thyra::VectorSpaceBase
VectorSpaceThyra	VectorSpace adapter subclass for Thyra::VectorSpaceBase<value_type>
BLAS_C_Decl
BLAS_Cpp
ConstrainedOptPack
QPSchurPack
ConstraintsRelaxedStd	Constraints subclass that is used to represent generic varaible bounds, and general inequality and equality constraints
MatrixConstraints	Matrix type for A_bar
QPInitFixedFreeStd	General (and flexible) implementation class for a QPSchur QP problem
vector_one_based_checked	Utility class for a ranged check vector
QP	Represents the QP to be solved by QPSchur {abstract}
Constraints	Represents the extra constraints in the QP to be satisfied by the schur complement QP solver QPSchur {abstract}
DecompositionSystem	This class abstracts a decomposition choice for the quasi-range space Y and null space Z matrices for a linearly independent set of columns of Gc
InvalidMatrixType
SingularDecomposition
TestFailed
DecompositionSystemCoordinate	Coordinate variable reduction subclass
DecompositionSystemOrthogonal	Orthogonal variable reduction subclass
DecompositionSystemTester	Testing class for DecompositionSystem interface
DecompositionSystemTesterSetOptions	Set options for DecompositionSystemTester from an OptionsFromStream object
DecompositionSystemVarReduct	Specialization of DecompositionSystem for variable reduction decompositions
DecompositionSystemVarReductImp	Specialization node implementation subclass of DecompositionSystem for variable reduction decompositions
DecompositionSystemVarReductPerm	Specialization interface of DecompositonSystem that allows basis permutations
DecompositionSystemVarReductPermStd	Concreate subclass of DecompositionSystemVarReductPerm that uses an aggregate DecompostionSystemVarReductImp object
DirectLineSearch_Strategy	Abstract strategy interface for 1D line searches {abstract}
NotDescentDirection	Thrown if the direction vector d_k is not a descent direction for the merit funciton
DirectLineSearchArmQuad_Strategy	Performs a line search using the Armijo condition and uses quadratic interpolation to select each new alpha
DirectLineSearchArmQuad_StrategySetOptions	Set options for DirectLineSearchArmQuad_Strategy from a OptionsFromStream object
MeritFuncCalc	Abstract iterface for n-D merit functions {abstract}
MeritFuncCalc1D	Abstracts a 1D merit function {abstract}
MeritFuncCalc1DQuadratic	Adds the ability to compute phi(alpha) at alpha of a given set of vectors
MeritFuncCalcNLE	Adds the ability to compute phi(c(x)) at x directly instead of having to compute c first. This class uses an aggregate NLP to perform the computations of c(x)
MeritFuncCalcNLP	Adds the ability to compute phi(f(x),c(x),h(x)) at x directly instead of having to compute f, c and h first. This class uses an aggregate NLP to perform the computations of f(x) c(x) and h(x)
MeritFuncNLE	Base class for all merit functions for systems of NonLinear Equations (NLE) {abstract}
InvalidInitialization
MeritFuncNLESqrResid	A merit function for the square of the constriant values
MeritFuncNLP	Base class for all merit functions for NonLinear Programs (NLP) {abstract}
InvalidInitialization
MeritFuncNLPDirecDeriv	This class provides a mix-in interface for allowing subclass merit functions to compute the directional 1D derivative at a base point
MeritFuncNLPL1	The L1 merit function
MeritFuncNLPModL1	The modified L1 merit function using different penatly parameters for each constriant
MeritFuncPenaltyParam	This class provides interface for setting and retrieving a penalty parameter that many merit functions use {abstract}
MeritFuncPenaltyParams	This class provides interface for setting and retrieving a penalty parameter that many merit functions use {abstract}
CanNotResize
MatrixDecompRangeOrthog	Matrix subclass for variable reduction orthogonal matrix R = Gc(:,con_decomp)'*Y
MatrixGenBanded	Matrix subclass for general (possibly singular) banded matrices
MatrixHessianRelaxed	Represents a symmetric Hessian matrix with a relaxation variable added
MatrixHessianSuperBasic	Matrix class that represents a hessian matrix where only the super submatrix for the super basic variables need be nonsingular
MatrixHessianSuperBasicInitDiagonal	Matrix class that adds the ability to initialize to a diagonal to a MatrixHessainSuperBasic object
MatrixIdentConcat	Matrix class for a matrix vertically concatonated with an identity matrix {abstract}
MatrixIdentConcatStd	Concrete implementation class for a matrix vertically concatonated with an identity matrix
MatrixKKTFullSpaceRelaxed	Implementation of a KKT matrix factorized in the full space
InvalidMatrixType
NotInitializedException
SingularMatrixException
MatrixSymAddDelBunchKaufman	This class maintains the factorization of symmetric indefinite matrix using a Bunch & Kaufman factorization
MatrixSymAddDelUpdateableWithOpNonsingular	Interface for updating a symmetric matrix and its factorization by adding and deleting rows and columns and preforming operations with it
MatrixSymHessianRelaxNonSing	Matrix class for non-singular Hessian matrix augmented with a terms for "Big M" relaxation variables
MatrixSymIdentitySerial	Matrix class for a serial scaled identity matrix
MatrixSymPosDefBandedChol	Matrix subclass for banded symmetric positive definite matrices and their Cholesky factors
MatrixSymPosDefInvCholFactor	Implementation of MatrixOp abstract interface for SymInvCholMatrix
MatrixSymPosDefLBFGS	Implementation of limited Memory BFGS matrix for arbitrary vector spaces
PostMod	PostMod class to use with MemMngPack::AbstractFactorStd
MatrixVarReductImplicit	Implements D = - inv(C) * N for a variable reduction projection
VariableBoundsTester	Tests that a set of variables are within their bounds
VariableBoundsTesterSetOptions	Set options for VariableBoundsTester from an OptionsFromStream object
QPSchur	Solves a Quadratic Program with a dual QP method using a schur complement factorization
ActiveSet	Represents and manages the active set for the QPSchur algorithm
DualInfeasibleException	Thrown if during the course of the primal-dual iteration a non-dual feasible point if found
InconsistantConstraintsException	Thrown if constraints are inconsistant (no feasible region)
NumericalInstabilityException	Thrown if there is some numerical instability
TestFailed	Thrown if a test failed
U_hat_t	Represents the matrix U_hat
QPSchurInitKKTSystemHessianFixedFree	Implementation of initial KKT system using the Hessian for the free variables only
QPSchurInitKKTSystemHessianFull	Implementation of initial KKT system for all variables initially free and Ko = G
QPSchurInitKKTSystemHessianRelaxed	Implementation of initial KKT system where all original variables are free and all the relaxation variables are fixed
QPSchurInitKKTSystemHessianSuperBasic	Implementation of initial KKT system for all variables initially fixed and free where #Ko = B_RR#
QPSolverRelaxed	Solves Quadratic Programs (QPs) of several different forms while allowing a relaxation of the constraints
Infeasible	Thrown if the QP is infeasible
InvalidInput	Thrown if there is invalid input
TestFailed	Thrown if a test failed
Unbounded	Thrown if the QP is unbounded
QPSolverRelaxedQPKWIK	Solves Quadratic Programming (QP) problem using the primal-dual active-set solver QPKWIK
QPSolverRelaxedQPOPTSOL	Node base clase for the primal QP solvers QPOPT and QPSOL
QPSolverRelaxedQPSchur	Solves Quadratic Programming (QP) problems using QPSchur
InitKKTSystem	Interface for the object that forms the initial KKT system {abstract}
ReinitKKTSystem	Interface for the object that can reform an initial KKT system dynamically {abstract}
QPSolverRelaxedQPSchurSetOptions	Set options for QPSolverRelaxedQPSchur from an OptionsFromStream object
QPSolverRelaxedTester	Tests the optimality conditions of the output from a QPSolverRelaxed object
QPSolverRelaxedTesterSetOptions	Set options for QPSolverRelaxedTester from an OptionsFromStream object
QPSolverStats	Class for storing statistics about a run of a (active set?) QP solver
DenseLinAlgLAPack
FactorizationException	Exception for factorization error
DenseLinAlgPack	Test function for COOMatrix and COOMatrixSlice
LinAlgPackIO
InputException	Exception throw on input error
bit_flags
ios_format_memento
bound_format
const_bound_format
format
MatlabPack
TestingPack
Testing
NaNInfException
DMatrixSliceTriEle
DMatrixSliceTri
DMatrixSliceSym
DMatrixSlice
DMatrix
VectorSliceTmpl
VectorTmpl
IVector
EpetraExt
string >
string >
vector< T > >
FortranTypes
InvalidFileNameException	Thrown if the file name is not a valid ASCII string
OpenException	Thrown if the open operation fails
InputStreamHelperPack
IterationPack
TestingPack
Algorithm	Acts as the central hub for an iterative algorithm
AlgorithmInterrupted	Thrown if Algorithm was interrupted by the user
AlreadyExists	Thrown if name already exists
assoc_steps_ele_t
DoesNotExist	Thrown if name or id does not exist
InvalidConfigChange	Thrown if a member function is called while this is in an invalid running state.
InvalidControlProtocal	Thrown if an invalid control protocal is used
InvalidRunningState	Thrown if a member function is called while this is in an invalid running state.
name_comp
step_ptr_and_name
AlgorithmSetOptions	Set options for Algorithm from an OptionsFromStream object
AlgorithmState	Abstacts a set of iteration quantities for an iterative algorithm
AlreadyExists	Thrown if name already exists
DoesNotExist	Thrown if name or id does not exist
AlgorithmStep	Base type for all objects that perform steps in an Algorithm
AlgorithmTracker	Used to ouput iteration results and other information
AlgorithmTrackerComposite	This class acts a composite container for other AlgorithmTracker objects
CastIQMemberBase	Base class for some of the implementation features of CastIQMember
CastIQMember	Template class to be used to lookup an interation quantity, cast it to an IterQuantityAccess<T> object and cache the iq_id for fast access later
IterQuantity	Iterface for information about Iteration Quantities
NoStorageAvailable	Thrown memory if attempted to be set that storage can not be allocated to
QuanityNotSet	Thrown when memory access is attempted when it has not yet been updated
IterQuantityAccess	Interface to typed iteration quantities
IterQuantityAccessContiguous	Iteration Quanities subclass for contiguous iterations
InvalidTypeCastException
IterQuantityAccessDerivedToBase
AlgorithmStepTesting	Testing class
AlgorithmTrackTesting	Testing class
MinorLoop1Step
ControledLoop1Step
RuntimeConfigChangeStep
LAPACK_C_Decl
LAPACK_Cpp
LinAlgOpPack
MA28_Cpp
MA28CommonBlockReferences
MA28CommonBlockStorage
MA28Solver	MA28 Basic Encapsulation Class
MA28_CppDecl
Fortran
MA28ED_struct
MA28FD_struct
MA28GD_struct
MA28HD_struct
MA30ED_struct
MA30FD_struct
MA30GD_struct
MA30HD_struct
MA30ID_struct
MC23BD_struct
MemMngPack
ReleaseResource	Abstract interface for releasing an object when it is not needed anymore {abstract}
ReleaseResource_ref_count_ptr	Template class that implements ReleaseResource interface for a RCP<T> object
MoochoPack
PBFGSPack
NLPAlgoConfigIP	This is a do all configuration class for NLPAlgo
SOptionValues
NLPAlgoConfigMamaJama	This is a do all configuration class for NLPAlgo
SOptionValues
MoochoSolver	Universal interface to a MOOCHO solver
DecompositionSystemStateStepBuilderStd	Standard builder object for creating DecompositionSystem, EvalNewPoint Step and other objects and setting up some of the state object
SOptionValues
InfeasibleConstraints
LineSearchFailure	Thrown if a line search failure occurs
TestFailed	Thrown if a runtime test failed
QPFailure	Thrown if a the QP failed and was not corrected
IpState
NLPAlgo	RSQP Algorithm control class
NLPAlgoClientInterface	Interface that smart clients use to set the algorithm configuration object that defines the rSQP algorithm to be used to solve the NLP
NLPAlgoConfig	Interface for objects responsible for configuring an rSQP algorithm
InvalidNLPType	Thrown if NLP type is incompatible with this config
NLPAlgoContainer	Implementation for NLPAlgo solver
NLPAlgoInterface	Interface NLPAlgoContainer uses to access NLPAlgo
NLPAlgoState	Reduced space SQP state encapsulation interface
InvalidType	Thrown if an iteration quantity is of an invalid type
iq_id_encap
NLPSolverClientInterface	This is the most basic interface that clients use to solve an NLP
InvalidSetup	Thrown if the setup is not valid
NLPSolverClientInterfaceSetOptions	Set options for NLPSolverClientInterface from an OptionsFromStream object
act_set_stats_iq_member	Class for object that attempts to return an IterQuantityAccess<ActSetStats> from an AlgorithmState object with the name act_set_stats_name
ActSetStats	Class for storing statistics about the changes in the active set of an SQP algorithm
ActSetStats_AddedStep	Updates the active set statistics for the current iteration
BFGSUpdate_Strategy	Strategy interface which contains the guts for a dampened BFGS update
BFGSUpdate_StrategySetOptions	Set options for BFGSUpdate_Strategy from an OptionsFromStream object
CalcD_vStep_Step	Calculates dvl_k = mu*invXl_k*e - vl_k - invXl_k*Vl_k*d_k and dvu_k = mu*invXu_k*e - vu_k + invXu_k*Vu_k*d_k
CalcDFromYPY_Step	Calculates d = Ypy
CalcDFromYPYZPZ_Step	Calculates d = Ypy + Zpz
CalcDFromZPZ_Step	Calculates d = Zpz
CalcLambdaIndepStd_AddedStep	Calculates the lagrange multipliers for the independent constraints
CalcReducedGradLagrangianStd_AddedStep	Calculates the reduced gradient of the Lagrangian rGL = rGf + Z' * nu + GcUP' * lambda(equ_undecomp) + GhUP' * lambdaI(inequ_undecomp)
CheckConvergence_Strategy	Strategy interface for performing convergence checks
CheckConvergence_StrategySetOptions	Set options for CheckConvergence_Strategy from an OptionsFromStream object
CheckConvergenceIP_Strategy	Implementation of CheckConvergence_Strategy interface
CheckConvergenceStd_AddedStep	Check for convergence
CheckConvergenceStd_AddedStepSetOptions	Set options for CheckConvergenceStd_AddedStep from an OptionsFromStream object
CheckConvergenceStd_Strategy	Implementation of CheckConvergence_Strategy interface
CheckDecompositionFromPy_Step	Check if the decomposition is going singular and if it is select a new decomposition
CheckDecompositionFromRPy_Step	Check if the decomposition is going singular and if it is select a new decomposition
CheckDescentQuasiNormalStep_Step	Checks for descent in the decomposed equality constraints with respect to the range space step Ypy using finite differences
CheckSkipBFGSUpdateStd_Step	Checks if a BFGS update should be preformed
CheckSkipBFGSUpdateStd_StepSetOptions	Set options for CheckSkipBFGSUpdateStd_Step from a OptionsFromStream object
CrossTermExactStd_Step	W_k = Z_k' * HL_k * Ypy_k
DampenCrossTermStd_Step	Compute a dampening term zeta_k for the cross term w_k such that Gf'*Z*pz <= 0
DecompositionSystemHandler_Strategy	Interface for range/null decomposition handling
DecompositionSystemHandlerSelectNew_Strategy	Interface for range/null decomposition handling
DecompositionSystemHandlerStd_Strategy	Subclass for updating the range/null space decomposition using the base DecompositionSystem interface only
DecompositionSystemHandlerVarReductPerm_Strategy	Subclass for selecting and updating the range/null space decomposition using the DecompositionSystemVarReductPerm interface
EvalNewPointStd_Step	Standard new point evaluation step class
EvalNewPointTailoredApproach_Step	Base class for evaluating a new point for the "Tailored Approach"
EvalNewPointTailoredApproach_StepSetOptions	Set options for EvalNewPointTailoredApproach_Step from an OptionsFromStream object
EvalNewPointTailoredApproachCoordinate_Step	Implements "coordinate" decompostion for "Tailored Appraoch"
EvalNewPointTailoredApproachOrthogonal_Step	Implements "orthogonal" decompostion for "Tailored Appraoch"
FeasibilityStep_Strategy	Abstract interface for a strategy object that will compute a step that will improve feasibility (at least descent) {abstract}
FeasibilityStepReducedStd_Strategy	Implements the feasibility step computation for reduced space SQP
FeasibilityStepReducedStd_StrategySetOptions	Set options for FeasibilityStepReducedStd_Strategy from an OptionsFromStream object
InitFinDiffReducedHessian_Step	Initializes the reduced hessian using a single finite difference along the null space of the constraints
InitFinDiffReducedHessian_StepSetOptions	Set options for InitFinDiffReducedHessian_Step from an OptionsFromStream object
LineSearch2ndOrderCorrect_Step	Implements second order correction
LineSearch2ndOrderCorrect_StepSetOptions	Set options for LineSearch2ndOrderCorrect_Step from an OptionsFromStream object
LineSearchDirect_Step	Delegates the line search to a DirectLineSearch_Strategy object
LineSearchFailureNewDecompositionSelection_Step	Directs the selection of a new decomposition if the line search fails
FilterEntry
LineSearchFilter_Step	Filter line-search step class
LineSearchFullStep_Step	Takes the full step x_kp1 = x_k + d_k (d_k = Ypy_k + Zpz_k)
LineSearchFullStepAfterKIter_Step	Changes from a line search step to just taking full steps after full_steps_after_k iterations
LineSearchNLE_Step	Delegates the line search to a DirectLineSearch_Strategy object
LineSearchWatchDog_Step	Implements watchdog line search
LineSearchWatchDog_StepSetOptions	Set options for LineSearchWatchDog_Step from a OptionsFromStream object
MeritFunc_DummyUpdate_Step	Simply updates merit_func_nlp_k = merit_func_nlp_km1
MeritFunc_ModifiedL1LargerSteps_AddedStep	This function increases the penalty parameters of the modifed L1 merit function to allow for larger steps by taking advantage of constraints that are reduced for a full step
MeritFunc_ModifiedL1LargerSteps_AddedStepSetOptions	Set options for MeritFunc_ModifiedL1LargerSteps_AddedStep from a OptionsFromStream object
MeritFunc_PenaltyParamsUpdateWithMult_AddedStep	Updates a set of penalty parameters for a merit function as: mu(j) = max( mu(j), |lambda_k(j)| )
MeritFunc_PenaltyParamUpdate_AddedStep	Base class for steps that update penalty parameters based on the Lagrange multipliers lambda_k (or some approximation to them)
MeritFunc_PenaltyParamUpdate_AddedStepSetOptions	Set options for MeritFunc_PenaltyParamUpdate_AddedStep from a OptionsFromStream object
MeritFunc_PenaltyParamUpdateGuts_AddedStep	Updates the penalty parameter for a merit function as: mu_k = max( mu_km1, min_mu )
MeritFunc_PenaltyParamUpdateMultFree_AddedStep	Specializes the update of the penalty parameter for a merit function as: min_mu = |(Gf_k+nu_k)'* Ypy_k| / ||c_k||1
MeritFunc_PenaltyParamUpdateWithMult_AddedStep	Specializes the update of the penalty parameter for a merit function as: min_mu =||lambda||inf
MoochoTrackerConsoleStd	This rSQP iteration class provides a tablular output suitable for an 80 char wide console
MoochoTrackerStatsStd	This is a simple track class for getting statistics about a solved (or not solved) NLP
MoochoTrackerSummaryStd	This class simply outputs the convergence information for each iteration
MoochoTrackerXMLSummary	This class outputs an XML summary file of the algorithm results and performance
NewDecompositionSelection_Strategy	Abstract interface for an object that directs the selection of a new decomposition
NewDecompositionSelectionStd_Strategy	Just force the decomposition system object to select a new decomposition and let everyone else fend for themselves
NumFixedDepIndep_AddedStep	Computes and outputs the number of fixed variables from the dependent and independent set.
PostEvalNewPointBarrier_Step	Standard evaluation step class for extra parameters in primal/dual barrier method
PostProcessBarrierLineSearch_Step	Fraction to boundary rule for calculating alpha max
PreEvalNewPointBarrier_Step	Standard evaluation step class for extra parameters in primal/dual barrier method
PreEvalNewPointBarrier_StepSetOptions
PreProcessBarrierLineSearch_Step	Fraction to boundary rule for calculating alpha max
PreProcessBarrierLineSearch_StepSetOptions
qp_solver_stats_iq_member	Class for object that attempts to return an IterQuantityAccess<QPSolverStats> from an AlgorithmState object with the name qp_solver_stats_name
QPFailureReinitReducedHessian_Step	Directs the algorithm to reinitalize the reduced Hessian on the event of a QP failure
quasi_newton_stats_iq_member	Class for object that attempts to return an IterQuantityAccess<QuasiNewtonStats> from an AlgorithmState object with the name quasi_newton_stats_name
QuasiNewtonStats	Class for storing statistics about the Quasi-Newton updating
QuasiNormalStepStd_Step	Calculates the range space step by, solving for py = -inv(R)*c(equ_decomp), then setting Ypy = Y * py
QuasiRangeSpaceStep_Strategy	Abstract interface for a strategy object that will compute a step that will approximalty solve a range space subproblem {abstract}
QuasiRangeSpaceStepStd_Strategy	Strategy class for computing a quasi-range-space step by solving the approximate range space problem directly
QuasiRangeSpaceStepTailoredApproach_Strategy	Strategy class for computing a quasi range space step for the tailored approach NLP interface
ReducedGradientStd_Step	Computes the reducecd gradient of the objective rGf_k = Z_k' * Gf_k
ReducedHessianExactStd_Step	Computes the exact reduced Hessian rHL_k = Z_k' * HL_k * Z_k
ReducedHessianSecantUpdate_Strategy	Strategy interface for performing secant updates {abstract}
ReducedHessianSecantUpdateBFGSFull_Strategy	Perform BFGS updates on full reduced Hessian
ReducedHessianSecantUpdateBFGSProjected_Strategy	Perform BFGS updates on only the free independent (super basic) variables
ReducedHessianSecantUpdateBFGSProjected_StrategySetOptions	Set options for ReducedHessianSecantUpdateBFGSProjected_Strategy from a OptionsFromStream object
ReducedHessianSecantUpdateLPBFGS_Strategy	Perform BFGS updates on only the free independent (super basic) variables
ReducedHessianSecantUpdateLPBFGS_StrategySetOptions	Set options for ReducedHessianSecantUpdateBFGSProjected_Strategy from a OptionsFromStream object
ReducedHessianSecantUpdateStd_Step	Updates rHL_k using a secant update
ReducedHessianSerialization_Step	Serializes rHL_k to and from a file
SetDBoundsStd_AddedStep	Computes the bounds for the QP subproblem from the NLP bounds
TangentialStepIP_Step	Null Space Step for Interior Point algorithm
TangentialStepWithInequStd_Step	Solves the reduced QP subproblem with bounds and/or general inequalities
TangentialStepWithInequStd_StepSetOptions	Set options for TangentialStepWithInequStd_Step from an OptionsFromStream object
TangentialStepWithoutBounds_Step	Solves the unconstrained QP subproblem: min qp_grad' * pz + (1/2) * pz' * rHL * pz
UpdateBarrierParameter_Step	Barrier Parameter (mu) Update
UpdateBarrierParameter_StepSetOptions
UpdateReducedSigma_Step	Standard class for updating the reduced sigma for interior point optimization
UpdateReducedSigma_StepSetOptions
MoochoThyraSolver	MOOCHO NLP Solver class for models represented through Thyra::ModelEvaluator
NLPInterfacePack
NLP	NLP interface class {abstract}
IncompatibleType	Thrown if an incompatible object is used
InvalidInitialization	Thrown from initialize() if some logical error occured
NoBounds	Thrown some bounds do not existe
UnInitialized	Thrown if any member functions are called before initialize() has been called
ZeroOrderInfo	Struct for objective and constriants (pointer)
NLPDirect	Interface providing only direct first order sensitivity information
NLPFirstOrder	NLP first order information interface class {abstract}
FirstOrderInfo	Struct for zero and first order quantities (pointers)
NLPObjGrad	NLP interface class that adds gradient information for the objective function {abstract}
ObjGradInfo	Struct for gradient (objective), objective and constriants (pointers)
NLPSecondOrder	NLP second order information interface class {abstract}
SecondOrderInfo	Struct for zero, first and second order quantities (pointers)
NLPVarReductPerm	NLP interface class that adds variable and constriant permutations for variable reduction basis selections
InvalidBasis	Thrown if an invalid basis selection is made
NLPDirectTester	Concrete class that tests the computed values of the NLPDirect interface using finite differences
NLPDirectTesterSetOptions	Set options for NLPDirectTester from an OptionsFromStream object
NLPFirstDerivTester	Concrete class that tests the derivatives using finite differences
NLPFirstDerivTesterSetOptions	Set options for NLPFirstDerivTester from an OptionsFromStream object
NLPTester	Testing class for base NLP interface
NLPTesterSetOptions	Set options for NLPTester from an OptionsFromStream object
CalcFiniteDiffProd	Strategy interface for computing the product of the derivatives of the functions of an NLP along given directions using finite differences
CalcFiniteDiffProdSetOptions	Set options for CalcFiniteDiffProd from an OptionsFromStream object
NLPBarrier	Simple wrapper that provides an objective fn with the barrier term included
NLPSerialPreprocess	NLP node implementation subclass for preprocessing and basis manipulation
InconsistantBounds	Thrown if xl(i) > xu(i)
ObjGradInfoSerial	Struct for serial gradient (objective), objective and constriants (pointers)
ZeroOrderInfoSerial	Struct for objective and constriants (pointer) as serial vectors
NLPSerialPreprocessExplJac	NLP node subclass complementing NLPSerialPreprocess for explicit Jacobians
FirstOrderExplInfo	Struct for zero and explicit first order quantities that subclass must fill in
ExampleNLPBanded	Simple scalable serial NLP subclass
ExampleNLPDirect	Simple example NLP subclass to illustrate how to implement the NLPDirect interface for a specialized NLP
ExampleNLPObjGrad	Simple example NLP subclass to illustrate how to implement the NLPObjGrad interface for a specialized NLP
ExampleBasisSystem	Subclass of BasisSystem for example NLP
ExampleNLPFirstOrder	Simple example NLP subclass to illustrate how to implement the NLPFirstOrder interface for a specialized NLP
NLPWBCounterExample	NLP subclass for the Waechter and Biegler Counter Example
NLPDirectThyraModelEvaluator	Implement the NLPFirstOrder interface using a Thyra::ModelEvaluator object
NLPFirstOrderThyraModelEvaluator	Implement the NLPFirstOrder interface using a Thyra::ModelEvaluator object
NLPThyraModelEvaluatorBase	Implements the base NLP interface using a Thyra::ModelEvaluator object
OptionsFromStreamPack
OptionsFromStreamUtilityPack
false_bool_t
OptionsGroup	Class used to encapsulate options belonging an options group
CommandLineOptionsFromStreamProcessor	Reads from a file and/or parses from the commandline to initalize an OptionsFromStream object
OptionsFromStream	Extracts options from a text stream and then allows convenient access to them
InputStreamError	Thrown if there is an input error
InputException	Input from stream error
AccessException	Access error
SetOptionsFromStream	Abstact interface for objects that have options to be set that are contained in an OptionsFromStreamObject
SetOptionsFromStreamNode	Node class for setting options from a stream
SetOptionsToTargetBase	Templated node class manipulating a reference to a target object who will have its options set.
StringToIntMap	Map a string to an enumeration
AlreadyExists
DoesNotExist
ProfileHackPack
ProfileTiming	Helper class that takes care of timing
QPKWIK_Output
set_output
QPOPT_CppDecl
Fortran
RangePack
Range1D	. One-based subregion index range class
RTOpPack
SubVectorT1B	Class for a non-mutable sub-vector
MutableSubVectorT1B	Class for a mutable sub-vector
SubMultiVectorT1B	Class for a non-mutable sub-multi-vector (submatrix)
MutableSubMultiVectorT1B	Class for a mutable sub-vector
RTOpC	Adapter subclass that uses a RTOp_RTOp object
ReductTargetC	Adapter subclass for RTOp_ReductTarget
RTOpCPostMod
SerializationPack
Serializable	Mixin interface for objects that can be serialized to and from a stream
SpecialASCII
StandardCompositionRelationshipsPack
NoRefSet	Thrown when the reference has not been set
StopWatchPack
stopwatch	Simple stopwatch object
StrideIterPack
stride_iter	C++ Standard Library compatable iterator class for accesing nonunit stride arrays of data
TestingHelperPack
Teuchos
details
MatrixMarket
Trilinos
Details
RTOP_MPI_Status
RTOp_MutableSubVector
RTOp_obj_type_vtbl_t
RTOp_ROp_find_nan_inf_reduct_obj_t
RTOp_ROp_get_sub_vector_rng_t
RTOp_ROp_max_inequ_viol_reduct_obj_t
RTOp_ROp_max_near_feas_step_reduct_obj_t
RTOp_RTOp
RTOp_RTOp_vtbl_t
RTOp_Server_op_class_name
RTOp_SparseSubVector
RTOp_SubVector
RTOp_TOp_random_vector_bnd_t
RTOp_TOp_set_sub_vector_state_t
RTOp_value_index_type
RTOp_value_value_type