Ipopt::AdaptiveMuUpdate | Non-monotone mu update |
Ipopt::AlgorithmBuilder | Builder to create a complete IpoptAlg object |
Ipopt::AlgorithmStrategyObject | This is the base class for all algorithm strategy objects |
ampl_info | |
Bonmin::AmplInterface | Class for providing an Osi interface to Ipopt with an ampl nl file as input |
Ipopt::AmplOptionsList | Class for storing a number of AMPL options that should be registered to the AMPL Solver library interface |
Ipopt::AmplOptionsList::AmplOption | Ampl Option class, contains name, type and description for an AMPL option |
Ipopt::AmplOptionsList::PrivatInfo | |
Ipopt::AmplSuffixHandler | |
Bonmin::AmplTMINLP | Ampl MINLP Interface |
Ipopt::AmplTNLP | Ampl Interface |
Array< Type > | |
ArrayOfMatrices | |
Ipopt::AugRestoSystemSolver | Class that converts the an augmented system with compound restoration pieces into a smaller "pivoted" system to be solved with an existing AugSystemSolver |
Bonmin::AuxInfo | Bonmin class for passing info between components of branch-and-cuts |
Bonmin::Bab | |
Bonmin::BabInfo | Bonmin class for passing info between components of branch-and-cuts |
Bonmin::BabSetupBase | A class to have all elements necessary to setup a branch-and-bound |
Bonmin::BabSetupBase::CuttingMethod | Type for cut generation method with its frequency and string identification |
Ipopt::BacktrackingLineSearch | General implementation of a backtracking line search |
Ipopt::BacktrackingLSAcceptor | Base class for backtracking line search acceptors |
BB_cut | Simple representation of a cut by storing non zero coefficients only |
BitVector128 | |
blockStruct | |
BM_BranchData | |
BM_init | |
BM_lp | |
BM_node | |
BM_pack | |
BM_par | |
BM_SB_result | |
BM_stats | |
BM_tm | |
Bonmin::BonCbcFullNodeInfo | Holds information for recreating a subproblem by incremental change from the parent for Bonmin |
Bonmin::BonCbcPartialNodeInfo | Holds information for recreating a subproblem by incremental change from the parent for |
Bonmin::BonChooseVariable | This class chooses a variable to branch on |
Bonmin::BonChooseVariable::Messages | |
Bonmin::BonminAmplSetup | |
Bonmin::BonminSetup | |
BonRandomChoice | |
Bonmin::BoundsReader | Reads a file containing change bounds for variables |
Bonmin::BqpdSolver | |
Bonmin::BqpdSolver::cachedInfo | Cached information for reoptimizing |
Bonmin::BqpdSolver::UnsolvedBqpdError | |
Bonmin::BqpdWarmStart | Warm start for filter interface |
Bonmin::BranchingTQP | This is an adapter class that converts a TMINLP2TNLP object into a TNLP, which is now just a QP |
Ipopt::CachedResults< T > | Templated class for Chached Results |
CbcBranchAllDifferent | Define a branch class that branches so that it is only satsified if all members have different values So cut is x <= y-1 or x >= y+1 |
CbcBranchCut | Define a cut branching class |
CbcBranchDecision | Abstract branching decision base class |
CbcBranchDefaultDecision | Branching decision default class |
CbcBranchDynamicDecision | Branching decision dynamic class |
CbcBranchingObject | Abstract branching object base class Now just difference with OsiBranchingObject |
CbcBranchToFixLots | Define a branch class that branches so that one way variables are fixed while the other way cuts off that solution |
CbcBranchUserDecision | Branching decision user class |
CbcCbcParam | Class for control parameters that act on a CbcModel object |
CbcChooseVariable | |
CbcClique | Define a clique class |
CbcCliqueBranchingObject | Branching object for unordered cliques |
CbcCompare | |
CbcCompareBase | |
CbcCompareDefault | |
CbcCompareDepth | |
CbcCompareEstimate | |
CbcCompareObjective | |
CbcCompareUser | |
CbcConsequence | Abstract base class for consequent bounds |
CbcCountRowCut | OsiRowCut augmented with bookkeeping |
CbcCutBranchingObject | Cut branching object |
CbcCutGenerator | Interface between Cbc and Cut Generation Library |
CbcCutModifier | Abstract cut modifier base class |
CbcCutSubsetModifier | Simple cut modifier base class |
Bonmin::CbcDfsDiver | A more elaborate diving class |
Bonmin::CbcDiver | Class to do diving in the tree |
CbcDummyBranchingObject | Dummy branching object |
CbcDynamicPseudoCostBranchingObject | Simple branching object for an integer variable with pseudo costs |
CbcEventHandler | Base class for Cbc event handling |
CbcFathom | Fathom base class |
CbcFathomDynamicProgramming | FathomDynamicProgramming class |
CbcFeasibilityBase | |
CbcFixingBranchingObject | General Branching Object class |
CbcFixVariable | Class for consequent bounds |
CbcFollowOn | Define a follow on class |
CbcFollowOn2 | Define a follow on class |
CbcFullNodeInfo | Holds complete information for recreating a subproblem |
CbcGenCtlBlk | |
CbcGenCtlBlk::babState_struct | State of branch-and-cut |
CbcGenCtlBlk::cbcParamsInfo_struct | Start and end of CbcModel parameters in parameter vector |
CbcGenCtlBlk::chooseStrongCtl_struct | Control variables for a strong branching method |
CbcGenCtlBlk::cliqueCtl_struct | Control variable and prototype for clique cut generator |
CbcGenCtlBlk::combineCtl_struct | Control variable and prototype for combine heuristic |
CbcGenCtlBlk::debugSolInfo_struct | Array of primal variable values for debugging |
CbcGenCtlBlk::djFixCtl_struct | Control use of reduced cost fixing prior to B&C |
CbcGenCtlBlk::flowCtl_struct | Control variable and prototype for flow cover cut generator |
CbcGenCtlBlk::fpumpCtl_struct | Control variable and prototype for feasibility pump heuristic |
CbcGenCtlBlk::genParamsInfo_struct | Start and end of cbc-generic parameters in parameter vector |
CbcGenCtlBlk::gomoryCtl_struct | Control variable and prototype for Gomory cut generator |
CbcGenCtlBlk::greedyCoverCtl_struct | Control variable and prototype for greedy cover heuristic |
CbcGenCtlBlk::greedyEqualityCtl_struct | Control variable and prototype for greedy equality heuristic |
CbcGenCtlBlk::knapsackCtl_struct | Control variable and prototype for knapsack cover cut generator |
CbcGenCtlBlk::localTreeCtl_struct | Control variables for local tree |
CbcGenCtlBlk::mirCtl_struct | Control variable and prototype for MIR cut generator |
CbcGenCtlBlk::oddHoleCtl_struct | Control variable and prototype for odd hole cut generator |
CbcGenCtlBlk::osiParamsInfo_struct | Start and end of OsiSolverInterface parameters in parameter vector |
CbcGenCtlBlk::probingCtl_struct | Control variable and prototype for probing cut generator |
CbcGenCtlBlk::redSplitCtl_struct | Control variable and prototype for reduce-and-split cut generator |
CbcGenCtlBlk::roundingCtl_struct | Control variable and prototype for simple rounding heuristic |
CbcGenCtlBlk::twomirCtl_struct | Control variable and prototype for Two-MIR cut generator |
CbcGenParam | Class for cbc-generic control parameters |
CbcHeuristic | Heuristic base class |
CbcHeuristicDive | Dive class |
CbcHeuristicDiveCoefficient | DiveCoefficient class |
CbcHeuristicDiveFractional | DiveFractional class |
CbcHeuristicDiveGuided | DiveGuided class |
CbcHeuristicDiveVectorLength | DiveVectorLength class |
CbcHeuristicDynamic3 | Heuristic - just picks up any good solution |
CbcHeuristicFPump | Rounding class |
CbcHeuristicGreedyCover | Greedy heuristic classes |
CbcHeuristicGreedyEquality | |
CbcHeuristicLocal | LocalSearch class |
CbcHeuristicNode | A class describing the branching decisions that were made to get to the node where a heuristics was invoked from |
CbcHeuristicNodeList | |
CbcHeuristicPartial | Partial solution class If user knows a partial solution this tries to get an integer solution it uses hotstart information |
CbcHeuristicRENS | LocalSearch class |
CbcHeuristicRINS | LocalSearch class |
CbcIntegerBranchingObject | Simple branching object for an integer variable |
CbcIntegerPseudoCostBranchingObject | Simple branching object for an integer variable with pseudo costs |
CbcLink | Define Special Linked Ordered Sets |
CbcLinkBranchingObject | Branching object for Special ordered sets |
CbcLongCliqueBranchingObject | Unordered Clique Branching Object class |
CbcLotsize | Lotsize class |
CbcLotsizeBranchingObject | Lotsize branching object |
CbcMessage | |
CbcModel | Simple Branch and bound class |
CbcNewTree | |
Bonmin::CbcNlpStrategy | |
CbcNode | Information required while the node is live |
CbcNodeInfo | Information required to recreate the subproblem at this node |
CbcNWay | Define an n-way class for variables |
CbcNWayBranchingObject | N way branching Object class |
Bonmin::CbcOaStrategy | A class to pass on a CbcStrategy to OA sub-milp solver |
CbcObject | |
CbcObjectUpdateData | |
CbcOrClpParam | Very simple class for setting parameters |
CbcOsiParam | Class for control parameters that act on a OsiSolverInterface object |
CbcOsiSolver | This is for codes where solver needs to know about CbcModel |
CbcParam | Very simple class for setting parameters |
CbcPartialNodeInfo | Holds information for recreating a subproblem by incremental change from the parent |
Bonmin::CbcProbedDiver | Class to do probed diving in the tree |
CbcRounding | Rounding class |
CbcSerendipity | Heuristic - just picks up any good solution found by solver - see OsiBabSolver |
CbcSimpleInteger | Define a single integer class |
CbcSimpleIntegerDynamicPseudoCost | Define a single integer class but with dynamic pseudo costs |
CbcSimpleIntegerFixed | Define a single integer class where branching is forced until fixed |
CbcSimpleIntegerPseudoCost | Define a single integer class but with pseudo costs |
CbcSolver | This allows the use of the standalone solver in a flexible manner It has an original OsiClpSolverInterface and CbcModel which it can use repeatedly e.g |
CbcSolver2 | This is to allow the user to replace initialSolve and resolve |
CbcSolver3 | This is to allow the user to replace initialSolve and resolve |
CbcSolverLongThin | This is to allow the user to replace initialSolve and resolve |
CbcSolverUsefulData | Structure to hold useful arrays |
CbcSOS | Define Special Ordered Sets of type 1 and 2 |
CbcSOSBranchingObject | Branching object for Special ordered sets |
CbcStatistics | For gathering statistics |
CbcStopNow | This allows the use of a call back class to decide whether to stop |
CbcStrategy | Strategy base class |
CbcStrategyDefault | Default class |
CbcStrategyDefaultSubTree | Default class for sub trees |
CbcStrategyNull | Null class |
CbcStrongInfo | Abstract base class for `objects' |
CbcTree | |
CbcTreeLocal | |
CbcUser | This allows the use of an unknown user stuff including modeling languages |
CglAllDifferent | AllDifferent Cut Generator Class This has a number of sets |
CglClique | |
CglClique::fnode | A node of the fractional graph |
CglClique::frac_graph | A graph corresponding to a fractional solution of an LP |
CglCutGenerator | Cut Generator Base Class |
CglDuplicateRow | DuplicateRow Cut Generator Class |
CglFakeClique | This works on a fake solver i.e. invented rows |
CglFlowCover | Lifed Simple Generalized Flow Cover Cut Generator Class |
CglFlowVUB | Varibale upper bound class |
CglGomory | Gomory Cut Generator Class |
CglKnapsackCover | Knapsack Cover Cut Generator Class |
CglLandP | |
CglLandP::CachedData | Some informations that will be changed by the pivots and that we want to keep |
CglLandP::NoBasisError | |
CglLandP::Parameters | Class storing parameters |
CglLandP::SimplexInterfaceError | |
LAP::CglLandPSimplex | |
LAP::CglLandPSimplex::extraInfo | |
LAP::CglLandPSimplex::TabRow | |
CglLiftAndProject | Lift And Project Cut Generator Class |
CglMessage | This deals with Cgl messages (as against Osi messages etc) |
CglMixedIntegerRounding | Mixed Integer Rounding Cut Generator Class |
CglMixedIntegerRounding2 | Mixed Integer Rounding Cut Generator Class |
CglMixIntRoundVUB | |
CglMixIntRoundVUB2 | |
CglOddHole | Odd Hole Cut Generator Class |
CglParam | Class collecting parameters for all cut generators |
CglPreProcess | Class for preProcessing and postProcessing |
CglProbing | Probing Cut Generator Class |
CglProbing::cliqueEntry | Entries for clique |
CglProbing::cliqueType | Clique type |
CglProbing::disaggregation_struct_tag | Disaggregation cuts and for building cliques |
CglProbing::disaggregationAction | Only useful type of disaggregation is most normal For now just done for 0-1 variables Can be used for building cliques |
CglRedSplit | Gomory Reduce-and-Split Cut Generator Class; See method generateCuts() |
CglRedSplitParam | Class collecting parameters the Reduced-and-split cut generator |
CglResidualCapacity | Residual Capacity Inequalities Cut Generator Class |
CglSimpleRounding | Simple Rounding Cut Generator Class
|
CglStored | Stored Cut Generator Class |
CglTemporary | Stored Temporary Cut Generator Class - destroyed after first use |
CglTreeInfo | Information about where the cut generator is invoked from |
CglTreeProbingInfo | |
CglTwomir | Twostep MIR Cut Generator Class |
CglValidator | Class to validate or reject a cut |
Ipopt::CGPenaltyCq | Class for all Chen-Goldfarb penalty method specific calculated quantities |
Ipopt::CGPenaltyData | Class to organize all the additional data required by the Chen-Goldfarb penalty function algorithm |
Ipopt::CGPenaltyLSAcceptor | Line search acceptor, based on the Chen-Goldfarb penalty function approach |
Ipopt::CGPerturbationHandler | Class for handling the perturbation factors delta_x, delta_s, delta_c, and delta_d in the primal dual system |
Ipopt::CGSearchDirCalculator | Implementation of the search direction calculator that computes the Chen-Goldfarb step for the current barrier and penalty parameter |
ClpAmplObjective | Ampl Objective Class |
ClpCholeskyBase | Base class for Clp Cholesky factorization Will do better factorization |
ClpCholeskyDense | Dense class for Clp Cholesky factorization |
ClpCholeskyTaucs | Taucs class for Clp Cholesky factorization |
ClpCholeskyUfl | Ufl class for Clp Cholesky factorization |
ClpCholeskyWssmp | Wssmp class for Clp Cholesky factorization |
ClpCholeskyWssmpKKT | WssmpKKT class for Clp Cholesky factorization |
ClpConstraint | Constraint Abstract Base Class |
ClpConstraintAmpl | Ampl Constraint Class |
ClpConstraintLinear | Linear Constraint Class |
ClpConstraintQuadratic | Quadratic Constraint Class |
ClpDataSave | This is a tiny class where data can be saved round calls |
ClpDisasterHandler | Base class for Clp disaster handling |
ClpDualRowDantzig | Dual Row Pivot Dantzig Algorithm Class |
ClpDualRowPivot | Dual Row Pivot Abstract Base Class |
ClpDualRowSteepest | Dual Row Pivot Steepest Edge Algorithm Class |
ClpDummyMatrix | This implements a dummy matrix as derived from ClpMatrixBase |
ClpDynamicExampleMatrix | This implements a dynamic matrix when we have a limit on the number of "interesting rows" |
ClpDynamicMatrix | This implements a dynamic matrix when we have a limit on the number of "interesting rows" |
ClpEventHandler | Base class for Clp event handling |
ClpFactorization | This just implements CoinFactorization when an ClpMatrixBase object is passed |
ClpGubDynamicMatrix | This implements Gub rows plus a ClpPackedMatrix |
ClpGubMatrix | This implements Gub rows plus a ClpPackedMatrix |
ClpInterior | This solves LPs using interior point methods |
ClpLinearObjective | Linear Objective Class |
ClpLsqr | This class implements LSQR |
ClpMatrixBase | Abstract base class for Clp Matrices |
ClpMessage | This deals with Clp messages (as against Osi messages etc) |
ClpModel | |
ClpNetworkBasis | This deals with Factorization and Updates for network structures |
ClpNetworkMatrix | This implements a simple network matrix as derived from ClpMatrixBase |
ClpNode | |
ClpNode::branchState | |
ClpNodeStuff | |
ClpNonLinearCost | |
ClpObjective | Objective Abstract Base Class |
ClpPackedMatrix | |
ClpPackedMatrix2 | |
ClpPackedMatrix3 | |
ClpPdco | This solves problems in Primal Dual Convex Optimization |
ClpPdcoBase | Abstract base class for tailoring everything for Pcdo |
ClpPlusMinusOneMatrix | This implements a simple +- one matrix as derived from ClpMatrixBase |
ClpPredictorCorrector | This solves LPs using the predictor-corrector method due to Mehrotra |
ClpPresolve | This is the Clp interface to CoinPresolve |
ClpPrimalColumnDantzig | Primal Column Pivot Dantzig Algorithm Class |
ClpPrimalColumnPivot | Primal Column Pivot Abstract Base Class |
ClpPrimalColumnSteepest | Primal Column Pivot Steepest Edge Algorithm Class |
ClpPrimalQuadraticDantzig | Primal Column Pivot Dantzig Algorithm Class |
ClpQuadInterface | This is to allow the user to replace initialSolve and resolve |
ClpQuadraticObjective | Quadratic Objective Class |
ClpSimplex | This solves LPs using the simplex method |
ClpSimplexDual | This solves LPs using the dual simplex method |
ClpSimplexNonlinear | This solves non-linear LPs using the primal simplex method |
ClpSimplexOther | This is for Simplex stuff which is neither dual nor primal |
ClpSimplexPrimal | This solves LPs using the primal simplex method |
ClpSimplexProgress | For saving extra information to see if looping |
ClpSolve | This is a very simple class to guide algorithms |
CoinAbsFltEq | Equality to an absolute tolerance |
CoinArrayWithLength | Pointer with length in bytes |
CoinBigIndexArrayWithLength | CoinBigIndex * version |
CoinBuild | In many cases it is natural to build a model by adding one row at a time |
CoinDenseFactorization | This deals with Factorization and Updates This is a simple dense version so other people can write a better one |
CoinDenseVector< T > | Dense Vector |
CoinDoubleArrayWithLength | Double * version |
CoinError | Error Class thrown by an exception |
CoinExternalVectorFirstGreater_2< S, T, V > | Function operator |
CoinExternalVectorFirstGreater_3< S, T, U, V > | Function operator |
CoinExternalVectorFirstLess_2< S, T, V > | Function operator |
CoinExternalVectorFirstLess_3< S, T, U, V > | Function operator |
CoinFactorization | This deals with Factorization and Updates |
CoinFileInput | Abstract base class for file input classes |
CoinFileIOBase | Base class for FileIO classes |
CoinFileOutput | Abstract base class for file output classes |
CoinFirstAbsGreater_2< S, T > | Function operator |
CoinFirstAbsGreater_3< S, T, U > | Function operator |
CoinFirstAbsLess_2< S, T > | Function operator |
CoinFirstAbsLess_3< S, T, U > | Function operator |
CoinFirstGreater_2< S, T > | Function operator |
CoinFirstGreater_3< S, T, U > | Function operator |
CoinFirstLess_2< S, T > | Function operator |
CoinFirstLess_3< S, T, U > | Function operator |
CoinIndexedVector | Indexed Vector |
CoinIntArrayWithLength | Int * version |
CoinLpIO | Class to read and write Lp files |
CoinLpIO::CoinHashLink | |
CoinMessage | The standard set of Coin messages |
CoinMessageHandler | Base class for message handling |
CoinMessages | Class to hold and manipulate an array of massaged messages |
CoinModel | This is a simple minded model which is stored in a format which makes it easier to construct and modify but not efficient for algorithms |
CoinModelHash | |
CoinModelHash2 | For int,int hashing |
CoinModelHashLink | For names and hashing |
CoinModelLink | For going through row or column |
CoinModelLinkedList | |
CoinModelTriple | For linked lists |
CoinMpsCardReader | Very simple code for reading MPS data |
CoinMpsIO | MPS IO Interface |
CoinMpsIO::CoinHashLink | |
CoinOneMessage | Class for one massaged message |
CoinPackedMatrix | Sparse Matrix Base Class |
CoinPackedVector | Sparse Vector |
CoinPackedVectorBase | Abstract base class for various sparse vectors |
CoinPair< S, T > | An ordered pair |
CoinParam | A base class for `keyword value' command line parameters |
CoinPostsolveMatrix | Augments CoinPrePostsolveMatrix with information about the problem that is only needed during postsolve |
CoinPrePostsolveMatrix | Collects all the information about the problem that is needed in both presolve and postsolve |
CoinPresolveAction | Abstract base class of all presolve routines |
CoinPresolveMatrix | Augments CoinPrePostsolveMatrix with information about the problem that is only needed during presolve |
CoinRelFltEq | Equality to a scaled tolerance |
CoinSearchTree< Comp > | |
CoinSearchTreeBase | |
CoinSearchTreeCompareBest | Best first search |
CoinSearchTreeCompareBreadth | |
CoinSearchTreeCompareDepth | Depth First Search |
CoinSearchTreeComparePreferred | Depth First Search |
CoinSearchTreeManager | |
CoinSet | Very simple class for containing data on set |
CoinShallowPackedVector | Shallow Sparse Vector |
CoinSnapshot | NON Abstract Base Class for interfacing with cut generators or branching code or |
CoinSnapshot::coinOwned | To say whether arrays etc are owned by CoinSnapshot |
CoinSosSet | Very simple class for containing SOS set |
CoinThreadRandom | Class for thread specific random numbers |
CoinTimer | This class implements a timer that also implements a tracing functionality |
CoinTreeNode | A class from which the real tree nodes should be derived from |
CoinTreeSiblings | |
CoinTriple< S, T, U > | |
CoinUnsignedIntArrayWithLength | Unsigned int * version |
CoinWarmStart | Abstract base class for warm start information |
CoinWarmStartBasis | The default COIN simplex (basis-oriented) warm start class |
CoinWarmStartBasisDiff | A `diff' between two CoinWarmStartBasis objects |
CoinWarmStartDiff | Abstract base class for warm start `diff' objects |
CoinWarmStartDual | WarmStart information that is only a dual vector |
CoinWarmStartDualDiff | A `diff' between two CoinWarmStartDual objects |
CoinWarmStartPrimalDual | WarmStart information that is only a dual vector |
CoinWarmStartPrimalDualDiff | A `diff' between two CoinWarmStartPrimalDual objects |
CoinWarmStartVector< T > | WarmStart information that is only a vector |
CoinWarmStartVectorDiff< T > | A `diff' between two CoinWarmStartVector objects |
CoinWarmStartVectorPair< T, U > | |
CoinWarmStartVectorPairDiff< T, U > | |
CoinYacc | |
Ipopt::CompositeNLP | This class creates a composite NLP from a list of NLP's |
Ipopt::CompoundMatrix | Class for Matrices consisting of other matrices |
Ipopt::CompoundMatrixSpace | This is the matrix space for CompoundMatrix |
Ipopt::CompoundSymMatrix | Class for symmetric matrices consisting of other matrices |
Ipopt::CompoundSymMatrixSpace | This is the matrix space for CompoundSymMatrix |
Ipopt::CompoundVector | Class of Vectors consisting of other vectors |
Ipopt::CompoundVectorSpace | This vectors space is the vector space for CompoundVector |
Ipopt::ConvergenceCheck | Base class for checking the algorithm termination criteria |
Bonmin::CouenneInfo | Bonmin class for passing info between components of branch-and-cuts |
Bonmin::CouenneInfo::NlpSolution | Class for storing an Nlp Solution |
Bonmin::CouenneInterface | |
Bonmin::CouenneSetup | |
Bonmin::CurvatureEstimator | |
Bonmin::CurvBranchingSolver | Implementation of BonChooseVariable for curvature-based braching |
cutParams | |
Bonmin::CutStrengthener | Class for strengthening OA cuts, and generating additional ones |
Bonmin::CutStrengthener::StrengtheningTNLP | Class implementing the TNLP for strengthening one cut |
Ipopt::DefaultIterateInitializer | Class implementing the default initialization procedure (based on user options) for the iterates |
Ipopt::DenseGenMatrix | Class for dense general matrices |
Ipopt::DenseGenMatrixSpace | This is the matrix space for DenseGenMatrix |
Ipopt::DenseSymMatrix | Class for dense symetrix matrices |
Ipopt::DenseSymMatrixSpace | This is the matrix space for DenseSymMatrix |
Ipopt::DenseVector | Dense Vector Implementation |
Ipopt::DenseVectorSpace | This vectors space is the vector space for DenseVector |
Ipopt::DependentResult< T > | Templated class which stores one entry for the CachedResult class |
DGG_constraint_t | |
DGG_data_t | |
DGG_list_t | |
Ipopt::DiagMatrix | Class for diagonal matrices |
Ipopt::DiagMatrixSpace | This is the matrix space for DiagMatrix |
Bonmin::DiverCompare | |
do_tighten_action | |
do_tighten_action::action | |
doubleton_action | Solve ax+by=c for y and substitute y out of the problem |
doubleton_action::action | |
drop_empty_cols_action | Physically removes empty columns in presolve, and reinserts empty columns in postsolve |
drop_empty_cols_action::action | |
drop_empty_rows_action | Physically removes empty rows in presolve, and reinserts empty rows in postsolve |
drop_empty_rows_action::action | |
drop_zero_coefficients_action | Removal of explicit zeros |
dropped_zero | Tracking information for an explicit zero coefficient |
Bonmin::DummyHeuristic | |
dupcol_action | Detect and remove duplicate columns |
dupcol_action::action | |
duprow_action | Detect and remove duplicate rows |
duprow_action::action | |
Bonmin::EcpCuts | |
Ipopt::EqMultiplierCalculator | Base Class for objects that compute estimates for the equality constraint multipliers y_c and y_d |
Ipopt::EquilibrationScaling | This class does problem scaling by setting the scaling parameters based on the maximum of the gradient at the user provided initial point |
Ipopt::ExactHessianUpdater | Implementation of the HessianUpdater for the use of exact second derivatives |
Ipopt::ExpansionMatrix | Class for expansion/projection matrices |
Ipopt::ExpansionMatrixSpace | This is the matrix space for ExpansionMatrix |
Ipopt::FileJournal | FileJournal class |
Ipopt::Filter | Class for the filter |
Ipopt::FilterEntry | Class for one filter entry |
Ipopt::FilterLSAcceptor | Filter line search |
Bonmin::FilterSolver | |
Bonmin::FilterSolver::cachedInfo | Cached information for reoptimizing |
Bonmin::FilterSolver::UnsolvedFilterError | |
Bonmin::FilterWarmStart | Warm start for filter interface |
Bonmin::FilterWarmStartDiff | |
fixEntry | Derived class to pick up probing info |
forcing_constraint_action | Detect and process forcing constraints and useless constraints |
forcing_constraint_action::action | |
Ipopt::GenAugSystemSolver | Solver for the augmented system using GenKKTSolverInterfaces |
Ipopt::GenKKTSolverInterface | Base class for interfaces to symmetric indefinite linear solvers for generic matrices |
Ipopt::GenTMatrix | Class for general matrices stored in triplet format |
Ipopt::GenTMatrixSpace | This is the matrix space for a GenTMatrix with fixed sparsity structure |
Ipopt::GradientScaling | This class does problem scaling by setting the scaling parameters based on the maximum of the gradient at the user provided initial point |
Bonmin::GuessHeuristic | |
Ipopt::HessianUpdater | Abstract base class for objects responsible for updating the Hessian information |
Bonmin::HotInfo | |
HS071_NLP | C++ Example NLP for interfacing a problem with IPOPT |
Ipopt::IdentityMatrix | Class for Matrices which are multiples of the identity matrix |
Ipopt::IdentityMatrixSpace | This is the matrix space for IdentityMatrix |
Idiot | This class implements a very silly algorithm |
IdiotResult | For use internally |
implied_free_action | Detect and process implied free variables |
implied_free_action::action | |
Info | ******** DATA to be moved into protected section of ClpInterior |
Bonmin::InitHeuristic | A heuristic that stores the initial solution of the NLP |
Ipopt::IpoptAlgorithm | The main ipopt algorithm class |
Ipopt::IpoptApplication | This is the main application class for making calls to Ipopt |
Ipopt::IpoptCalculatedQuantities | Class for all IPOPT specific calculated quantities |
Ipopt::IpoptData | Class to organize all the data required by the algorithm |
Ipopt::IpoptException | This is the base class for all exceptions |
Bonmin::IpoptInteriorWarmStarter | |
Ipopt::IpoptNLP | This is the abstract base class for classes that map the traditional NLP into something that is more useful by Ipopt |
Bonmin::IpoptSolver | |
Bonmin::IpoptSolver::UnsolvedIpoptError | |
Bonmin::IpoptWarmStart | Class for storing warm start informations for Ipopt |
Bonmin::IpoptWarmStartDiff | Diff class for IpoptWarmStart |
isolated_constraint_action | |
Ipopt::IterateInitializer | Base class for all methods for initializing the iterates |
Ipopt::IteratesVector | Specialized CompoundVector class specifically for the algorithm iterates |
Ipopt::IteratesVectorSpace | Vector Space for the IteratesVector class |
Ipopt::IterationOutput | Base class for objects that do the output summary per iteration |
Ipopt::Journal | Journal class (part of the Journalist implementation |
Ipopt::Journalist | Class responsible for all message output |
LAP::LandPMessages | Message handler for lift-and-project simplex |
LAP::LapMessages | Output messages for Cgl |
Ipopt::LeastSquareMultipliers | Class for calculator for the least-square equality constraint multipliers |
Ipopt::LimMemQuasiNewtonUpdater | Implementation of the HessianUpdater for limit-memory quasi-Newton approximation of the Lagrangian Hessian |
Ipopt::LineSearch | Base class for line search objects |
Ipopt::LoqoMuOracle | Implementation of the LOQO formula for computing the barrier parameter |
Ipopt::LowRankAugSystemSolver | Solver for the augmented system with LowRankUpdateSymMatrix Hessian matrices |
Ipopt::LowRankUpdateSymMatrix | Class for symmetric matrices, represented as low-rank updates |
Ipopt::LowRankUpdateSymMatrixSpace | This is the matrix space for LowRankUpdateSymMatrix |
Bonmin::LpBranchingSolver | Implementation of BonChooseVariable for curvature-based braching |
LuksanVlcek1 | Implementation of Example 5.1 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L |
LuksanVlcek2 | Implementation of Example 5.2 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L |
LuksanVlcek3 | Implementation of Example 5.3 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L |
LuksanVlcek4 | Implementation of Example 5.4 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L |
LuksanVlcek5 | Implementation of Example 5.5 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L |
LuksanVlcek6 | Implementation of Example 5.6 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L |
LuksanVlcek7 | Implementation of Example 5.7 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L |
Ipopt::Ma27TSolverInterface | Interface to the symmetric linear solver MA27, derived from SparseSymLinearSolverInterface |
Ipopt::Ma28TDependencyDetector | Base class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian |
Ipopt::Ma57TSolverInterface | Interface to the symmetric linear solver MA57, derived from SparseSymLinearSolverInterface |
make_fixed_action | Fix a variable at a specified bound |
make_fixed_action::action | Structure to preserve the bound overwritten when fixing a variable |
MatlabException | |
MatlabFunctionHandle | |
Ipopt::MatlabJournal | |
MatlabOption | |
MatlabProgram | |
MatlabScalar | |
MatlabString | |
Ipopt::Matrix | Matrix Base Class |
Matrix | |
Ipopt::MatrixSpace | MatrixSpace base class, corresponding to the Matrix base class |
Ipopt::Mc19TSymScalingMethod | Class for the method for computing scaling factors for symmetric matrices in triplet format, using MC19 |
Ipopt::MinC_1NrmRestorationPhase | Restoration Phase that minimizes the 1-norm of the constraint violation - using the interior point method (Ipopt) |
Bonmin::MinlpFeasPump | |
MittelmannBndryCntrlDiri1 | Class implementating Example 1 |
MittelmannBndryCntrlDiri2 | Class implementating Example 2 |
MittelmannBndryCntrlDiri3 | Class implementating Example 3 |
MittelmannBndryCntrlDiri3D | Class implementating Example 1 |
MittelmannBndryCntrlDiri3D_27 | Class implementating case with convex quadratic penalty function |
MittelmannBndryCntrlDiri3D_27BT | Class implementating case with nonconvex Beaton-Tukey like penalty function |
MittelmannBndryCntrlDiri3Dsin | Class implementating Example 1 |
MittelmannBndryCntrlDiri4 | Class implementating Example 4 |
MittelmannBndryCntrlDiriBase | Base class for boundary control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-4 in "Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
MittelmannBndryCntrlDiriBase3D | Base class for boundary control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-4 in "Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
MittelmannBndryCntrlDiriBase3D_27 | Base class for boundary control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-4 in "Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
MittelmannBndryCntrlDiriBase3Dsin | Base class for boundary control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-4 in "Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
MittelmannBndryCntrlNeum1 | Class implementating Example 5 |
MittelmannBndryCntrlNeum2 | Class implementating Example 6 |
MittelmannBndryCntrlNeum3 | Class implementating Example 7 |
MittelmannBndryCntrlNeum4 | Class implementating Example 8 |
MittelmannBndryCntrlNeumBase | Base class for boundary control problems with Neumann boundary conditions, as formulated by Hans Mittelmann as Examples 5-8 in "Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
MittelmannDistCntrlDiri1 | Class implementating Example 1 |
MittelmannDistCntrlDiri2 | Class implementating Example 2 |
MittelmannDistCntrlDiri3 | Class implementating Example 3 |
MittelmannDistCntrlDiri3a | |
MittelmannDistCntrlDiriBase | Base class for distributed control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-3 in "Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
MittelmannDistCntrlNeumA1 | Class implementating Example 4 |
MittelmannDistCntrlNeumA2 | Class implementating Example 5 |
MittelmannDistCntrlNeumA3 | Class implementating Example 6 |
MittelmannDistCntrlNeumABase | Base class for distributed control problems with homogeneous Neumann boundary conditions, as formulated by Hans Mittelmann as Examples 4-6 in "Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
MittelmannDistCntrlNeumB1 | Class implementating Example 4 |
MittelmannDistCntrlNeumB2 | Class implementating Example 5 |
MittelmannDistCntrlNeumB3 | Class implementating Example 6 |
MittelmannDistCntrlNeumBBase | Base class for distributed control problems with homogeneous Neumann boundary conditions, as formulated by Hans Mittelmann as Examples 4-6 in "Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
MittelmannParaCntrl5_1 | |
MittelmannParaCntrl5_1::ProblemSpecs | |
MittelmannParaCntrl5_2_1 | |
MittelmannParaCntrl5_2_1::ProblemSpecs | |
MittelmannParaCntrl5_2_2 | |
MittelmannParaCntrl5_2_2::ProblemSpecs | |
MittelmannParaCntrl5_2_3 | |
MittelmannParaCntrl5_2_3::ProblemSpecs | |
MittelmannParaCntrl5_try | |
MittelmannParaCntrl5_try::ProblemSpecs | |
MittelmannParaCntrlBase< T > | Base class for parabolic and elliptic control problems, as formulated by Hans Mittelmann as problem (P) in "Sufficient Optimality for Discretized Parabolic and Elliptic Control Problems" |
Ipopt::MonotoneMuUpdate | Monotone Mu Update |
Multipliers | |
Ipopt::MultiVectorMatrix | Class for Matrices with few columns that consists of Vectors |
Ipopt::MultiVectorMatrixSpace | This is the matrix space for MultiVectorMatrix |
Ipopt::MumpsSolverInterface | Interface to the linear solver Mumps, derived from SparseSymLinearSolverInterface |
Ipopt::MuOracle | Abstract Base Class for classes that are able to compute a suggested value of the barrier parameter that can be used as an oracle in the NonmontoneMuUpdate class |
Ipopt::MuUpdate | Abstract Base Class for classes that implement methods for computing the barrier and fraction-to-the-boundary rule parameter for the current iteration |
MyEventHandler | This is so user can trap events and do useful stuff |
MyMessageHandler | |
MyNLP | C++ Example NLP for interfacing a problem with IPOPT |
myPdco | This implements a simple network matrix as derived from ClpMatrixBase |
MyTMINLP | A C++ example for interfacing an MINLP with bonmin |
Bonmin::NamesReader | A class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file) |
Bonmin::NamesReader::ltstr | String comparison strucutre |
Ipopt::NLP | Brief Class Description |
Ipopt::NLPScalingObject | This is the abstract base class for problem scaling |
Bonmin::NlpSolveHeuristic | |
Ipopt::NoNLPScalingObject | Class implementing the scaling object that doesn't to any scaling |
Bonmin::OACutGenerator2 | Class to perform OA in its classical form |
Bonmin::OaDecompositionBase | Base class for OA algorithms |
Bonmin::OaDecompositionBase::Parameters | Parameters for algorithm |
Bonmin::OaDecompositionBase::solverManip | Small class to manipulatee various things in an OsiSolverInterface and restore them |
Bonmin::OaDecompositionBase::SubMipSolver | Small class to perform the solution of sub-mips |
Bonmin::OaFeasibilityChecker | Class to perform OA in its classical form |
Bonmin::OaMessages | Output messages for Outer approximation cutting planes |
Bonmin::OaNlpOptim | Generate cuts for the nlp corresponding to continuous relaxation at a node |
Ipopt::Observer | Slight Variation of the Observer Design Pattern |
Ipopt::OptimalityErrorConvergenceCheck | Brief Class Description |
Options | ******** DATA to be moved into protected section of ClpInterior |
Ipopt::OptionsList | This class stores a list of user set options |
Ipopt::OptionsList::OptionValue | Class for storing the value and counter for each option in OptionsList |
OptParam | |
Ipopt::OrigIpoptNLP | This class maps the traditional NLP into something that is more useful by Ipopt |
Ipopt::OrigIterationOutput | Class for the iteration summary output for the original NLP |
OsiAuxInfo | This class allows for a more structured use of algorithmic tweaking to an OsiSolverInterface |
OsiBabSolver | This class allows for the use of more exotic solvers e.g |
OsiBiLinear | Define BiLinear objects |
OsiBiLinearBranchingObject | Branching object for BiLinear objects |
OsiBiLinearEquality | Define Continuous BiLinear objects for an == bound |
OsiBranchingInformation | |
OsiBranchingObject | Abstract branching object base class |
OsiCbcSolverInterface | Cbc Solver Interface |
OsiChooseStrong | This class chooses a variable to branch on |
OsiChooseStrongSubset | This class chooses a variable to branch on |
OsiChooseVariable | This class chooses a variable to branch on |
OsiClpDisasterHandler | |
OsiClpSolverInterface | Clp Solver Interface |
OsiColCut | Column Cut Class |
OsiCpxSolverInterface | CPLEX Solver Interface |
OsiCut | |
OsiCuts | Collections of row cuts and column cuts |
OsiCuts::const_iterator | Const Iterator |
OsiCuts::iterator | Iterator |
OsiCuts::OsiCutCompare | |
OsiDylpSolverInterface | COIN OSI layer for dylp |
OsiDylpWarmStartBasis | The dylp warm start class |
OsiDylpWarmStartBasisDiff | A `diff' between two OsiDylpWarmStartBasis objects |
OsiFmpSolverInterface | OSL Solver Interface |
OsiGlpkSolverInterface | GPLK Solver Interface |
OsiHotInfo | This class contains the result of strong branching on a variable When created it stores enough information for strong branching |
OsiIntegerBranchingObject | Simple branching object for an integer variable |
OsiLink | Define Special Linked Ordered Sets |
OsiLinkBranchingObject | Branching object for Linked ordered sets |
OsiLinkedBound | List of bounds which depend on other bounds |
OsiLinkedBound::boundElementAction | |
OsiLotsize | Lotsize class |
OsiLotsizeBranchingObject | Lotsize branching object |
OsiMskSolverInterface | |
OsiObject | Abstract base class for `objects' |
OsiObject2 | Define a class to add a bit of complexity to OsiObject This assumes 2 way branching |
OsiOldLink | |
OsiOldLinkBranchingObject | Branching object for Linked ordered sets |
OsiOneLink | Define data for one link |
OsiOslSolverInterface | OSL Solver Interface |
OsiPresolve | OSI interface to COIN problem simplification capabilities |
OsiPseudoCosts | This class is the placeholder for the pseudocosts used by OsiChooseStrong |
OsiRowCut | Row Cut Class |
OsiRowCut2 | Row Cut Class which refers back to row which created it |
OsiRowCutDebugger | Validate Row Cut Generator |
OsiSimpleFixedInteger | Define a single integer class - but one where you keep branching until fixed even if satisfied |
OsiSimpleInteger | Define a single integer class |
OsiSolverBranch | Solver Branch Class |
OsiSolverInterface | Solver Interface Abstract Base Class |
OsiSolverInterface::ApplyCutsReturnCode | Internal class for obtaining status from the applyCuts method |
OsiSolverLinearizedQuadratic | This is to allow the user to replace initialSolve and resolve |
OsiSolverLink | This is to allow the user to replace initialSolve and resolve This version changes coefficients |
OsiSolverResult | Solver Result Class |
OsiSOS | Define Special Ordered Sets of type 1 and 2 |
OsiSOSBranchingObject | Branching object for Special ordered sets |
OsiSpxSolverInterface | SOPLEX Solver Interface |
OsiSymSolverInterface | OSI Solver Interface for SYMPHONY |
Bonmin::OsiTMINLPInterface | This is class provides an Osi interface for a Mixed Integer Linear Program expressed as a TMINLP (so that we can use it for example as the continuous solver in Cbc) |
Bonmin::OsiTMINLPInterface::Messages | Messages outputed by an OsiTMINLPInterface |
Bonmin::OsiTMINLPInterface::OaMessageHandler | Like a CoinMessageHandler but can print a cut also |
Bonmin::OsiTMINLPInterface::OaMessages | Class to store OA Messages |
Bonmin::OsiTMINLPInterface::SimpleError | Error class to throw exceptions from OsiTMINLPInterface |
OsiTwoWayBranchingObject | This just adds two-wayness to a branching object |
OsiUsesBiLinear | Define a single variable class which is involved with OsiBiLinear objects |
OsiVolSolverInterface | Vol(ume) Solver Interface |
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_ | |
OsiXprSolverInterface | XPRESS-MP Solver Interface |
Outfo | ******** DATA to be moved into protected section of ClpInterior |
Ipopt::PardisoSolverInterface | Interface to the linear solver Pardiso, derived from SparseSymLinearSolverInterface |
Ipopt::PDFullSpaceSolver | This is the implemetation of the Primal-Dual System, using the full space approach with a direct linear solver |
Ipopt::PDPerturbationHandler | Class for handling the perturbation factors delta_x, delta_s, delta_c, and delta_d in the primal dual system |
Ipopt::PDSearchDirCalculator | Implementation of the search direction calculator that computes the pure primal dual step for the current barrier parameter |
Ipopt::PDSystemSolver | Pure Primal Dual System Solver Base Class |
Ipopt::PenaltyLSAcceptor | Filter line search |
Ipopt::PiecewisePenalty | Class for the Piecewise Penalty |
Ipopt::PiecewisePenEntry | Struct for one Piecewise Penalty entry |
Ipopt::PointPerturber | This class is a simple object for generating randomly perturbed points that are withing the NLP bounds |
presolvehlink | Links to aid in packed matrix modification |
Ipopt::ProbingMuOracle | Implementation of the probing strategy for computing the barrier parameter |
Bonmin::PseudoCosts | |
Bonmin::QpBranchingSolver | This class chooses a variable to branch on |
Ipopt::QualityFunctionMuOracle | Implementation of the probing strategy for computing the barrier parameter |
Ipopt::ReferencedObject | ReferencedObject class |
Coin::ReferencedObject | ReferencedObject class |
Ipopt::Referencer | Psydo-class, from which everything has to inherit that wants to use be registered as a Referencer for a ReferencedObject |
Ipopt::RegisteredOption | Base class for registered options |
Ipopt::RegisteredOption::string_entry | Class to hold the valid string settings for a string option |
Ipopt::RegisteredOptions | Class for storing registered options |
Bonmin::RegisteredOptions | Class to add a few more information to Ipopt::RegisteredOptions |
RegisteredTNLP | Class implemented the NLP discretization of |
RegisteredTNLPs | |
remove_dual_action | Attempt to fix variables by bounding reduced costs |
remove_fixed_action | Excise fixed variables from the model |
remove_fixed_action::action | Structure to hold information necessary to reintroduce a column into the problem representation |
Ipopt::RestoFilterConvergenceCheck | Convergence check for the restoration phase as called by the filter |
Ipopt::RestoIpoptNLP | This class maps the traditional NLP into something that is more useful by Ipopt |
Ipopt::RestoIterateInitializer | Class implementing the default initialization procedure (based on user options) for the iterates |
Ipopt::RestoIterationOutput | Class for the iteration summary output for the restoration phase |
Ipopt::RestorationPhase | Base class for different restoration phases |
Ipopt::RestoRestorationPhase | Recursive Restoration Phase for the.MinC_1NrmRestorationPhase |
Ipopt::ScaledMatrix | Class for a Matrix in conjunction with its scaling factors for row and column scaling |
Ipopt::ScaledMatrixSpace | This is the matrix space for ScaledMatrix |
Ipopt::SearchDirectionCalculator | Base class for computing the search direction for the line search |
Bonmin::SimpleReferenced< X > | |
Bonmin::SimpleReferencedPtr< X > | |
slack_doubleton_action | Convert an explicit bound constraint to a column bound |
slack_doubleton_action::action | |
slack_singleton_action | For variables with one entry |
slack_singleton_action::action | |
Bonmin::SmartAsl | |
Ipopt::SmartPtr< T > | Template class for Smart Pointers |
Coin::SmartPtr< T > | Template class for Smart Pointers |
Ipopt::SolveStatistics | This class collects statistics about an optimziation run, such as iteration count, final infeasibilities etc |
SparseMatrixStructure | |
Ipopt::SparseSymLinearSolverInterface | Base class for interfaces to symmetric indefinite linear solvers for sparse matrices |
Ipopt::StandardScalingBase | This is a base class for many standard scaling techniques |
Bonmin::StartPointReader | This class reads a file with a starting point for Ipopt initalization |
Ipopt::StdAugSystemSolver | Solver for the augmented system for triple type matrices |
Ipopt::StdInterfaceTNLP | Implementation of a TNLP for the Standard C interface |
Ipopt::StreamJournal | StreamJournal class |
Bonmin::StrongBranchingSolver | This class is the base class for a solver that can be used in BonOsiSolverInterface to perform the strong branching solves |
Ipopt::Subject | Slight Variation of the Observer Design Pattern (Subject part) |
subst_constraint_action | |
subst_constraint_action::action | |
Ipopt::SumMatrix | Class for Matrices which are sum of matrices |
Ipopt::SumMatrixSpace | Class for matrix space for SumMatrix |
Ipopt::SumSymMatrix | Class for Matrices which are sum of symmetric matrices |
Ipopt::SumSymMatrixSpace | Class for matrix space for SumSymMatrix |
Ipopt::SymLinearSolver | Base class for all derived symmetric linear solvers |
Ipopt::SymMatrix | This is the base class for all derived symmetric matrix types |
Ipopt::SymMatrixSpace | SymMatrixSpace base class, corresponding to the SymMatrix base class |
symrec | For string evaluation |
Ipopt::SymScaledMatrix | Class for a Matrix in conjunction with its scaling factors for row and column scaling |
Ipopt::SymScaledMatrixSpace | This is the matrix space for SymScaledMatrix |
Ipopt::SymTMatrix | Class for symmetric matrices stored in triplet format |
Ipopt::SymTMatrixSpace | This is the matrix space for a SymTMatrix with fixed sparsity structure |
SymWarmStart | |
Ipopt::TaggedObject | TaggedObject class |
Ipopt::TDependencyDetector | Base class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian |
Ipopt::TimedTask | This class is used to collect timing information for a particular task |
Ipopt::TimingStatistics | This class collects all timing statistics for Ipopt |
Bonmin::TMINLP | Base class for all MINLPs that use a standard triplet matrix form and dense vectors |
Bonmin::TMINLP2TNLP | This is an adapter class that converts a TMINLP to a TNLP to be solved by Ipopt |
Bonmin::TMINLP::BranchingInfo | Stores branching priorities information |
Bonmin::TMINLP::MarkedNonConvex | Structure for marked non-convex constraints |
Bonmin::TMINLP::PerturbInfo | Class to store perturbation radii for variables in the model |
Bonmin::TMINLP::SimpleConcaveConstraint | Structure which describes a constraints of the form $f[ y F(x) ] with a concave function |
Bonmin::TMINLP::SosInfo | Class to store sos constraints for model |
Ipopt::TNLP | Base class for all NLP's that use standard triplet matrix form and dense vectors |
Bonmin::TNLP2FPNLP | This is an adapter class to convert an NLP to a Feasibility Pump NLP by changing the objective function to the (2-norm) distance to a point |
Ipopt::TNLPAdapter | This class Adapts the TNLP interface so it looks like an NLP interface |
Bonmin::TNLPSolver | This is a generic class for calling an NLP solver to solve a TNLP |
Bonmin::TNLPSolver::UnsolvedError | We will throw this error when a problem is not solved |
tree | Implementation of live set as a heap |
Ipopt::TripletHelper | |
tripleton_action | We are only going to do this if it does not increase number of elements? |
tripleton_action::action | |
Ipopt::TripletToCSRConverter | Class for converting symmetric matrices given in triplet format to matrices in compressed sparse row (CSR) format of the upper triangual part (or, equivalently, compressed sparse column (CSC) format for the lower triangular part) |
Ipopt::TripletToCSRConverter::TripletEntry | Class for one triplet position entry |
Ipopt::TSymDependencyDetector | Base class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian |
Ipopt::TSymLinearSolver | General driver for linear solvers for sparse indefinite symmetric matrices |
Ipopt::TSymScalingMethod | Base class for the method for computing scaling factors for symmetric matrices in triplet format |
useless_constraint_action | |
useless_constraint_action::action | |
Ipopt::UserScaling | This class does problem scaling by getting scaling parameters from the user (through the NLP interface) |
Ipopt::Vector | Vector Base Class |
Bonmin::vector< T > | A small wrap around std::vector to give easy access to array for interfacing with fortran code |
vector | |
Ipopt::VectorSpace | VectorSpace base class, corresponding to the Vector base class |
Ipopt::WarmStartIterateInitializer | Class implementing an initialization procedure for warm starts |
Ipopt::WsmpSolverInterface | Interface to the linear solver Wsmp, derived from SparseSymLinearSolverInterface |
Ipopt::ZeroMatrix | Class for Matrices with only zero entries |
Ipopt::ZeroMatrixSpace | Class for matrix space for ZeroMatrix |