Class List

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

MoochoPack::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
MoochoPack::ActSetStats	Class for storing statistics about the changes in the active set of an SQP algorithm
MoochoPack::ActSetStats_AddedStep	Updates the active set statistics for the current iteration
MoochoPack::BFGSUpdate_Strategy	Strategy interface which contains the guts for a dampened BFGS update
MoochoPack::BFGSUpdate_StrategySetOptions	Set options for BFGSUpdate_Strategy from an OptionsFromStream object
MoochoPack::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
MoochoPack::CalcDFromYPY_Step	Calculates d = Ypy
MoochoPack::CalcDFromYPYZPZ_Step	Calculates d = Ypy + Zpz
MoochoPack::CalcDFromZPZ_Step	Calculates d = Zpz
MoochoPack::CalcLambdaIndepStd_AddedStep	Calculates the lagrange multipliers for the independent constraints
MoochoPack::CalcReducedGradLagrangianStd_AddedStep	Calculates the reduced gradient of the Lagrangian rGL = rGf + Z' * nu + GcUP' * lambda(equ_undecomp) + GhUP' * lambdaI(inequ_undecomp)
MoochoPack::CheckConvergence_Strategy	Strategy interface for performing convergence checks
MoochoPack::CheckConvergence_StrategySetOptions	Set options for CheckConvergence_Strategy from an OptionsFromStream object
MoochoPack::CheckConvergenceIP_Strategy	Implementation of CheckConvergence_Strategy interface
MoochoPack::CheckConvergenceStd_AddedStep	Check for convergence
MoochoPack::CheckConvergenceStd_AddedStepSetOptions	Set options for CheckConvergenceStd_AddedStep from an OptionsFromStream object
MoochoPack::CheckConvergenceStd_Strategy	Implementation of CheckConvergence_Strategy interface
MoochoPack::CheckDecompositionFromPy_Step	Check if the decomposition is going singular and if it is select a new decomposition
MoochoPack::CheckDecompositionFromRPy_Step	Check if the decomposition is going singular and if it is select a new decomposition
MoochoPack::CheckDescentQuasiNormalStep_Step	Checks for descent in the decomposed equality constraints with respect to the range space step Ypy using finite differences
MoochoPack::CheckSkipBFGSUpdateStd_Step	Checks if a BFGS update should be preformed
MoochoPack::CheckSkipBFGSUpdateStd_StepSetOptions	Set options for CheckSkipBFGSUpdateStd_Step from a OptionsFromStream object
MoochoPack::CrossTermExactStd_Step	W_k = Z_k' * HL_k * Ypy_k
MoochoPack::DampenCrossTermStd_Step	Compute a dampening term zeta_k for the cross term w_k such that Gf'*Z*pz <= 0
MoochoPack::DecompositionSystemHandler_Strategy	Interface for range/null decomposition handling
MoochoPack::DecompositionSystemHandlerSelectNew_Strategy	Interface for range/null decomposition handling
MoochoPack::DecompositionSystemHandlerStd_Strategy	Subclass for updating the range/null space decomposition using the base DecompositionSystem interface only
MoochoPack::DecompositionSystemHandlerVarReductPerm_Strategy	Subclass for selecting and updating the range/null space decomposition using the DecompositionSystemVarReductPerm interface
MoochoPack::DecompositionSystemStateStepBuilderStd	Standard builder object for creating DecompositionSystem, EvalNewPoint Step and other objects and setting up some of the state object
MoochoPack::EvalNewPointStd_Step	Standard new point evaluation step class
MoochoPack::EvalNewPointTailoredApproach_Step	Base class for evaluating a new point for the "Tailored Approach"
MoochoPack::EvalNewPointTailoredApproach_StepSetOptions	Set options for EvalNewPointTailoredApproach_Step from an OptionsFromStream object
MoochoPack::EvalNewPointTailoredApproachCoordinate_Step	Implements "coordinate" decompostion for "Tailored Appraoch"
MoochoPack::EvalNewPointTailoredApproachOrthogonal_Step	Implements "orthogonal" decompostion for "Tailored Appraoch"
MoochoPack::FeasibilityStep_Strategy	Abstract interface for a strategy object that will compute a step that will improve feasibility (at least descent) {abstract}
MoochoPack::FeasibilityStepReducedStd_Strategy	Implements the feasibility step computation for reduced space SQP
MoochoPack::FeasibilityStepReducedStd_StrategySetOptions	Set options for FeasibilityStepReducedStd_Strategy from an OptionsFromStream object
MoochoPack::InitFinDiffReducedHessian_Step	Initializes the reduced hessian using a single finite difference along the null space of the constraints
MoochoPack::InitFinDiffReducedHessian_StepSetOptions	Set options for InitFinDiffReducedHessian_Step from an OptionsFromStream object
MoochoPack::NLPAlgoConfig::InvalidNLPType	Thrown if NLP type is incompatible with this config
MoochoPack::NLPSolverClientInterface::InvalidSetup	Thrown if the setup is not valid
MoochoPack::NLPAlgoState::InvalidType	Thrown if an iteration quantity is of an invalid type
MoochoPack::NLPAlgoState::iq_id_encap
MoochoPack::LineSearch2ndOrderCorrect_Step	Implements second order correction
MoochoPack::LineSearch2ndOrderCorrect_StepSetOptions	Set options for LineSearch2ndOrderCorrect_Step from an OptionsFromStream object
MoochoPack::LineSearchDirect_Step	Delegates the line search to a DirectLineSearch_Strategy object
MoochoPack::LineSearchFailure	Thrown if a line search failure occurs
MoochoPack::LineSearchFailureNewDecompositionSelection_Step	Directs the selection of a new decomposition if the line search fails
MoochoPack::LineSearchFilter_Step	Filter line-search step class
MoochoPack::LineSearchFullStep_Step	Takes the full step x_kp1 = x_k + d_k (d_k = Ypy_k + Zpz_k)
MoochoPack::LineSearchFullStepAfterKIter_Step	Changes from a line search step to just taking full steps after full_steps_after_k iterations
MoochoPack::LineSearchNLE_Step	Delegates the line search to a DirectLineSearch_Strategy object
MoochoPack::LineSearchWatchDog_Step	Implements watchdog line search
MoochoPack::LineSearchWatchDog_StepSetOptions	Set options for LineSearchWatchDog_Step from a OptionsFromStream object
MoochoPack::MeritFunc_DummyUpdate_Step	Simply updates merit_func_nlp_k = merit_func_nlp_km1
MoochoPack::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
MoochoPack::MeritFunc_ModifiedL1LargerSteps_AddedStepSetOptions	Set options for MeritFunc_ModifiedL1LargerSteps_AddedStep from a OptionsFromStream object
MoochoPack::MeritFunc_PenaltyParamsUpdateWithMult_AddedStep	Updates a set of penalty parameters for a merit function as: mu(j) = max( mu(j), |lambda_k(j)| )
MoochoPack::MeritFunc_PenaltyParamUpdate_AddedStep	Base class for steps that update penalty parameters based on the Lagrange multipliers lambda_k (or some approximation to them)
MoochoPack::MeritFunc_PenaltyParamUpdate_AddedStepSetOptions	Set options for MeritFunc_PenaltyParamUpdate_AddedStep from a OptionsFromStream object
MoochoPack::MeritFunc_PenaltyParamUpdateGuts_AddedStep	Updates the penalty parameter for a merit function as: mu_k = max( mu_km1, min_mu )
MoochoPack::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
MoochoPack::MeritFunc_PenaltyParamUpdateWithMult_AddedStep	Specializes the update of the penalty parameter for a merit function as: min_mu =||lambda||inf
MoochoPack::MoochoSolver	Universal interface to a MOOCHO solver
MoochoPack::MoochoTrackerConsoleStd	This rSQP iteration class provides a tablular output suitable for an 80 char wide console
MoochoPack::MoochoTrackerStatsStd	This is a simple track class for getting statistics about a solved (or not solved) NLP
MoochoPack::MoochoTrackerSummaryStd	This class simply outputs the convergence information for each iteration
MoochoPack::MoochoTrackerXMLSummary	This class outputs an XML summary file of the algorithm results and performance
MoochoPack::NewDecompositionSelection_Strategy	Abstract interface for an object that directs the selection of a new decomposition
MoochoPack::NewDecompositionSelectionStd_Strategy	Just force the decomposition system object to select a new decomposition and let everyone else fend for themselves
MoochoPack::NLPAlgo	RSQP Algorithm control class
MoochoPack::NLPAlgoClientInterface	Interface that smart clients use to set the algorithm configuration object that defines the rSQP algorithm to be used to solve the NLP
MoochoPack::NLPAlgoConfig	Interface for objects responsible for configuring an rSQP algorithm
MoochoPack::NLPAlgoConfigIP	This is a do all configuration class for NLPAlgo
MoochoPack::NLPAlgoConfigMamaJama	This is a do all configuration class for NLPAlgo
MoochoPack::NLPAlgoContainer	Implementation for NLPAlgo solver
MoochoPack::NLPAlgoInterface	Interface NLPAlgoContainer uses to access NLPAlgo
MoochoPack::NLPAlgoState	Reduced space SQP state encapsulation interface
MoochoPack::NLPSolverClientInterface	This is the most basic interface that clients use to solve an NLP
MoochoPack::NLPSolverClientInterfaceSetOptions	Set options for NLPSolverClientInterface from an OptionsFromStream object
MoochoPack::NumFixedDepIndep_AddedStep	Computes and outputs the number of fixed variables from the dependent and independent set.
MoochoPack::PostEvalNewPointBarrier_Step	Standard evaluation step class for extra parameters in primal/dual barrier method
MoochoPack::PostProcessBarrierLineSearch_Step	Fraction to boundary rule for calculating alpha max
MoochoPack::PreEvalNewPointBarrier_Step	Standard evaluation step class for extra parameters in primal/dual barrier method
MoochoPack::PreProcessBarrierLineSearch_Step	Fraction to boundary rule for calculating alpha max
MoochoPack::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
MoochoPack::QPFailure	Thrown if a the QP failed and was not corrected
MoochoPack::QPFailureReinitReducedHessian_Step	Directs the algorithm to reinitalize the reduced Hessian on the event of a QP failure
MoochoPack::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
MoochoPack::QuasiNewtonStats	Class for storing statistics about the Quasi-Newton updating
MoochoPack::QuasiNormalStepStd_Step	Calculates the range space step by, solving for py = -inv(R)*c(equ_decomp), then setting Ypy = Y * py
MoochoPack::QuasiRangeSpaceStep_Strategy	Abstract interface for a strategy object that will compute a step that will approximalty solve a range space subproblem {abstract}
MoochoPack::QuasiRangeSpaceStepStd_Strategy	Strategy class for computing a quasi-range-space step by solving the approximate range space problem directly
MoochoPack::QuasiRangeSpaceStepTailoredApproach_Strategy	Strategy class for computing a quasi range space step for the tailored approach NLP interface
MoochoPack::ReducedGradientStd_Step	Computes the reducecd gradient of the objective rGf_k = Z_k' * Gf_k
MoochoPack::ReducedHessianExactStd_Step	Computes the exact reduced Hessian rHL_k = Z_k' * HL_k * Z_k
MoochoPack::ReducedHessianSecantUpdate_Strategy	Strategy interface for performing secant updates {abstract}
MoochoPack::ReducedHessianSecantUpdateBFGSFull_Strategy	Perform BFGS updates on full reduced Hessian
MoochoPack::ReducedHessianSecantUpdateBFGSProjected_Strategy	Perform BFGS updates on only the free independent (super basic) variables
MoochoPack::ReducedHessianSecantUpdateBFGSProjected_StrategySetOptions	Set options for ReducedHessianSecantUpdateBFGSProjected_Strategy from a OptionsFromStream object
MoochoPack::ReducedHessianSecantUpdateLPBFGS_Strategy	Perform BFGS updates on only the free independent (super basic) variables
MoochoPack::ReducedHessianSecantUpdateLPBFGS_StrategySetOptions	Set options for ReducedHessianSecantUpdateBFGSProjected_Strategy from a OptionsFromStream object
MoochoPack::ReducedHessianSecantUpdateStd_Step	Updates rHL_k using a secant update
MoochoPack::ReducedHessianSerialization_Step	Serializes rHL_k to and from a file
MoochoPack::SetDBoundsStd_AddedStep	Computes the bounds for the QP subproblem from the NLP bounds
MoochoPack::NLPAlgoConfigMamaJama::SOptionValues
MoochoPack::DecompositionSystemStateStepBuilderStd::SOptionValues
MoochoPack::NLPAlgoConfigIP::SOptionValues
MoochoPack::TangentialStepIP_Step	Null Space Step for Interior Point algorithm
MoochoPack::TangentialStepWithInequStd_Step	Solves the reduced QP subproblem with bounds and/or general inequalities
MoochoPack::TangentialStepWithInequStd_StepSetOptions	Set options for TangentialStepWithInequStd_Step from an OptionsFromStream object
MoochoPack::TangentialStepWithoutBounds_Step	Solves the unconstrained QP subproblem: min qp_grad' * pz + (1/2) * pz' * rHL * pz
MoochoPack::TestFailed	Thrown if a runtime test failed
MoochoPack::UpdateBarrierParameter_Step	Barrier Parameter (mu) Update
MoochoPack::UpdateReducedSigma_Step	Standard class for updating the reduced sigma for interior point optimization