MOOCHO (Single Doxygen Collection) Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
OptionsFromStreamPack::AccessExceptionAccess error
MoochoPack::act_set_stats_iq_memberClass for object that attempts to return an IterQuantityAccess<ActSetStats> from an AlgorithmState object with the name act_set_stats_name
MoochoPack::ActSetStatsClass for storing statistics about the changes in the active set of an SQP algorithm
MoochoPack::ActSetStats_AddedStepUpdates the active set statistics for the current iteration
IterationPack::AlgorithmActs as the central hub for an iterative algorithm
IterationPack::Algorithm::AlgorithmInterruptedThrown if Algorithm was interrupted by the user
IterationPack::Algorithm::AlreadyExistsThrown if name already exists
IterationPack::Algorithm::assoc_steps_ele_t
IterationPack::Algorithm::DoesNotExistThrown if name or id does not exist
IterationPack::Algorithm::InvalidConfigChangeThrown if a member function is called while this is in an invalid running state.
IterationPack::Algorithm::InvalidControlProtocalThrown if an invalid control protocal is used
IterationPack::Algorithm::InvalidRunningStateThrown if a member function is called while this is in an invalid running state.
IterationPack::Algorithm::name_comp< T_ele >
IterationPack::Algorithm::step_ptr_and_name< T_Step_ptr >
IterationPack::AlgorithmSetOptionsSet options for Algorithm from an OptionsFromStream object
IterationPack::AlgorithmStateAbstacts a set of iteration quantities for an iterative algorithm
IterationPack::AlgorithmState::AlreadyExistsThrown if name already exists
IterationPack::AlgorithmState::DoesNotExistThrown if name or id does not exist
IterationPack::AlgorithmStepBase type for all objects that perform steps in an Algorithm
IterationPack::AlgorithmStepTestingTesting class
IterationPack::AlgorithmTrackerUsed to ouput iteration results and other information
IterationPack::AlgorithmTrackerCompositeThis class acts a composite container for other AlgorithmTracker objects
IterationPack::AlgorithmTrackTestingTesting class
AbstractLinAlgPack::BasisSystemInterface for the creation and maintainance of a basis matrix for a decomposition of linearlized constriants
AbstractLinAlgPack::BasisSystem::SingularBasis
AbstractLinAlgPack::BasisSystemCompositeSimple BasisSystem subclass the case where the client sets up seperate C and N matrices
AbstractLinAlgPack::BasisSystemFactoryInterface for a factory object that will create BasisSystem objects
AbstractLinAlgPack::BasisSystemFactoryStdDefault implementation for BasisSystemPermDirectSparse obejcts using DirectSparseSolver object
AbstractLinAlgPack::BasisSystemPermInterface for setting and selecting a basis from the Jacobian from a set of equations
AbstractLinAlgPack::BasisSystemPermDirectSparsePermutatble basis system subclass that uses a direct sparse solver
AbstractLinAlgPack::BasisSystemTesterTesting class for BasisSystem interface
AbstractLinAlgPack::BasisSystemTesterSetOptionsSet options for BasisSystemTester from an OptionsFromStream object
MoochoPack::BFGSUpdate_StrategyStrategy interface which contains the guts for a dampened BFGS update
MoochoPack::BFGSUpdate_StrategySetOptionsSet options for BFGSUpdate_Strategy from an OptionsFromStream object
DenseLinAlgPack::LinAlgPackIO::bit_flags
DenseLinAlgPack::LinAlgPackIO::bound_format< T >
MoochoPack::CalcD_vStep_StepCalculates 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
MoochoPack::CalcDFromYPY_StepCalculates d = Ypy
MoochoPack::CalcDFromYPYZPZ_StepCalculates d = Ypy + Zpz
MoochoPack::CalcDFromZPZ_StepCalculates d = Zpz
NLPInterfacePack::CalcFiniteDiffProdStrategy interface for computing the product of the derivatives of the functions of an NLP along given directions using finite differences
NLPInterfacePack::CalcFiniteDiffProdSetOptionsSet options for CalcFiniteDiffProd from an OptionsFromStream object
MoochoPack::CalcLambdaIndepStd_AddedStepCalculates the lagrange multipliers for the independent constraints
MoochoPack::CalcReducedGradLagrangianStd_AddedStepCalculates the reduced gradient of the Lagrangian rGL = rGf + Z' * nu + GcUP' * lambda(equ_undecomp) + GhUP' * lambdaI(inequ_undecomp)
IterationPack::CastIQMember< T >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
IterationPack::CastIQMemberBaseBase class for some of the implementation features of CastIQMember
MoochoPack::CheckConvergence_StrategyStrategy interface for performing convergence checks
MoochoPack::CheckConvergence_StrategySetOptionsSet options for CheckConvergence_Strategy from an OptionsFromStream object
MoochoPack::CheckConvergenceIP_StrategyImplementation of CheckConvergence_Strategy interface
MoochoPack::CheckConvergenceStd_AddedStepCheck for convergence
MoochoPack::CheckConvergenceStd_AddedStepSetOptionsSet options for CheckConvergenceStd_AddedStep from an OptionsFromStream object
MoochoPack::CheckConvergenceStd_StrategyImplementation of CheckConvergence_Strategy interface
MoochoPack::CheckDecompositionFromPy_StepCheck if the decomposition is going singular and if it is select a new decomposition
MoochoPack::CheckDecompositionFromRPy_StepCheck if the decomposition is going singular and if it is select a new decomposition
MoochoPack::CheckDescentQuasiNormalStep_StepChecks for descent in the decomposed equality constraints with respect to the range space step Ypy using finite differences
MoochoPack::CheckSkipBFGSUpdateStd_StepChecks if a BFGS update should be preformed
MoochoPack::CheckSkipBFGSUpdateStd_StepSetOptionsSet options for CheckSkipBFGSUpdateStd_Step from a OptionsFromStream object
OptionsFromStreamPack::CommandLineOptionsFromStreamProcessorReads from a file and/or parses from the commandline to initalize an OptionsFromStream object
AbstractLinAlgPack::compare_element_indexes_equal_to< T_Element >Ele.index() == i
AbstractLinAlgPack::compare_element_indexes_less< T_Element >Ele1.index() < ele2.index()
DenseLinAlgPack::LinAlgPackIO::const_bound_format< T >
ConstrainedOptPack::QPSchurPack::ConstraintsRepresents the extra constraints in the QP to be satisfied by the schur complement QP solver QPSchur {abstract}
ConstrainedOptPack::QPSchurPack::ConstraintsRelaxedStdConstraints subclass that is used to represent generic varaible bounds, and general inequality and equality constraints
ConstrainedOptPack::QPSchurPack::ConstraintsRelaxedStd::MatrixConstraintsMatrix type for A_bar
IterationPack::ControledLoop1Step
AbstractLinAlgPack::ConvertToCSCAbstract interface for inserting a matrix into a Fortran compatable compressed column sparse matrix format
AbstractLinAlgPack::COOMatrixSparse Coordinate Matrix abstraction storage class
AbstractLinAlgPack::COOMatrixPartitionedView< T_Indice, T_Value >COO Matrix partitioning view class
AbstractLinAlgPack::COOMatrixPartitionedView< T_Indice, T_Value >::UninitializedException
AbstractLinAlgPack::COOMatrixPartitionViewSubclassImplementation of MatrixOp abstract interface for COOMatrixWithPartitionedView::partition_type
AbstractLinAlgPack::COOMatrixWithPartitionedViewAggregation of a COO matrix and a partitioned view of it
AbstractLinAlgPack::COOMatrixWithPartitionedViewSubclassImplementation of MatrixOp abstract interface for COOMatrixWithPartitionedView
MoochoPack::CrossTermExactStd_StepW_k = Z_k' * HL_k * Ypy_k
MoochoPack::DampenCrossTermStd_StepCompute a dampening term zeta_k for the cross term w_k such that Gf'*Z*pz <= 0
ConstrainedOptPack::DecompositionSystemThis 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
ConstrainedOptPack::DecompositionSystem::InvalidMatrixType
ConstrainedOptPack::DecompositionSystem::SingularDecomposition
ConstrainedOptPack::DecompositionSystem::TestFailed
ConstrainedOptPack::DecompositionSystemCoordinateCoordinate variable reduction subclass
MoochoPack::DecompositionSystemHandler_StrategyInterface for range/null decomposition handling
MoochoPack::DecompositionSystemHandlerSelectNew_StrategyInterface for range/null decomposition handling
MoochoPack::DecompositionSystemHandlerStd_StrategySubclass for updating the range/null space decomposition using the base DecompositionSystem interface only
MoochoPack::DecompositionSystemHandlerVarReductPerm_StrategySubclass for selecting and updating the range/null space decomposition using the DecompositionSystemVarReductPerm interface
ConstrainedOptPack::DecompositionSystemOrthogonalOrthogonal variable reduction subclass
MoochoPack::DecompositionSystemStateStepBuilderStdStandard builder object for creating DecompositionSystem, EvalNewPoint Step and other objects and setting up some of the state object
MoochoPack::DecompositionSystemStateStepBuilderStd::SOptionValues
ConstrainedOptPack::DecompositionSystemTesterTesting class for DecompositionSystem interface
ConstrainedOptPack::DecompositionSystemTesterSetOptionsSet options for DecompositionSystemTester from an OptionsFromStream object
ConstrainedOptPack::DecompositionSystemVarReductSpecialization of DecompositionSystem for variable reduction decompositions
ConstrainedOptPack::DecompositionSystemVarReductImpSpecialization node implementation subclass of DecompositionSystem for variable reduction decompositions
ConstrainedOptPack::DecompositionSystemVarReductPermSpecialization interface of DecompositonSystem that allows basis permutations
ConstrainedOptPack::DecompositionSystemVarReductPermStdConcreate subclass of DecompositionSystemVarReductPerm that uses an aggregate DecompostionSystemVarReductImp object
ConstrainedOptPack::DirectLineSearch_StrategyAbstract strategy interface for 1D line searches {abstract}
ConstrainedOptPack::DirectLineSearch_Strategy::NotDescentDirectionThrown if the direction vector d_k is not a descent direction for the merit funciton
ConstrainedOptPack::DirectLineSearchArmQuad_StrategyPerforms a line search using the Armijo condition and uses quadratic interpolation to select each new alpha
ConstrainedOptPack::DirectLineSearchArmQuad_StrategySetOptionsSet options for DirectLineSearchArmQuad_Strategy from a OptionsFromStream object
AbstractLinAlgPack::DirectSparseSolverAbstract interface to serial direct sparse linear solvers
AbstractLinAlgPack::DirectSparseSolver::BasisMatrixAbstract class for objects that represent the factorized matrix and can be used to solve for different right-hand-sides
AbstractLinAlgPack::DirectSparseSolver::FactorizationFailure
AbstractLinAlgPack::DirectSparseSolver::FactorizationStructureAbstract class for objects that represent the factorization structure of a particular matrix
AbstractLinAlgPack::DirectSparseSolver::IncompatibleMatrixStructureException
AbstractLinAlgPack::DirectSparseSolver::InvalidObjectType
AbstractLinAlgPack::DirectSparseSolver::NoCurrentBasisException
AbstractLinAlgPack::DirectSparseSolver::UnsymmetricRankDeficientException
AbstractLinAlgPack::DirectSparseSolverDenseConcreate sparse solver subclass that uses the dense LAPACK routines
AbstractLinAlgPack::DirectSparseSolverDense::BasisMatrixDenseImplements the BasisMatrix object for Dense
AbstractLinAlgPack::DirectSparseSolverDense::FactorizationNonzerosDenseStores the factorization nonzeros for Dense
AbstractLinAlgPack::DirectSparseSolverDense::FactorizationStructureDenseStores the factorization structure for Dense
AbstractLinAlgPack::DirectSparseSolverImpImplementation node class for DirectSparseSolver that takes care of the memory management details
AbstractLinAlgPack::DirectSparseSolverImp::BasisMatrixImpImplementation node subclass that combines factorization structure and factorization nonzeros into a single basis matrix object
AbstractLinAlgPack::DirectSparseSolverImp::FactorizationNonzerosAbstract class for objects that represent the factorization nonzeros of a particular matrix
AbstractLinAlgPack::DirectSparseSolverMA28Concreate sparse solver subclass that uses MA28
AbstractLinAlgPack::DirectSparseSolverMA28::BasisMatrixMA28Implements the BasisMatrix object for MA28
AbstractLinAlgPack::DirectSparseSolverMA28::FactorizationNonzerosMA28Stores the factorization nonzeros for MA28
AbstractLinAlgPack::DirectSparseSolverMA28::FactorizationStructureMA28Stores the factorization structure for MA28
AbstractLinAlgPack::DirectSparseSolverMA28SetOptionsSet options for DirectSparseSolverMA28 from OptionsFromStream object
DenseLinAlgPack::DMatrix
DenseLinAlgPack::DMatrixSlice
DenseLinAlgPack::DMatrixSliceSym
DenseLinAlgPack::DMatrixSliceTri
DenseLinAlgPack::DMatrixSliceTriEle
AbstractLinAlgPack::SparseVectorUtilityPack::DoesNotExistException
AbstractLinAlgPack::SparseVectorUtilityPack::DuplicateIndexesException
AbstractLinAlgPack::EtaVectorCreate an eta vector (scaled by alpha = default 1)
MoochoPack::EvalNewPointStd_StepStandard new point evaluation step class
MoochoPack::EvalNewPointTailoredApproach_StepBase class for evaluating a new point for the "Tailored Approach"
MoochoPack::EvalNewPointTailoredApproach_StepSetOptionsSet options for EvalNewPointTailoredApproach_Step from an OptionsFromStream object
MoochoPack::EvalNewPointTailoredApproachCoordinate_StepImplements "coordinate" decompostion for "Tailored Appraoch"
MoochoPack::EvalNewPointTailoredApproachOrthogonal_StepImplements "orthogonal" decompostion for "Tailored Appraoch"
NLPInterfacePack::ExampleBasisSystemSubclass of BasisSystem for example NLP
NLPInterfacePack::ExampleNLPBandedSimple scalable serial NLP subclass
NLPInterfacePack::ExampleNLPDirectSimple example NLP subclass to illustrate how to implement the NLPDirect interface for a specialized NLP
NLPInterfacePack::ExampleNLPFirstOrderSimple example NLP subclass to illustrate how to implement the NLPFirstOrder interface for a specialized NLP
NLPInterfacePack::ExampleNLPObjGradSimple example NLP subclass to illustrate how to implement the NLPObjGrad interface for a specialized NLP
AbstractLinAlgPack::GenPermMatrixSliceIteratorPack::external_row_col_value_type< T >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(...))
DenseLinAlgLAPack::FactorizationExceptionException for factorization error
OptionsFromStreamPack::OptionsFromStreamUtilityPack::false_bool_t
MoochoPack::FeasibilityStep_StrategyAbstract interface for a strategy object that will compute a step that will improve feasibility (at least descent) {abstract}
MoochoPack::FeasibilityStepReducedStd_StrategyImplements the feasibility step computation for reduced space SQP
MoochoPack::FeasibilityStepReducedStd_StrategySetOptionsSet options for FeasibilityStepReducedStd_Strategy from an OptionsFromStream object
MoochoPack::FilterEntry
DenseLinAlgPack::LinAlgPackIO::format
AbstractLinAlgPack::GenPermMatrixSliceConcrete matrix type to represent general permutation (mapping) matrices
MoochoPack::InfeasibleConstraints
MoochoPack::InitFinDiffReducedHessian_StepInitializes the reduced hessian using a single finite difference along the null space of the constraints
MoochoPack::InitFinDiffReducedHessian_StepSetOptionsSet options for InitFinDiffReducedHessian_Step from an OptionsFromStream object
AbstractLinAlgPack::InnerProductAbstract interface for inner products
AbstractLinAlgPack::InnerProductDotImplements the inner product as the dot product
AbstractLinAlgPack::InnerProductThyraImplements the inner product using Thyra::VectorSpaceBase::scalarProd()
OptionsFromStreamPack::InputExceptionInput from stream error
AbstractLinAlgPack::InputExceptionBase class for input exceptions (Preconditions)
DenseLinAlgPack::LinAlgPackIO::InputExceptionException throw on input error
FortranTypes::InvalidFileNameExceptionThrown if the file name is not a valid ASCII string
IterationPack::InvalidTypeCastException
DenseLinAlgPack::LinAlgPackIO::ios_format_memento
MoochoPack::IpState
IterationPack::IterQuantityIterface for information about Iteration Quantities
IterationPack::IterQuantity::NoStorageAvailableThrown memory if attempted to be set that storage can not be allocated to
IterationPack::IterQuantity::QuanityNotSetThrown when memory access is attempted when it has not yet been updated
IterationPack::IterQuantityAccess< T_info >Interface to typed iteration quantities
IterationPack::IterQuantityAccessContiguous< T_info >Iteration Quanities subclass for contiguous iterations
DenseLinAlgPack::IVector
MoochoPack::LineSearch2ndOrderCorrect_StepImplements second order correction
MoochoPack::LineSearch2ndOrderCorrect_StepSetOptionsSet options for LineSearch2ndOrderCorrect_Step from an OptionsFromStream object
MoochoPack::LineSearchDirect_StepDelegates the line search to a DirectLineSearch_Strategy object
MoochoPack::LineSearchFailureThrown if a line search failure occurs
MoochoPack::LineSearchFailureNewDecompositionSelection_StepDirects the selection of a new decomposition if the line search fails
MoochoPack::LineSearchFilter_StepFilter line-search step class
MoochoPack::LineSearchFullStep_StepTakes the full step x_kp1 = x_k + d_k (d_k = Ypy_k + Zpz_k)
MoochoPack::LineSearchFullStepAfterKIter_StepChanges from a line search step to just taking full steps after full_steps_after_k iterations
MoochoPack::LineSearchNLE_StepDelegates the line search to a DirectLineSearch_Strategy object
MoochoPack::LineSearchWatchDog_StepImplements watchdog line search
MoochoPack::LineSearchWatchDog_StepSetOptionsSet options for LineSearchWatchDog_Step from a OptionsFromStream object
MA28_Cpp::MA28CommonBlockReferences
MA28_Cpp::MA28CommonBlockStorage
MA28_CppDecl::MA28ED_struct
MA28_CppDecl::MA28FD_struct
MA28_CppDecl::MA28GD_struct
MA28_CppDecl::MA28HD_struct
MA28_Cpp::MA28SolverMA28 Basic Encapsulation Class
MA28_CppDecl::MA30ED_struct
MA28_CppDecl::MA30FD_struct
MA28_CppDecl::MA30GD_struct
MA28_CppDecl::MA30HD_struct
MA28_CppDecl::MA30ID_struct
AbstractLinAlgPack::MatrixBaseBase class for all polymorphic matrices
AbstractLinAlgPack::MatrixBase::IncompatibleMatricesThrown if matrices are incompatible
AbstractLinAlgPack::MatrixBasisNonbasisThis is the interface to a basis and an nonbasis matrix
AbstractLinAlgPack::MatrixBasisNonbasis::MatrixNotAvailableBase class for postcondition exceptions
AbstractLinAlgPack::MatrixBasisNonbasisStdThis is the interface to a basis and an nonbasis matrix
AbstractLinAlgPack::MatrixCompositeMatrix class for matrices composed out of a set of other matrices and vectors
AbstractLinAlgPack::MatrixComposite::SubMatrixEntryMatrix list entry for a sub-matrix
AbstractLinAlgPack::MatrixComposite::SubVectorEntryVector list entry for a sub-vector
AbstractLinAlgPack::MatrixConvertToSparseMix-in interface for extracing explicit elements from a sparse matrix in one of several Fortran compatible formats
AbstractLinAlgPack::MatrixConvertToSparseEncapSparse conversion subclass based on views of a MatrixExtractSparseElements object
AbstractLinAlgPack::MatrixCOORTmplItfc< T_Scalar, T_Index >Templated class that supports the COOMatrixTemplateInterface template interface
AbstractLinAlgPack::MatrixCOORTmplItfcItr< T_Scalar, T_Index >Templated class for iterator returning objects that support the SparseCOOElementTemplatInterface specification
AbstractLinAlgPack::MatrixCOORTmplItfcItrEleView< T_Scalar, T_Index >Templated class for objects that support the SparseCOOElementTemplatInterface specification
ConstrainedOptPack::MatrixDecompRangeOrthogMatrix subclass for variable reduction orthogonal matrix R = Gc(:,con_decomp)'*Y
AbstractLinAlgPack::MatrixDenseEncapHelper class type that simplifies the usage of the MatrixOpGetGMS interface for clients
AbstractLinAlgPack::MatrixDenseMutableEncapHelper class type that simplifies the usage of the MatrixOpGetGMSMutable interface for clients
AbstractLinAlgPack::MatrixDenseSymEncapHelper class type that simplifies the usage of the MatrixSymOpGetGMSSym interface for clients
AbstractLinAlgPack::MatrixDenseSymMutableEncapHelper class type that simplifies the usage of the MatrixSymOpGetGMSSymMutable interface for clients
AbstractLinAlgPack::MatrixDenseTriEncapHelper class type that simplifies the usage of the MatrixOpGetGMSTri interface for clients
AbstractLinAlgPack::MatrixExtractInvCholFactorMix-in Interface for extracting the inverse cholesky factor of a dense symmetric positive definite matrix
AbstractLinAlgPack::MatrixExtractSparseElementsInterface for extracting nonzero elements from a banded subregion of a permuted sparse matrix in one of several Fortran compatible formats
ConstrainedOptPack::MatrixGenBandedMatrix subclass for general (possibly singular) banded matrices
ConstrainedOptPack::MatrixHessianRelaxedRepresents a symmetric Hessian matrix with a relaxation variable added
ConstrainedOptPack::MatrixHessianSuperBasicMatrix class that represents a hessian matrix where only the super submatrix for the super basic variables need be nonsingular
ConstrainedOptPack::MatrixHessianSuperBasicInitDiagonalMatrix class that adds the ability to initialize to a diagonal to a MatrixHessainSuperBasic object
ConstrainedOptPack::MatrixIdentConcatMatrix class for a matrix vertically concatonated with an identity matrix {abstract}
ConstrainedOptPack::MatrixIdentConcatStdConcrete implementation class for a matrix vertically concatonated with an identity matrix
ConstrainedOptPack::MatrixKKTFullSpaceRelaxedImplementation of a KKT matrix factorized in the full space
ConstrainedOptPack::MatrixKKTFullSpaceRelaxed::InvalidMatrixType
ConstrainedOptPack::MatrixKKTFullSpaceRelaxed::NotInitializedException
ConstrainedOptPack::MatrixKKTFullSpaceRelaxed::SingularMatrixException
AbstractLinAlgPack::MatrixLoadSparseElementsMix-in interface for loading nonzero elements into a sparse matrix data structure
AbstractLinAlgPack::MatrixNonsingAbstract 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}
AbstractLinAlgPack::MatrixNonsing::SingularMatrixThis exception will be thrown if it turns out at runtime that the matrix is numerically singular
AbstractLinAlgPack::MatrixNonsingSerialAbstract base class for all AbstractLinAlgPack::MatrixNonsing objects implemented in shared memory space
AbstractLinAlgPack::MatrixOpBase class for all matrices that support basic matrix operations
AbstractLinAlgPack::MatrixOp::IncompatibleMatricesThrown if matrices are not compatible
AbstractLinAlgPack::MatrixOp::MatNormReturned form calc_norm()
AbstractLinAlgPack::MatrixOp::MethodNotImplementedThrown if a method is not implemented
AbstractLinAlgPack::MatrixOpGetGMSAbstract interface that allows the extraction of a const DMatrixSlice view of an abstract matrix
AbstractLinAlgPack::MatrixOpGetGMSMutableAbstract interface that allows the extraction of a non-const DMatrixSlice view of an abstract matrix
AbstractLinAlgPack::MatrixOpGetGMSTriMix-in interface that allows the extraction of a const DenseLinAlgPack::DMatrixSliceTri view of an non-singular abstract matrix
AbstractLinAlgPack::MatrixOpNonsingAbstract base class for all nonsingular polymorphic matrices that can be used to compute matrix-vector products and solve for linear systems efficiently
AbstractLinAlgPack::MatrixOpNonsingAggrAggregate matrix class pulling together a MatrixOp object and a MatrixNonsing object into a unified matrix object
AbstractLinAlgPack::MatrixOpNonsingSerialAbstract base class for all serial nonsingular polymorphic matrices that can be used to compute matrix-vector products and solve for linear systems efficiently
AbstractLinAlgPack::MatrixOpNonsingTesterTesting class for MatrixOpNonsing interface
AbstractLinAlgPack::MatrixOpNonsingThyraMatrixOpNonsing adapter subclass for Thyra::Nonlin::LinearOpWithSolve
AbstractLinAlgPack::MatrixOpSerialBase class for all matrices implemented in a shared memory address space
AbstractLinAlgPack::MatrixOpSubViewStandard subclass for representing a sub, possibly transposed, view of a matrix
AbstractLinAlgPack::MatrixOpThyraMatrixOp adapter subclass for Thyra::LinearOpBase
AbstractLinAlgPack::MatrixPermAggrAggregate matrix class for a matrix and its permuted view
AbstractLinAlgPack::MatrixScaling_StrategyAbstract interface for sparse matrix scaling strategies
AbstractLinAlgPack::MatrixSparseCOORSerialCoordinate matrix subclass
AbstractLinAlgPack::MatrixSparseCOORSerial::ReleaseValRowColArraysSubclass to delete dynamically allocated memory with delete[]
ConstrainedOptPack::MatrixSymAddDelBunchKaufmanThis class maintains the factorization of symmetric indefinite matrix using a Bunch & Kaufman factorization
AbstractLinAlgPack::MatrixSymAddDelUpdateableMix-in Interface for updating a serial symmetric matrix by adding and deleting rows and columns
AbstractLinAlgPack::MatrixSymAddDelUpdateable::InertiaStruct for the inertia of the matrix
AbstractLinAlgPack::MatrixSymAddDelUpdateable::MaxSizeExceededExceptionThrown if the maximum size is exceeded in augment_update(...)
AbstractLinAlgPack::MatrixSymAddDelUpdateable::PivotTolerancesStruct for pivot tolerances to be used when initializing, and augmenting and deleting rows and columns
AbstractLinAlgPack::MatrixSymAddDelUpdateable::SingularUpdateExceptionThrown if the matrix is singular and should not have been
AbstractLinAlgPack::MatrixSymAddDelUpdateable::WarnNearSingularUpdateExceptionThrown if the matrix is near singular as a warning
AbstractLinAlgPack::MatrixSymAddDelUpdateable::WrongInertiaUpdateExceptionThrown if matrix has the wrong inertia from what was expected
ConstrainedOptPack::MatrixSymAddDelUpdateableWithOpNonsingularInterface for updating a symmetric matrix and its factorization by adding and deleting rows and columns and preforming operations with it
AbstractLinAlgPack::MatrixSymDenseInitializeMix-in Interface for initializing a matrix with a dense symmetric matrix
AbstractLinAlgPack::MatrixSymDiagInterface to all diagonal matrices {abstract}
AbstractLinAlgPack::MatrixSymDiagSparseAbstract base class for all serial symmetric diagonal matrices with significant zeros along the diagonal
AbstractLinAlgPack::MatrixSymDiagSparseStdConcrete subclass for a serial symmetric diagonal matrix with many zeros on the diagonal
AbstractLinAlgPack::MatrixSymDiagStdSimple diagonal matrix class
AbstractLinAlgPack::MatrixSymDiagStd::PostModPostMod class to use with MemMngPack::AbstractFactorStd
ConstrainedOptPack::MatrixSymHessianRelaxNonSingMatrix class for non-singular Hessian matrix augmented with a terms for "Big M" relaxation variables
AbstractLinAlgPack::MatrixSymIdentMatrix subclass for a scaled identity matrix
ConstrainedOptPack::MatrixSymIdentitySerialMatrix class for a serial scaled identity matrix
AbstractLinAlgPack::MatrixSymInitDiagMix-in Interface for setting a matrix to a diagonal {abstract}
AbstractLinAlgPack::MatrixSymNonsingAbstract base class for all polymorphic symmetrix nonsingular matrices that can be used to solve for linear systems relatively efficently
AbstractLinAlgPack::MatrixSymNonsingSerialAbstract base class for all serial polymorphic symmetrix nonsingular matrices that can be used to solve for linear systems relatively efficiently
AbstractLinAlgPack::MatrixSymOpInterface adding operations specific for a symmetric matrix {abstract}
AbstractLinAlgPack::MatrixSymOpGetGMSSymAbstract interface that allows the extraction of a const DenseLinAlgPack::DMatrixSliceSym view of an abstract matrix
AbstractLinAlgPack::MatrixSymOpGetGMSSymMutableAbstract interface that allows the extraction of a non-const DenseLinAlgPack::DMatrixSliceSym view of a symmetry abstract matrix
AbstractLinAlgPack::MatrixSymOpNonsingAbstract base class for all polymorphic symmetrix nonsingular matrices that can be used to compute matrix-vector products and solve for linear systems relatively efficently
AbstractLinAlgPack::MatrixSymOpNonsingSerialAbstract 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
AbstractLinAlgPack::MatrixSymOpSerialAbstract base class for all AbstractLinAlgPack::MatrixSymOp objects implemented in shared memory space
ConstrainedOptPack::MatrixSymPosDefBandedCholMatrix subclass for banded symmetric positive definite matrices and their Cholesky factors
ConstrainedOptPack::MatrixSymPosDefInvCholFactorImplementation of MatrixOp abstract interface for SymInvCholMatrix
ConstrainedOptPack::MatrixSymPosDefLBFGSImplementation of limited Memory BFGS matrix for arbitrary vector spaces
ConstrainedOptPack::MatrixSymPosDefLBFGSImplementation of limited Memory BFGS matrix
ConstrainedOptPack::MatrixSymPosDefLBFGS::PostModPostMod class to use with MemMngPack::AbstractFactorStd
AbstractLinAlgPack::MatrixSymSecantMix-in interface for all polymorphic symmetric matrices that support secant updating
AbstractLinAlgPack::MatrixSymSecant::UpdateFailedException
AbstractLinAlgPack::MatrixSymSecant::UpdateSkippedException
ConstrainedOptPack::MatrixVarReductImplicitImplements D = - inv(C) * N for a variable reduction projection
AbstractLinAlgPack::MatrixWithOpConcreteEncap< M >This template class defines the storage for a concrete matrix class that operations are based on
AbstractLinAlgPack::MatrixZeroImplementation of a matrix with all zeros
MA28_CppDecl::MC23BD_struct
MoochoPack::MeritFunc_DummyUpdate_StepSimply updates merit_func_nlp_k = merit_func_nlp_km1
MoochoPack::MeritFunc_ModifiedL1LargerSteps_AddedStepThis 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
MoochoPack::MeritFunc_ModifiedL1LargerSteps_AddedStepSetOptionsSet options for MeritFunc_ModifiedL1LargerSteps_AddedStep from a OptionsFromStream object
MoochoPack::MeritFunc_PenaltyParamsUpdateWithMult_AddedStepUpdates a set of penalty parameters for a merit function as: mu(j) = max( mu(j), |lambda_k(j)| )
MoochoPack::MeritFunc_PenaltyParamUpdate_AddedStepBase class for steps that update penalty parameters based on the Lagrange multipliers lambda_k (or some approximation to them)
MoochoPack::MeritFunc_PenaltyParamUpdate_AddedStepSetOptionsSet options for MeritFunc_PenaltyParamUpdate_AddedStep from a OptionsFromStream object
MoochoPack::MeritFunc_PenaltyParamUpdateGuts_AddedStepUpdates the penalty parameter for a merit function as: mu_k = max( mu_km1, min_mu )
MoochoPack::MeritFunc_PenaltyParamUpdateMultFree_AddedStepSpecializes the update of the penalty parameter for a merit function as: min_mu = |(Gf_k+nu_k)'* Ypy_k| / ||c_k||1
MoochoPack::MeritFunc_PenaltyParamUpdateWithMult_AddedStepSpecializes the update of the penalty parameter for a merit function as: min_mu =||lambda||inf
ConstrainedOptPack::MeritFuncCalcAbstract iterface for n-D merit functions {abstract}
ConstrainedOptPack::MeritFuncCalc1DAbstracts a 1D merit function {abstract}
ConstrainedOptPack::MeritFuncCalc1DQuadraticAdds the ability to compute phi(alpha) at alpha of a given set of vectors
ConstrainedOptPack::MeritFuncCalcNLEAdds 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)
ConstrainedOptPack::MeritFuncCalcNLPAdds 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)
ConstrainedOptPack::MeritFuncNLEBase class for all merit functions for systems of NonLinear Equations (NLE) {abstract}
ConstrainedOptPack::MeritFuncNLE::InvalidInitialization
ConstrainedOptPack::MeritFuncNLESqrResidA merit function for the square of the constriant values
ConstrainedOptPack::MeritFuncNLPBase class for all merit functions for NonLinear Programs (NLP) {abstract}
ConstrainedOptPack::MeritFuncNLP::InvalidInitialization
ConstrainedOptPack::MeritFuncNLPDirecDerivThis class provides a mix-in interface for allowing subclass merit functions to compute the directional 1D derivative at a base point
ConstrainedOptPack::MeritFuncNLPL1The L1 merit function
ConstrainedOptPack::MeritFuncNLPModL1The modified L1 merit function using different penatly parameters for each constriant
ConstrainedOptPack::MeritFuncPenaltyParamThis class provides interface for setting and retrieving a penalty parameter that many merit functions use {abstract}
ConstrainedOptPack::MeritFuncPenaltyParamsThis class provides interface for setting and retrieving a penalty parameter that many merit functions use {abstract}
ConstrainedOptPack::MeritFuncPenaltyParams::CanNotResize
IterationPack::MinorLoop1Step
MoochoPack::MoochoSolverUniversal interface to a MOOCHO solver
MoochoPack::MoochoThyraSolverMOOCHO NLP Solver class for models represented through Thyra::ModelEvaluator
MoochoPack::MoochoTrackerConsoleStdThis rSQP iteration class provides a tablular output suitable for an 80 char wide console
MoochoPack::MoochoTrackerStatsStdThis is a simple track class for getting statistics about a solved (or not solved) NLP
MoochoPack::MoochoTrackerSummaryStdThis class simply outputs the convergence information for each iteration
MoochoPack::MoochoTrackerXMLSummaryThis class outputs an XML summary file of the algorithm results and performance
AbstractLinAlgPack::MultiVectorInterface for a collection of non-mutable vectors (multi-vector, matrix)
AbstractLinAlgPack::MultiVectorMutableInterface for a collection of mutable vectors (multi-vector, matrix)
AbstractLinAlgPack::MultiVectorMutableColsDefault subclass for MultiVectorMutable implemented using columns of separate abstract vectors
AbstractLinAlgPack::MultiVectorMutableDenseMultiVectorMutable "Adapter" subclass for DenseLinAlgPack::DMatrixSlice or DenseLinAlgPack::DMatrix object
AbstractLinAlgPack::MultiVectorMutableThyraMultiVectorMutable adapter subclass for Thyra::MultiVectorBase
RTOpPack::MutableSubMultiVectorT1B< Scalar >Class for a mutable sub-vector
RTOpPack::MutableSubVectorT1B< Scalar >Class for a mutable sub-vector
AbstractLinAlgPack::NaNInfException
DenseLinAlgPack::NaNInfException
MoochoPack::NewDecompositionSelection_StrategyAbstract interface for an object that directs the selection of a new decomposition
MoochoPack::NewDecompositionSelectionStd_StrategyJust force the decomposition system object to select a new decomposition and let everyone else fend for themselves
NLPInterfacePack::NLPNLP interface class {abstract}
NLPInterfacePack::NLP::IncompatibleTypeThrown if an incompatible object is used
NLPInterfacePack::NLP::InvalidInitializationThrown from initialize() if some logical error occured
NLPInterfacePack::NLP::NoBoundsThrown some bounds do not existe
NLPInterfacePack::NLP::UnInitializedThrown if any member functions are called before initialize() has been called
NLPInterfacePack::NLP::ZeroOrderInfoStruct for objective and constriants (pointer)
MoochoPack::NLPAlgoRSQP Algorithm control class
MoochoPack::NLPAlgoClientInterfaceInterface that smart clients use to set the algorithm configuration object that defines the rSQP algorithm to be used to solve the NLP
MoochoPack::NLPAlgoConfigInterface for objects responsible for configuring an rSQP algorithm
MoochoPack::NLPAlgoConfig::InvalidNLPTypeThrown if NLP type is incompatible with this config
MoochoPack::NLPAlgoConfigIPThis is a do all configuration class for NLPAlgo
MoochoPack::NLPAlgoConfigIP::SOptionValues
MoochoPack::NLPAlgoConfigMamaJamaThis is a do all configuration class for NLPAlgo
MoochoPack::NLPAlgoConfigMamaJama::SOptionValues
MoochoPack::NLPAlgoContainerImplementation for NLPAlgo solver
MoochoPack::NLPAlgoInterfaceInterface NLPAlgoContainer uses to access NLPAlgo
MoochoPack::NLPAlgoStateReduced space SQP state encapsulation interface
MoochoPack::NLPAlgoState::InvalidTypeThrown if an iteration quantity is of an invalid type
MoochoPack::NLPAlgoState::iq_id_encap
NLPInterfacePack::NLPBarrierSimple wrapper that provides an objective fn with the barrier term included
NLPInterfacePack::NLPDirectInterface providing only direct first order sensitivity information
NLPInterfacePack::NLPDirectTesterConcrete class that tests the computed values of the NLPDirect interface using finite differences
NLPInterfacePack::NLPDirectTesterSetOptionsSet options for NLPDirectTester from an OptionsFromStream object
NLPInterfacePack::NLPDirectThyraModelEvaluatorImplement the NLPFirstOrder interface using a Thyra::ModelEvaluator object
NLPInterfacePack::NLPFirstDerivTesterConcrete class that tests the derivatives using finite differences
NLPInterfacePack::NLPFirstDerivTesterSetOptionsSet options for NLPFirstDerivTester from an OptionsFromStream object
NLPInterfacePack::NLPFirstOrderNLP first order information interface class {abstract}
NLPInterfacePack::NLPFirstOrder::FirstOrderInfoStruct for zero and first order quantities (pointers)
NLPInterfacePack::NLPFirstOrderThyraModelEvaluatorImplement the NLPFirstOrder interface using a Thyra::ModelEvaluator object
NLPInterfacePack::NLPObjGradNLP interface class that adds gradient information for the objective function {abstract}
NLPInterfacePack::NLPObjGrad::ObjGradInfoStruct for gradient (objective), objective and constriants (pointers)
NLPInterfacePack::NLPSecondOrderNLP second order information interface class {abstract}
NLPInterfacePack::NLPSecondOrder::SecondOrderInfoStruct for zero, first and second order quantities (pointers)
NLPInterfacePack::NLPSerialPreprocessNLP node implementation subclass for preprocessing and basis manipulation
NLPInterfacePack::NLPSerialPreprocess::InconsistantBoundsThrown if xl(i) > xu(i)
NLPInterfacePack::NLPSerialPreprocess::ObjGradInfoSerialStruct for serial gradient (objective), objective and constriants (pointers)
NLPInterfacePack::NLPSerialPreprocess::ZeroOrderInfoSerialStruct for objective and constriants (pointer) as serial vectors
NLPInterfacePack::NLPSerialPreprocessExplJacNLP node subclass complementing NLPSerialPreprocess for explicit Jacobians
NLPInterfacePack::NLPSerialPreprocessExplJac::FirstOrderExplInfoStruct for zero and explicit first order quantities that subclass must fill in
MoochoPack::NLPSolverClientInterfaceThis is the most basic interface that clients use to solve an NLP
MoochoPack::NLPSolverClientInterface::InvalidSetupThrown if the setup is not valid
MoochoPack::NLPSolverClientInterfaceSetOptionsSet options for NLPSolverClientInterface from an OptionsFromStream object
NLPInterfacePack::NLPTesterTesting class for base NLP interface
NLPInterfacePack::NLPTesterSetOptionsSet options for NLPTester from an OptionsFromStream object
NLPInterfacePack::NLPThyraModelEvaluatorBaseImplements the base NLP interface using a Thyra::ModelEvaluator object
NLPInterfacePack::NLPVarReductPermNLP interface class that adds variable and constriant permutations for variable reduction basis selections
NLPInterfacePack::NLPVarReductPerm::InvalidBasisThrown if an invalid basis selection is made
NLPInterfacePack::NLPWBCounterExampleNLP subclass for the Waechter and Biegler Counter Example
AbstractLinAlgPack::SparseVectorUtilityPack::NoNonZeroElementsException
StandardCompositionRelationshipsPack::NoRefSetThrown when the reference has not been set
AbstractLinAlgPack::SparseVectorUtilityPack::NotSortedException
MoochoPack::NumFixedDepIndep_AddedStepComputes and outputs the number of fixed variables from the dependent and independent set.
FortranTypes::OpenExceptionThrown if the open operation fails
OptionsFromStreamPack::OptionsFromStreamExtracts options from a text stream and then allows convenient access to them
OptionsFromStreamPack::OptionsFromStream::InputStreamErrorThrown if there is an input error
OptionsFromStreamPack::OptionsFromStreamUtilityPack::OptionsGroupClass used to encapsulate options belonging an options group
AbstractLinAlgPack::SparseVectorUtilityPack::OutOfRoomException
AbstractLinAlgPack::COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value >Class for a partition or a set of continous partitions in a partitioned COO matrix
AbstractLinAlgPack::PermutationAbstract interface to permutation matrices
AbstractLinAlgPack::PostConditionExceptionBase class for postcondition exceptions
MoochoPack::PostEvalNewPointBarrier_StepStandard evaluation step class for extra parameters in primal/dual barrier method
MoochoPack::PostProcessBarrierLineSearch_StepFraction to boundary rule for calculating alpha max
AbstractLinAlgPack::PreConditionExceptionBase class for precondition exceptions
MoochoPack::PreEvalNewPointBarrier_StepStandard evaluation step class for extra parameters in primal/dual barrier method
MoochoPack::PreEvalNewPointBarrier_StepSetOptions
MoochoPack::PreProcessBarrierLineSearch_StepFraction to boundary rule for calculating alpha max
MoochoPack::PreProcessBarrierLineSearch_StepSetOptions
ProfileHackPack::ProfileTimingHelper class that takes care of timing
ConstrainedOptPack::QPSchurPack::QPRepresents the QP to be solved by QPSchur {abstract}
MoochoPack::qp_solver_stats_iq_memberClass for object that attempts to return an IterQuantityAccess<QPSolverStats> from an AlgorithmState object with the name qp_solver_stats_name
MoochoPack::QPFailureThrown if a the QP failed and was not corrected
MoochoPack::QPFailureReinitReducedHessian_StepDirects the algorithm to reinitalize the reduced Hessian on the event of a QP failure
ConstrainedOptPack::QPSchurPack::QPInitFixedFreeStdGeneral (and flexible) implementation class for a QPSchur QP problem
ConstrainedOptPack::QPSchurSolves a Quadratic Program with a dual QP method using a schur complement factorization
ConstrainedOptPack::QPSchur::ActiveSetRepresents and manages the active set for the QPSchur algorithm
ConstrainedOptPack::QPSchur::DualInfeasibleExceptionThrown if during the course of the primal-dual iteration a non-dual feasible point if found
ConstrainedOptPack::QPSchur::InconsistantConstraintsExceptionThrown if constraints are inconsistant (no feasible region)
ConstrainedOptPack::QPSchur::NumericalInstabilityExceptionThrown if there is some numerical instability
ConstrainedOptPack::QPSchur::TestFailedThrown if a test failed
ConstrainedOptPack::QPSchur::U_hat_tRepresents the matrix U_hat
ConstrainedOptPack::QPSchurInitKKTSystemHessianFixedFreeImplementation of initial KKT system using the Hessian for the free variables only
ConstrainedOptPack::QPSchurInitKKTSystemHessianFullImplementation of initial KKT system for all variables initially free and Ko = G
ConstrainedOptPack::QPSchurInitKKTSystemHessianRelaxedImplementation of initial KKT system where all original variables are free and all the relaxation variables are fixed
ConstrainedOptPack::QPSchurInitKKTSystemHessianSuperBasicImplementation of initial KKT system for all variables initially fixed and free where Ko = B_RR#
ConstrainedOptPack::QPSolverRelaxedSolves Quadratic Programs (QPs) of several different forms while allowing a relaxation of the constraints
ConstrainedOptPack::QPSolverRelaxed::InfeasibleThrown if the QP is infeasible
ConstrainedOptPack::QPSolverRelaxed::InvalidInputThrown if there is invalid input
ConstrainedOptPack::QPSolverRelaxed::TestFailedThrown if a test failed
ConstrainedOptPack::QPSolverRelaxed::UnboundedThrown if the QP is unbounded
ConstrainedOptPack::QPSolverRelaxedQPKWIKSolves Quadratic Programming (QP) problem using the primal-dual active-set solver QPKWIK
ConstrainedOptPack::QPSolverRelaxedQPOPTSOLNode base clase for the primal QP solvers QPOPT and QPSOL
ConstrainedOptPack::QPSolverRelaxedQPSchurSolves Quadratic Programming (QP) problems using QPSchur
ConstrainedOptPack::QPSolverRelaxedQPSchur::InitKKTSystemInterface for the object that forms the initial KKT system {abstract}
ConstrainedOptPack::QPSolverRelaxedQPSchur::ReinitKKTSystemInterface for the object that can reform an initial KKT system dynamically {abstract}
ConstrainedOptPack::QPSolverRelaxedQPSchurSetOptionsSet options for QPSolverRelaxedQPSchur from an OptionsFromStream object
ConstrainedOptPack::QPSolverRelaxedTesterTests the optimality conditions of the output from a QPSolverRelaxed object
ConstrainedOptPack::QPSolverRelaxedTesterSetOptionsSet options for QPSolverRelaxedTester from an OptionsFromStream object
ConstrainedOptPack::QPSolverStatsClass for storing statistics about a run of a (active set?) QP solver
MoochoPack::quasi_newton_stats_iq_memberClass for object that attempts to return an IterQuantityAccess<QuasiNewtonStats> from an AlgorithmState object with the name quasi_newton_stats_name
MoochoPack::QuasiNewtonStatsClass for storing statistics about the Quasi-Newton updating
MoochoPack::QuasiNormalStepStd_StepCalculates the range space step by, solving for py = -inv(R)*c(equ_decomp), then setting Ypy = Y * py
MoochoPack::QuasiRangeSpaceStep_StrategyAbstract interface for a strategy object that will compute a step that will approximalty solve a range space subproblem {abstract}
MoochoPack::QuasiRangeSpaceStepStd_StrategyStrategy class for computing a quasi-range-space step by solving the approximate range space problem directly
MoochoPack::QuasiRangeSpaceStepTailoredApproach_StrategyStrategy class for computing a quasi range space step for the tailored approach NLP interface
RangePack::Range1D. One-based subregion index range class
MoochoPack::ReducedGradientStd_StepComputes the reducecd gradient of the objective rGf_k = Z_k' * Gf_k
MoochoPack::ReducedHessianExactStd_StepComputes the exact reduced Hessian rHL_k = Z_k' * HL_k * Z_k
MoochoPack::ReducedHessianSecantUpdate_StrategyStrategy interface for performing secant updates {abstract}
MoochoPack::ReducedHessianSecantUpdateBFGSFull_StrategyPerform BFGS updates on full reduced Hessian
MoochoPack::ReducedHessianSecantUpdateBFGSProjected_StrategyPerform BFGS updates on only the free independent (super basic) variables
MoochoPack::ReducedHessianSecantUpdateBFGSProjected_StrategySetOptionsSet options for ReducedHessianSecantUpdateBFGSProjected_Strategy from a OptionsFromStream object
MoochoPack::ReducedHessianSecantUpdateLPBFGS_StrategyPerform BFGS updates on only the free independent (super basic) variables
MoochoPack::ReducedHessianSecantUpdateLPBFGS_StrategySetOptionsSet options for ReducedHessianSecantUpdateBFGSProjected_Strategy from a OptionsFromStream object
MoochoPack::ReducedHessianSecantUpdateStd_StepUpdates rHL_k using a secant update
MoochoPack::ReducedHessianSerialization_StepSerializes rHL_k to and from a file
RTOpPack::ReductTargetCAdapter subclass for RTOp_ReductTarget
MemMngPack::ReleaseResourceAbstract interface for releasing an object when it is not needed anymore {abstract}
MemMngPack::ReleaseResource_ref_count_ptr< T >Template class that implements ReleaseResource interface for a RCP<T> object
AbstractLinAlgPack::GenPermMatrixSliceIteratorPack::row_col_iterator< T >This is a full random access iterator for accessing row and colunmn indices
AbstractLinAlgPack::GenPermMatrixSliceIteratorPack::row_col_value_type< T >Internal storage for the iterator of the row and column indices
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
RTOpPack::RTOpCAdapter subclass that uses a RTOp_RTOp object
RTOpPack::RTOpCPostMod
IterationPack::RuntimeConfigChangeStep
SerializationPack::SerializableMixin interface for objects that can be serialized to and from a stream
QPKWIK_Output::set_output
MoochoPack::SetDBoundsStd_AddedStepComputes the bounds for the QP subproblem from the NLP bounds
OptionsFromStreamPack::SetOptionsFromStreamAbstact interface for objects that have options to be set that are contained in an OptionsFromStreamObject
OptionsFromStreamPack::SetOptionsFromStreamNodeNode class for setting options from a stream
OptionsFromStreamPack::SetOptionsToTargetBase< T >Templated node class manipulating a reference to a target object who will have its options set.
AbstractLinAlgPack::SetupExceptionBase class for invalid setup for a class object when an exception is thrown
AbstractLinAlgPack::SortByDescendingAbsValueFunction object class for sorting a sparse vectors in descending order by abs(v(i))
AbstractLinAlgPack::sparse_bounds_itrIterate through a set of sparse bounds
AbstractLinAlgPack::SparseCOOPtrElement< T_Index, T_Value >Sparse pointer element type for a COO matrix (val, ivect, jvect)
AbstractLinAlgPack::SparseElement< T_Index, T_Value >Sparse storage element type
AbstractLinAlgPack::SparseElement< T_Index, T_Value >::index_and_padding
AbstractLinAlgPack::SparsePtrElement< T_Indice, T_Value >Sparse pointer element type
AbstractLinAlgPack::SparseVector< T_Element, T_Alloc >Sparse Vector class template
AbstractLinAlgPack::SparseVectorSlice< T_Element >Sparse Vector Slice class template
AbstractLinAlgPack::SparseVectorUtilityPack::SpVecIndexLookup< T_Element >Sparse Vector Index Lookup and Caching class
AbstractLinAlgPack::SparseVectorUtilityPack::SpVecIndexLookup< T_Element >::InvalidInternalStateException
AbstractLinAlgPack::SparseVectorUtilityPack::SpVecIndexLookup< T_Element >::NoSpVecSetException
AbstractLinAlgPack::SparseVectorUtilityPack::SpVecIndexLookup< T_Element >::poss_typeStruct with members: size_type poss; ElementRelation rel;
StopWatchPack::stopwatchSimple stopwatch object
StrideIterPack::stride_iter< T_iterator_type, T_value_type, T_reference_type, T_pointer_type, T_difference_type >C++ Standard Library compatable iterator class for accesing nonunit stride arrays of data
OptionsFromStreamPack::StringToIntMapMap a string to an enumeration
OptionsFromStreamPack::StringToIntMap::AlreadyExists
OptionsFromStreamPack::StringToIntMap::DoesNotExist
RTOpPack::SubMultiVectorT1B< Scalar >Class for a non-mutable sub-multi-vector (submatrix)
RTOpPack::SubVectorT1B< Scalar >Class for a non-mutable sub-vector
MoochoPack::TangentialStepIP_StepNull Space Step for Interior Point algorithm
MoochoPack::TangentialStepWithInequStd_StepSolves the reduced QP subproblem with bounds and/or general inequalities
MoochoPack::TangentialStepWithInequStd_StepSetOptionsSet options for TangentialStepWithInequStd_Step from an OptionsFromStream object
MoochoPack::TangentialStepWithoutBounds_StepSolves the unconstrained QP subproblem: min qp_grad' * pz + (1/2) * pz' * rHL * pz
MoochoPack::TestFailedThrown if a runtime test failed
AbstractLinAlgPack::COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value >Class for the transpose of a Partition
AbstractLinAlgPack::TransSparseCOOElementViewIter< T_Iter, T_IterCat, T_Indice, T_ValRef, T_Diff >Templateded iterator for iterating through a set of COO Matix elements but viewing them in transpose
AbstractLinAlgPack::TransSparseCOOElementViewIter< T_Iter, T_IterCat, T_Indice, T_ValRef, T_Diff >::ElementView< TT_Iter, TT_IterCat, TT_Indice, TT_ValRef, TT_Diff >Type for the object that is returned for the transpose sparse element
AbstractLinAlgPack::SparseVectorUtilityPack::UnsizedException
MoochoPack::UpdateBarrierParameter_StepBarrier Parameter (mu) Update
MoochoPack::UpdateBarrierParameter_StepSetOptions
MoochoPack::UpdateReducedSigma_StepStandard class for updating the reduced sigma for interior point optimization
MoochoPack::UpdateReducedSigma_StepSetOptions
ConstrainedOptPack::VariableBoundsTesterTests that a set of variables are within their bounds
ConstrainedOptPack::VariableBoundsTesterSetOptionsSet options for VariableBoundsTester from an OptionsFromStream object
AbstractLinAlgPack::VectorAbstract interface for immutable, finite dimensional, coordinate vectors {abstract}
ConstrainedOptPack::QPSchurPack::vector_one_based_checked< T >Utility class for a ranged check vector
AbstractLinAlgPack::VectorApplyOpSerialBaseThis 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
AbstractLinAlgPack::VectorDenseEncapExtract a constant DenseLinAlgPack::DVectorSlice view of a Vector object
AbstractLinAlgPack::VectorDenseMutableEncapExtract a non-const DenseLinAlgPack::DVectorSlice view of a VectorMutable object
AbstractLinAlgPack::VectorMutableAbstract interface for mutable coordinate vectors {abstract}
AbstractLinAlgPack::VectorMutableBlockedConcrete subclass for a blocked vector
AbstractLinAlgPack::VectorMutableDenseDVector "Adaptor" subclass for DenseLinAlgPack::DVectorSlice or DenseLinAlgPack::DVector objects
AbstractLinAlgPack::VectorMutableSubViewConcrete subclass for a sub-view of a VectorMutable object
AbstractLinAlgPack::VectorMutableThyraVectorMutable adapter subclass for Thyra::VectorBase
DenseLinAlgPack::VectorSliceTmpl< T >
AbstractLinAlgPack::VectorSpaceAbstract interface for objects that represent a space for mutable coordinate vectors
AbstractLinAlgPack::VectorSpace::IncompatibleVectorSpacesThrown if vector spaces are incompatible
AbstractLinAlgPack::VectorSpaceBlockedVectorSpace subclass for the composite of one or more VectorSpace objects
AbstractLinAlgPack::VectorSpaceFactoryAbstract interface for objects that can create vector spaces of a specified dimension
AbstractLinAlgPack::VectorSpaceFactorySerialAbstract interface for objects that can create vector spaces of a specified dimension
AbstractLinAlgPack::VectorSpaceFactoryThyraVectorSpaceFactory adapter subclass for Thyra::VectorSpaceBase
AbstractLinAlgPack::VectorSpaceSerialSubclass for serial vector space objects that create VectorMutableDense vector and MultiVectorMutableDense multi-vector objects
AbstractLinAlgPack::VectorSpaceSubSpaceConcrete subclass for a default sub-space of a vector
AbstractLinAlgPack::VectorSpaceTesterTesting class for VectorSpace, Vector and VectorMutable
AbstractLinAlgPack::VectorSpaceTesterSetOptionsSet options for VectorSpaceTester from an OptionsFromStream object
AbstractLinAlgPack::VectorSpaceThyraVectorSpace adapter subclass for Thyra::VectorSpaceBase<value_type>
AbstractLinAlgPack::VectorSubViewConcrete subclass for a default sub-view implementation for a Vector object
DenseLinAlgPack::VectorTmpl< T >

Generated on Tue Oct 20 12:54:02 2009 for MOOCHO (Single Doxygen Collection) by doxygen 1.4.7