MoochoPack : Framework for Large-Scale Optimization Algorithms Version of the Day
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
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
MoochoPack::BFGSUpdate_StrategyStrategy interface which contains the guts for a dampened BFGS update
MoochoPack::BFGSUpdate_StrategySetOptionsSet options for BFGSUpdate_Strategy from an OptionsFromStream object
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
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)
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
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
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
MoochoPack::DecompositionSystemStateStepBuilderStdStandard builder object for creating DecompositionSystem, EvalNewPoint Step and other objects and setting up some of the state object
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"
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::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
MoochoPack::NLPAlgoConfig::InvalidNLPTypeThrown if NLP type is incompatible with this config
MoochoPack::NLPSolverClientInterface::InvalidSetupThrown if the setup is not valid
MoochoPack::NLPAlgoState::InvalidTypeThrown if an iteration quantity is of an invalid type
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
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
MoochoPack::MoochoSolverUniversal interface to a MOOCHO solver
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
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
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::NLPAlgoConfigIPThis is a do all configuration class for NLPAlgo
MoochoPack::NLPAlgoConfigMamaJamaThis is a do all configuration class for NLPAlgo
MoochoPack::NLPAlgoContainerImplementation for NLPAlgo solver
MoochoPack::NLPAlgoInterfaceInterface NLPAlgoContainer uses to access NLPAlgo
MoochoPack::NLPAlgoStateReduced space SQP state encapsulation interface
MoochoPack::NLPSolverClientInterfaceThis is the most basic interface that clients use to solve an NLP
MoochoPack::NLPSolverClientInterfaceSetOptionsSet options for NLPSolverClientInterface from an OptionsFromStream object
MoochoPack::NumFixedDepIndep_AddedStepComputes and outputs the number of fixed variables from the dependent and independent set.
MoochoPack::PostEvalNewPointBarrier_StepStandard evaluation step class for extra parameters in primal/dual barrier method
MoochoPack::PostProcessBarrierLineSearch_StepFraction to boundary rule for calculating alpha max
MoochoPack::PreEvalNewPointBarrier_StepStandard evaluation step class for extra parameters in primal/dual barrier method
MoochoPack::PreProcessBarrierLineSearch_StepFraction to boundary rule for calculating alpha max
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
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
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
MoochoPack::SetDBoundsStd_AddedStepComputes the bounds for the QP subproblem from the NLP bounds
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
MoochoPack::UpdateBarrierParameter_StepBarrier Parameter (mu) Update
MoochoPack::UpdateReducedSigma_StepStandard class for updating the reduced sigma for interior point optimization
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends