Bonmin Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Ipopt::AdaptiveMuUpdateNon-monotone mu update
Ipopt::AlgorithmBuilderBuilder to create a complete IpoptAlg object
Ipopt::AlgorithmStrategyObjectThis is the base class for all algorithm strategy objects
ampl_info
Bonmin::AmplInterfaceClass for providing an Osi interface to Ipopt with an ampl nl file as input
Ipopt::AmplOptionsListClass for storing a number of AMPL options that should be registered to the AMPL Solver library interface
Ipopt::AmplOptionsList::AmplOptionAmpl Option class, contains name, type and description for an AMPL option
Ipopt::AmplOptionsList::PrivatInfo
Ipopt::AmplSuffixHandler
Bonmin::AmplTMINLPAmpl MINLP Interface
Ipopt::AmplTNLPAmpl Interface
Array< Type >
ArrayOfMatrices
Ipopt::AugRestoSystemSolverClass that converts the an augmented system with compound restoration pieces into a smaller "pivoted" system to be solved with an existing AugSystemSolver
Bonmin::AuxInfoBonmin class for passing info between components of branch-and-cuts
Bonmin::Bab
Bonmin::BabInfoBonmin class for passing info between components of branch-and-cuts
Bonmin::BabSetupBaseA class to have all elements necessary to setup a branch-and-bound
Bonmin::BabSetupBase::CuttingMethodType for cut generation method with its frequency and string identification
Ipopt::BacktrackingLineSearchGeneral implementation of a backtracking line search
Ipopt::BacktrackingLSAcceptorBase class for backtracking line search acceptors
BB_cutSimple 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::BonCbcFullNodeInfoHolds information for recreating a subproblem by incremental change from the parent for Bonmin
Bonmin::BonCbcPartialNodeInfoHolds information for recreating a subproblem by incremental change from the parent for
Bonmin::BonChooseVariableThis class chooses a variable to branch on
Bonmin::BonChooseVariable::Messages
Bonmin::BonminAmplSetup
Bonmin::BonminSetup
BonRandomChoice
Bonmin::BoundsReaderReads a file containing change bounds for variables
Bonmin::BqpdSolver
Bonmin::BqpdSolver::cachedInfoCached information for reoptimizing
Bonmin::BqpdSolver::UnsolvedBqpdError
Bonmin::BqpdWarmStartWarm start for filter interface
Bonmin::BranchingTQPThis 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
CbcBranchAllDifferentDefine 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
CbcBranchCutDefine a cut branching class
CbcBranchDecisionAbstract branching decision base class
CbcBranchDefaultDecisionBranching decision default class
CbcBranchDynamicDecisionBranching decision dynamic class
CbcBranchingObjectAbstract branching object base class Now just difference with OsiBranchingObject
CbcBranchToFixLotsDefine a branch class that branches so that one way variables are fixed while the other way cuts off that solution
CbcBranchUserDecisionBranching decision user class
CbcCbcParamClass for control parameters that act on a CbcModel object
CbcChooseVariable
CbcCliqueDefine a clique class
CbcCliqueBranchingObjectBranching object for unordered cliques
CbcCompare
CbcCompareBase
CbcCompareDefault
CbcCompareDepth
CbcCompareEstimate
CbcCompareObjective
CbcCompareUser
CbcConsequenceAbstract base class for consequent bounds
CbcCountRowCutOsiRowCut augmented with bookkeeping
CbcCutBranchingObjectCut branching object
CbcCutGeneratorInterface between Cbc and Cut Generation Library
CbcCutModifierAbstract cut modifier base class
CbcCutSubsetModifierSimple cut modifier base class
Bonmin::CbcDfsDiverA more elaborate diving class
Bonmin::CbcDiverClass to do diving in the tree
CbcDummyBranchingObjectDummy branching object
CbcDynamicPseudoCostBranchingObjectSimple branching object for an integer variable with pseudo costs
CbcEventHandlerBase class for Cbc event handling
CbcFathomFathom base class
CbcFathomDynamicProgrammingFathomDynamicProgramming class
CbcFeasibilityBase
CbcFixingBranchingObjectGeneral Branching Object class
CbcFixVariableClass for consequent bounds
CbcFollowOnDefine a follow on class
CbcFollowOn2Define a follow on class
CbcFullNodeInfoHolds complete information for recreating a subproblem
CbcGenCtlBlk
CbcGenCtlBlk::babState_structState of branch-and-cut
CbcGenCtlBlk::cbcParamsInfo_structStart and end of CbcModel parameters in parameter vector
CbcGenCtlBlk::chooseStrongCtl_structControl variables for a strong branching method
CbcGenCtlBlk::cliqueCtl_structControl variable and prototype for clique cut generator
CbcGenCtlBlk::combineCtl_structControl variable and prototype for combine heuristic
CbcGenCtlBlk::debugSolInfo_structArray of primal variable values for debugging
CbcGenCtlBlk::djFixCtl_structControl use of reduced cost fixing prior to B&C
CbcGenCtlBlk::flowCtl_structControl variable and prototype for flow cover cut generator
CbcGenCtlBlk::fpumpCtl_structControl variable and prototype for feasibility pump heuristic
CbcGenCtlBlk::genParamsInfo_structStart and end of cbc-generic parameters in parameter vector
CbcGenCtlBlk::gomoryCtl_structControl variable and prototype for Gomory cut generator
CbcGenCtlBlk::greedyCoverCtl_structControl variable and prototype for greedy cover heuristic
CbcGenCtlBlk::greedyEqualityCtl_structControl variable and prototype for greedy equality heuristic
CbcGenCtlBlk::knapsackCtl_structControl variable and prototype for knapsack cover cut generator
CbcGenCtlBlk::localTreeCtl_structControl variables for local tree
CbcGenCtlBlk::mirCtl_structControl variable and prototype for MIR cut generator
CbcGenCtlBlk::oddHoleCtl_structControl variable and prototype for odd hole cut generator
CbcGenCtlBlk::osiParamsInfo_structStart and end of OsiSolverInterface parameters in parameter vector
CbcGenCtlBlk::probingCtl_structControl variable and prototype for probing cut generator
CbcGenCtlBlk::redSplitCtl_structControl variable and prototype for reduce-and-split cut generator
CbcGenCtlBlk::roundingCtl_structControl variable and prototype for simple rounding heuristic
CbcGenCtlBlk::twomirCtl_structControl variable and prototype for Two-MIR cut generator
CbcGenParamClass for cbc-generic control parameters
CbcHeuristicHeuristic base class
CbcHeuristicDiveDive class
CbcHeuristicDiveCoefficientDiveCoefficient class
CbcHeuristicDiveFractionalDiveFractional class
CbcHeuristicDiveGuidedDiveGuided class
CbcHeuristicDiveVectorLengthDiveVectorLength class
CbcHeuristicDynamic3Heuristic - just picks up any good solution
CbcHeuristicFPumpRounding class
CbcHeuristicGreedyCoverGreedy heuristic classes
CbcHeuristicGreedyEquality
CbcHeuristicLocalLocalSearch class
CbcHeuristicNodeA class describing the branching decisions that were made to get to the node where a heuristics was invoked from
CbcHeuristicNodeList
CbcHeuristicPartialPartial solution class If user knows a partial solution this tries to get an integer solution it uses hotstart information
CbcHeuristicRENSLocalSearch class
CbcHeuristicRINSLocalSearch class
CbcIntegerBranchingObjectSimple branching object for an integer variable
CbcIntegerPseudoCostBranchingObjectSimple branching object for an integer variable with pseudo costs
CbcLinkDefine Special Linked Ordered Sets
CbcLinkBranchingObjectBranching object for Special ordered sets
CbcLongCliqueBranchingObjectUnordered Clique Branching Object class
CbcLotsizeLotsize class
CbcLotsizeBranchingObjectLotsize branching object
CbcMessage
CbcModelSimple Branch and bound class
CbcNewTree
Bonmin::CbcNlpStrategy
CbcNodeInformation required while the node is live
CbcNodeInfoInformation required to recreate the subproblem at this node
CbcNWayDefine an n-way class for variables
CbcNWayBranchingObjectN way branching Object class
Bonmin::CbcOaStrategyA class to pass on a CbcStrategy to OA sub-milp solver
CbcObject
CbcObjectUpdateData
CbcOrClpParamVery simple class for setting parameters
CbcOsiParamClass for control parameters that act on a OsiSolverInterface object
CbcOsiSolverThis is for codes where solver needs to know about CbcModel
CbcParamVery simple class for setting parameters
CbcPartialNodeInfoHolds information for recreating a subproblem by incremental change from the parent
Bonmin::CbcProbedDiverClass to do probed diving in the tree
CbcRoundingRounding class
CbcSerendipityHeuristic - just picks up any good solution found by solver - see OsiBabSolver
CbcSimpleIntegerDefine a single integer class
CbcSimpleIntegerDynamicPseudoCostDefine a single integer class but with dynamic pseudo costs
CbcSimpleIntegerFixedDefine a single integer class where branching is forced until fixed
CbcSimpleIntegerPseudoCostDefine a single integer class but with pseudo costs
CbcSolverThis 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
CbcSolver2This is to allow the user to replace initialSolve and resolve
CbcSolver3This is to allow the user to replace initialSolve and resolve
CbcSolverLongThinThis is to allow the user to replace initialSolve and resolve
CbcSolverUsefulDataStructure to hold useful arrays
CbcSOSDefine Special Ordered Sets of type 1 and 2
CbcSOSBranchingObjectBranching object for Special ordered sets
CbcStatisticsFor gathering statistics
CbcStopNowThis allows the use of a call back class to decide whether to stop
CbcStrategyStrategy base class
CbcStrategyDefaultDefault class
CbcStrategyDefaultSubTreeDefault class for sub trees
CbcStrategyNullNull class
CbcStrongInfoAbstract base class for `objects'
CbcTree
CbcTreeLocal
CbcUserThis allows the use of an unknown user stuff including modeling languages
CglAllDifferentAllDifferent Cut Generator Class This has a number of sets
CglClique
CglClique::fnodeA node of the fractional graph
CglClique::frac_graphA graph corresponding to a fractional solution of an LP
CglCutGeneratorCut Generator Base Class
CglDuplicateRowDuplicateRow Cut Generator Class
CglFakeCliqueThis works on a fake solver i.e. invented rows
CglFlowCoverLifed Simple Generalized Flow Cover Cut Generator Class
CglFlowVUBVaribale upper bound class
CglGomoryGomory Cut Generator Class
CglKnapsackCoverKnapsack Cover Cut Generator Class
CglLandP
CglLandP::CachedDataSome informations that will be changed by the pivots and that we want to keep
CglLandP::NoBasisError
CglLandP::ParametersClass storing parameters
CglLandP::SimplexInterfaceError
LAP::CglLandPSimplex
LAP::CglLandPSimplex::extraInfo
LAP::CglLandPSimplex::TabRow
CglLiftAndProjectLift And Project Cut Generator Class
CglMessageThis deals with Cgl messages (as against Osi messages etc)
CglMixedIntegerRoundingMixed Integer Rounding Cut Generator Class
CglMixedIntegerRounding2Mixed Integer Rounding Cut Generator Class
CglMixIntRoundVUB
CglMixIntRoundVUB2
CglOddHoleOdd Hole Cut Generator Class
CglParamClass collecting parameters for all cut generators
CglPreProcessClass for preProcessing and postProcessing
CglProbingProbing Cut Generator Class
CglProbing::cliqueEntryEntries for clique
CglProbing::cliqueTypeClique type
CglProbing::disaggregation_struct_tagDisaggregation cuts and for building cliques
CglProbing::disaggregationActionOnly useful type of disaggregation is most normal For now just done for 0-1 variables Can be used for building cliques
CglRedSplitGomory Reduce-and-Split Cut Generator Class; See method generateCuts()
CglRedSplitParamClass collecting parameters the Reduced-and-split cut generator
CglResidualCapacityResidual Capacity Inequalities Cut Generator Class
CglSimpleRoundingSimple Rounding Cut Generator Class
CglStoredStored Cut Generator Class
CglTemporaryStored Temporary Cut Generator Class - destroyed after first use
CglTreeInfoInformation about where the cut generator is invoked from
CglTreeProbingInfo
CglTwomirTwostep MIR Cut Generator Class
CglValidatorClass to validate or reject a cut
Ipopt::CGPenaltyCqClass for all Chen-Goldfarb penalty method specific calculated quantities
Ipopt::CGPenaltyDataClass to organize all the additional data required by the Chen-Goldfarb penalty function algorithm
Ipopt::CGPenaltyLSAcceptorLine search acceptor, based on the Chen-Goldfarb penalty function approach
Ipopt::CGPerturbationHandlerClass for handling the perturbation factors delta_x, delta_s, delta_c, and delta_d in the primal dual system
Ipopt::CGSearchDirCalculatorImplementation of the search direction calculator that computes the Chen-Goldfarb step for the current barrier and penalty parameter
ClpAmplObjectiveAmpl Objective Class
ClpCholeskyBaseBase class for Clp Cholesky factorization Will do better factorization
ClpCholeskyDenseDense class for Clp Cholesky factorization
ClpCholeskyTaucsTaucs class for Clp Cholesky factorization
ClpCholeskyUflUfl class for Clp Cholesky factorization
ClpCholeskyWssmpWssmp class for Clp Cholesky factorization
ClpCholeskyWssmpKKTWssmpKKT class for Clp Cholesky factorization
ClpConstraintConstraint Abstract Base Class
ClpConstraintAmplAmpl Constraint Class
ClpConstraintLinearLinear Constraint Class
ClpConstraintQuadraticQuadratic Constraint Class
ClpDataSaveThis is a tiny class where data can be saved round calls
ClpDisasterHandlerBase class for Clp disaster handling
ClpDualRowDantzigDual Row Pivot Dantzig Algorithm Class
ClpDualRowPivotDual Row Pivot Abstract Base Class
ClpDualRowSteepestDual Row Pivot Steepest Edge Algorithm Class
ClpDummyMatrixThis implements a dummy matrix as derived from ClpMatrixBase
ClpDynamicExampleMatrixThis implements a dynamic matrix when we have a limit on the number of "interesting rows"
ClpDynamicMatrixThis implements a dynamic matrix when we have a limit on the number of "interesting rows"
ClpEventHandlerBase class for Clp event handling
ClpFactorizationThis just implements CoinFactorization when an ClpMatrixBase object is passed
ClpGubDynamicMatrixThis implements Gub rows plus a ClpPackedMatrix
ClpGubMatrixThis implements Gub rows plus a ClpPackedMatrix
ClpInteriorThis solves LPs using interior point methods
ClpLinearObjectiveLinear Objective Class
ClpLsqrThis class implements LSQR
ClpMatrixBaseAbstract base class for Clp Matrices
ClpMessageThis deals with Clp messages (as against Osi messages etc)
ClpModel
ClpNetworkBasisThis deals with Factorization and Updates for network structures
ClpNetworkMatrixThis implements a simple network matrix as derived from ClpMatrixBase
ClpNode
ClpNode::branchState
ClpNodeStuff
ClpNonLinearCost
ClpObjectiveObjective Abstract Base Class
ClpPackedMatrix
ClpPackedMatrix2
ClpPackedMatrix3
ClpPdcoThis solves problems in Primal Dual Convex Optimization
ClpPdcoBaseAbstract base class for tailoring everything for Pcdo
ClpPlusMinusOneMatrixThis implements a simple +- one matrix as derived from ClpMatrixBase
ClpPredictorCorrectorThis solves LPs using the predictor-corrector method due to Mehrotra
ClpPresolveThis is the Clp interface to CoinPresolve
ClpPrimalColumnDantzigPrimal Column Pivot Dantzig Algorithm Class
ClpPrimalColumnPivotPrimal Column Pivot Abstract Base Class
ClpPrimalColumnSteepestPrimal Column Pivot Steepest Edge Algorithm Class
ClpPrimalQuadraticDantzigPrimal Column Pivot Dantzig Algorithm Class
ClpQuadInterfaceThis is to allow the user to replace initialSolve and resolve
ClpQuadraticObjectiveQuadratic Objective Class
ClpSimplexThis solves LPs using the simplex method
ClpSimplexDualThis solves LPs using the dual simplex method
ClpSimplexNonlinearThis solves non-linear LPs using the primal simplex method
ClpSimplexOtherThis is for Simplex stuff which is neither dual nor primal
ClpSimplexPrimalThis solves LPs using the primal simplex method
ClpSimplexProgressFor saving extra information to see if looping
ClpSolveThis is a very simple class to guide algorithms
CoinAbsFltEqEquality to an absolute tolerance
CoinArrayWithLengthPointer with length in bytes
CoinBigIndexArrayWithLengthCoinBigIndex * version
CoinBuildIn many cases it is natural to build a model by adding one row at a time
CoinDenseFactorizationThis deals with Factorization and Updates This is a simple dense version so other people can write a better one
CoinDenseVector< T >Dense Vector
CoinDoubleArrayWithLengthDouble * version
CoinErrorError 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
CoinFactorizationThis deals with Factorization and Updates
CoinFileInputAbstract base class for file input classes
CoinFileIOBaseBase class for FileIO classes
CoinFileOutputAbstract 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
CoinIndexedVectorIndexed Vector
CoinIntArrayWithLengthInt * version
CoinLpIOClass to read and write Lp files
CoinLpIO::CoinHashLink
CoinMessageThe standard set of Coin messages
CoinMessageHandlerBase class for message handling
CoinMessagesClass to hold and manipulate an array of massaged messages
CoinModelThis 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
CoinModelHash2For int,int hashing
CoinModelHashLinkFor names and hashing
CoinModelLinkFor going through row or column
CoinModelLinkedList
CoinModelTripleFor linked lists
CoinMpsCardReaderVery simple code for reading MPS data
CoinMpsIOMPS IO Interface
CoinMpsIO::CoinHashLink
CoinOneMessageClass for one massaged message
CoinPackedMatrixSparse Matrix Base Class
CoinPackedVectorSparse Vector
CoinPackedVectorBaseAbstract base class for various sparse vectors
CoinPair< S, T >An ordered pair
CoinParamA base class for `keyword value' command line parameters
CoinPostsolveMatrixAugments CoinPrePostsolveMatrix with information about the problem that is only needed during postsolve
CoinPrePostsolveMatrixCollects all the information about the problem that is needed in both presolve and postsolve
CoinPresolveActionAbstract base class of all presolve routines
CoinPresolveMatrixAugments CoinPrePostsolveMatrix with information about the problem that is only needed during presolve
CoinRelFltEqEquality to a scaled tolerance
CoinSearchTree< Comp >
CoinSearchTreeBase
CoinSearchTreeCompareBestBest first search
CoinSearchTreeCompareBreadth
CoinSearchTreeCompareDepthDepth First Search
CoinSearchTreeComparePreferredDepth First Search
CoinSearchTreeManager
CoinSetVery simple class for containing data on set
CoinShallowPackedVectorShallow Sparse Vector
CoinSnapshotNON Abstract Base Class for interfacing with cut generators or branching code or
CoinSnapshot::coinOwnedTo say whether arrays etc are owned by CoinSnapshot
CoinSosSetVery simple class for containing SOS set
CoinThreadRandomClass for thread specific random numbers
CoinTimerThis class implements a timer that also implements a tracing functionality
CoinTreeNodeA class from which the real tree nodes should be derived from
CoinTreeSiblings
CoinTriple< S, T, U >
CoinUnsignedIntArrayWithLengthUnsigned int * version
CoinWarmStartAbstract base class for warm start information
CoinWarmStartBasisThe default COIN simplex (basis-oriented) warm start class
CoinWarmStartBasisDiffA `diff' between two CoinWarmStartBasis objects
CoinWarmStartDiffAbstract base class for warm start `diff' objects
CoinWarmStartDualWarmStart information that is only a dual vector
CoinWarmStartDualDiffA `diff' between two CoinWarmStartDual objects
CoinWarmStartPrimalDualWarmStart information that is only a dual vector
CoinWarmStartPrimalDualDiffA `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::CompositeNLPThis class creates a composite NLP from a list of NLP's
Ipopt::CompoundMatrixClass for Matrices consisting of other matrices
Ipopt::CompoundMatrixSpaceThis is the matrix space for CompoundMatrix
Ipopt::CompoundSymMatrixClass for symmetric matrices consisting of other matrices
Ipopt::CompoundSymMatrixSpaceThis is the matrix space for CompoundSymMatrix
Ipopt::CompoundVectorClass of Vectors consisting of other vectors
Ipopt::CompoundVectorSpaceThis vectors space is the vector space for CompoundVector
Ipopt::ConvergenceCheckBase class for checking the algorithm termination criteria
Bonmin::CouenneInfoBonmin class for passing info between components of branch-and-cuts
Bonmin::CouenneInfo::NlpSolutionClass for storing an Nlp Solution
Bonmin::CouenneInterface
Bonmin::CouenneSetup
Bonmin::CurvatureEstimator
Bonmin::CurvBranchingSolverImplementation of BonChooseVariable for curvature-based braching
cutParams
Bonmin::CutStrengthenerClass for strengthening OA cuts, and generating additional ones
Bonmin::CutStrengthener::StrengtheningTNLPClass implementing the TNLP for strengthening one cut
Ipopt::DefaultIterateInitializerClass implementing the default initialization procedure (based on user options) for the iterates
Ipopt::DenseGenMatrixClass for dense general matrices
Ipopt::DenseGenMatrixSpaceThis is the matrix space for DenseGenMatrix
Ipopt::DenseSymMatrixClass for dense symetrix matrices
Ipopt::DenseSymMatrixSpaceThis is the matrix space for DenseSymMatrix
Ipopt::DenseVectorDense Vector Implementation
Ipopt::DenseVectorSpaceThis 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::DiagMatrixClass for diagonal matrices
Ipopt::DiagMatrixSpaceThis is the matrix space for DiagMatrix
Bonmin::DiverCompare
do_tighten_action
do_tighten_action::action
doubleton_actionSolve ax+by=c for y and substitute y out of the problem
doubleton_action::action
drop_empty_cols_actionPhysically removes empty columns in presolve, and reinserts empty columns in postsolve
drop_empty_cols_action::action
drop_empty_rows_actionPhysically removes empty rows in presolve, and reinserts empty rows in postsolve
drop_empty_rows_action::action
drop_zero_coefficients_actionRemoval of explicit zeros
dropped_zeroTracking information for an explicit zero coefficient
Bonmin::DummyHeuristic
dupcol_actionDetect and remove duplicate columns
dupcol_action::action
duprow_actionDetect and remove duplicate rows
duprow_action::action
Bonmin::EcpCuts
Ipopt::EqMultiplierCalculatorBase Class for objects that compute estimates for the equality constraint multipliers y_c and y_d
Ipopt::EquilibrationScalingThis class does problem scaling by setting the scaling parameters based on the maximum of the gradient at the user provided initial point
Ipopt::ExactHessianUpdaterImplementation of the HessianUpdater for the use of exact second derivatives
Ipopt::ExpansionMatrixClass for expansion/projection matrices
Ipopt::ExpansionMatrixSpaceThis is the matrix space for ExpansionMatrix
Ipopt::FileJournalFileJournal class
Ipopt::FilterClass for the filter
Ipopt::FilterEntryClass for one filter entry
Ipopt::FilterLSAcceptorFilter line search
Bonmin::FilterSolver
Bonmin::FilterSolver::cachedInfoCached information for reoptimizing
Bonmin::FilterSolver::UnsolvedFilterError
Bonmin::FilterWarmStartWarm start for filter interface
Bonmin::FilterWarmStartDiff
fixEntryDerived class to pick up probing info
forcing_constraint_actionDetect and process forcing constraints and useless constraints
forcing_constraint_action::action
Ipopt::GenAugSystemSolverSolver for the augmented system using GenKKTSolverInterfaces
Ipopt::GenKKTSolverInterfaceBase class for interfaces to symmetric indefinite linear solvers for generic matrices
Ipopt::GenTMatrixClass for general matrices stored in triplet format
Ipopt::GenTMatrixSpaceThis is the matrix space for a GenTMatrix with fixed sparsity structure
Ipopt::GradientScalingThis 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::HessianUpdaterAbstract base class for objects responsible for updating the Hessian information
Bonmin::HotInfo
HS071_NLPC++ Example NLP for interfacing a problem with IPOPT
Ipopt::IdentityMatrixClass for Matrices which are multiples of the identity matrix
Ipopt::IdentityMatrixSpaceThis is the matrix space for IdentityMatrix
IdiotThis class implements a very silly algorithm
IdiotResultFor use internally
implied_free_actionDetect and process implied free variables
implied_free_action::action
Info******** DATA to be moved into protected section of ClpInterior
Bonmin::InitHeuristicA heuristic that stores the initial solution of the NLP
Ipopt::IpoptAlgorithmThe main ipopt algorithm class
Ipopt::IpoptApplicationThis is the main application class for making calls to Ipopt
Ipopt::IpoptCalculatedQuantitiesClass for all IPOPT specific calculated quantities
Ipopt::IpoptDataClass to organize all the data required by the algorithm
Ipopt::IpoptExceptionThis is the base class for all exceptions
Bonmin::IpoptInteriorWarmStarter
Ipopt::IpoptNLPThis 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::IpoptWarmStartClass for storing warm start informations for Ipopt
Bonmin::IpoptWarmStartDiffDiff class for IpoptWarmStart
isolated_constraint_action
Ipopt::IterateInitializerBase class for all methods for initializing the iterates
Ipopt::IteratesVectorSpecialized CompoundVector class specifically for the algorithm iterates
Ipopt::IteratesVectorSpaceVector Space for the IteratesVector class
Ipopt::IterationOutputBase class for objects that do the output summary per iteration
Ipopt::JournalJournal class (part of the Journalist implementation
Ipopt::JournalistClass responsible for all message output
LAP::LandPMessagesMessage handler for lift-and-project simplex
LAP::LapMessagesOutput messages for Cgl
Ipopt::LeastSquareMultipliersClass for calculator for the least-square equality constraint multipliers
Ipopt::LimMemQuasiNewtonUpdaterImplementation of the HessianUpdater for limit-memory quasi-Newton approximation of the Lagrangian Hessian
Ipopt::LineSearchBase class for line search objects
Ipopt::LoqoMuOracleImplementation of the LOQO formula for computing the barrier parameter
Ipopt::LowRankAugSystemSolverSolver for the augmented system with LowRankUpdateSymMatrix Hessian matrices
Ipopt::LowRankUpdateSymMatrixClass for symmetric matrices, represented as low-rank updates
Ipopt::LowRankUpdateSymMatrixSpaceThis is the matrix space for LowRankUpdateSymMatrix
Bonmin::LpBranchingSolverImplementation of BonChooseVariable for curvature-based braching
LuksanVlcek1Implementation of Example 5.1 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L
LuksanVlcek2Implementation of Example 5.2 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L
LuksanVlcek3Implementation of Example 5.3 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L
LuksanVlcek4Implementation of Example 5.4 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L
LuksanVlcek5Implementation of Example 5.5 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L
LuksanVlcek6Implementation of Example 5.6 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L
LuksanVlcek7Implementation of Example 5.7 from "Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization" by L
Ipopt::Ma27TSolverInterfaceInterface to the symmetric linear solver MA27, derived from SparseSymLinearSolverInterface
Ipopt::Ma28TDependencyDetectorBase class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian
Ipopt::Ma57TSolverInterfaceInterface to the symmetric linear solver MA57, derived from SparseSymLinearSolverInterface
make_fixed_actionFix a variable at a specified bound
make_fixed_action::actionStructure to preserve the bound overwritten when fixing a variable
MatlabException
MatlabFunctionHandle
Ipopt::MatlabJournal
MatlabOption
MatlabProgram
MatlabScalar
MatlabString
Ipopt::MatrixMatrix Base Class
Matrix
Ipopt::MatrixSpaceMatrixSpace base class, corresponding to the Matrix base class
Ipopt::Mc19TSymScalingMethodClass for the method for computing scaling factors for symmetric matrices in triplet format, using MC19
Ipopt::MinC_1NrmRestorationPhaseRestoration Phase that minimizes the 1-norm of the constraint violation - using the interior point method (Ipopt)
Bonmin::MinlpFeasPump
MittelmannBndryCntrlDiri1Class implementating Example 1
MittelmannBndryCntrlDiri2Class implementating Example 2
MittelmannBndryCntrlDiri3Class implementating Example 3
MittelmannBndryCntrlDiri3DClass implementating Example 1
MittelmannBndryCntrlDiri3D_27Class implementating case with convex quadratic penalty function
MittelmannBndryCntrlDiri3D_27BTClass implementating case with nonconvex Beaton-Tukey like penalty function
MittelmannBndryCntrlDiri3DsinClass implementating Example 1
MittelmannBndryCntrlDiri4Class implementating Example 4
MittelmannBndryCntrlDiriBaseBase 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
MittelmannBndryCntrlDiriBase3DBase 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_27Base 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
MittelmannBndryCntrlDiriBase3DsinBase 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
MittelmannBndryCntrlNeum1Class implementating Example 5
MittelmannBndryCntrlNeum2Class implementating Example 6
MittelmannBndryCntrlNeum3Class implementating Example 7
MittelmannBndryCntrlNeum4Class implementating Example 8
MittelmannBndryCntrlNeumBaseBase 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
MittelmannDistCntrlDiri1Class implementating Example 1
MittelmannDistCntrlDiri2Class implementating Example 2
MittelmannDistCntrlDiri3Class implementating Example 3
MittelmannDistCntrlDiri3a
MittelmannDistCntrlDiriBaseBase 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
MittelmannDistCntrlNeumA1Class implementating Example 4
MittelmannDistCntrlNeumA2Class implementating Example 5
MittelmannDistCntrlNeumA3Class implementating Example 6
MittelmannDistCntrlNeumABaseBase 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
MittelmannDistCntrlNeumB1Class implementating Example 4
MittelmannDistCntrlNeumB2Class implementating Example 5
MittelmannDistCntrlNeumB3Class implementating Example 6
MittelmannDistCntrlNeumBBaseBase 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::MonotoneMuUpdateMonotone Mu Update
Multipliers
Ipopt::MultiVectorMatrixClass for Matrices with few columns that consists of Vectors
Ipopt::MultiVectorMatrixSpaceThis is the matrix space for MultiVectorMatrix
Ipopt::MumpsSolverInterfaceInterface to the linear solver Mumps, derived from SparseSymLinearSolverInterface
Ipopt::MuOracleAbstract 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::MuUpdateAbstract Base Class for classes that implement methods for computing the barrier and fraction-to-the-boundary rule parameter for the current iteration
MyEventHandlerThis is so user can trap events and do useful stuff
MyMessageHandler
MyNLPC++ Example NLP for interfacing a problem with IPOPT
myPdcoThis implements a simple network matrix as derived from ClpMatrixBase
MyTMINLPA C++ example for interfacing an MINLP with bonmin
Bonmin::NamesReaderA class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file)
Bonmin::NamesReader::ltstrString comparison strucutre
Ipopt::NLPBrief Class Description
Ipopt::NLPScalingObjectThis is the abstract base class for problem scaling
Bonmin::NlpSolveHeuristic
Ipopt::NoNLPScalingObjectClass implementing the scaling object that doesn't to any scaling
Bonmin::OACutGenerator2Class to perform OA in its classical form
Bonmin::OaDecompositionBaseBase class for OA algorithms
Bonmin::OaDecompositionBase::ParametersParameters for algorithm
Bonmin::OaDecompositionBase::solverManipSmall class to manipulatee various things in an OsiSolverInterface and restore them
Bonmin::OaDecompositionBase::SubMipSolverSmall class to perform the solution of sub-mips
Bonmin::OaFeasibilityCheckerClass to perform OA in its classical form
Bonmin::OaMessagesOutput messages for Outer approximation cutting planes
Bonmin::OaNlpOptimGenerate cuts for the nlp corresponding to continuous relaxation at a node
Ipopt::ObserverSlight Variation of the Observer Design Pattern
Ipopt::OptimalityErrorConvergenceCheckBrief Class Description
Options******** DATA to be moved into protected section of ClpInterior
Ipopt::OptionsListThis class stores a list of user set options
Ipopt::OptionsList::OptionValueClass for storing the value and counter for each option in OptionsList
OptParam
Ipopt::OrigIpoptNLPThis class maps the traditional NLP into something that is more useful by Ipopt
Ipopt::OrigIterationOutputClass for the iteration summary output for the original NLP
OsiAuxInfoThis class allows for a more structured use of algorithmic tweaking to an OsiSolverInterface
OsiBabSolverThis class allows for the use of more exotic solvers e.g
OsiBiLinearDefine BiLinear objects
OsiBiLinearBranchingObjectBranching object for BiLinear objects
OsiBiLinearEqualityDefine Continuous BiLinear objects for an == bound
OsiBranchingInformation
OsiBranchingObjectAbstract branching object base class
OsiCbcSolverInterfaceCbc Solver Interface
OsiChooseStrongThis class chooses a variable to branch on
OsiChooseStrongSubsetThis class chooses a variable to branch on
OsiChooseVariableThis class chooses a variable to branch on
OsiClpDisasterHandler
OsiClpSolverInterfaceClp Solver Interface
OsiColCutColumn Cut Class
OsiCpxSolverInterfaceCPLEX Solver Interface
OsiCut
OsiCutsCollections of row cuts and column cuts
OsiCuts::const_iteratorConst Iterator
OsiCuts::iteratorIterator
OsiCuts::OsiCutCompare
OsiDylpSolverInterfaceCOIN OSI layer for dylp
OsiDylpWarmStartBasisThe dylp warm start class
OsiDylpWarmStartBasisDiffA `diff' between two OsiDylpWarmStartBasis objects
OsiFmpSolverInterfaceOSL Solver Interface
OsiGlpkSolverInterfaceGPLK Solver Interface
OsiHotInfoThis class contains the result of strong branching on a variable When created it stores enough information for strong branching
OsiIntegerBranchingObjectSimple branching object for an integer variable
OsiLinkDefine Special Linked Ordered Sets
OsiLinkBranchingObjectBranching object for Linked ordered sets
OsiLinkedBoundList of bounds which depend on other bounds
OsiLinkedBound::boundElementAction
OsiLotsizeLotsize class
OsiLotsizeBranchingObjectLotsize branching object
OsiMskSolverInterface
OsiObjectAbstract base class for `objects'
OsiObject2Define a class to add a bit of complexity to OsiObject This assumes 2 way branching
OsiOldLink
OsiOldLinkBranchingObjectBranching object for Linked ordered sets
OsiOneLinkDefine data for one link
OsiOslSolverInterfaceOSL Solver Interface
OsiPresolveOSI interface to COIN problem simplification capabilities
OsiPseudoCostsThis class is the placeholder for the pseudocosts used by OsiChooseStrong
OsiRowCutRow Cut Class
OsiRowCut2Row Cut Class which refers back to row which created it
OsiRowCutDebuggerValidate Row Cut Generator
OsiSimpleFixedIntegerDefine a single integer class - but one where you keep branching until fixed even if satisfied
OsiSimpleIntegerDefine a single integer class
OsiSolverBranchSolver Branch Class
OsiSolverInterfaceSolver Interface Abstract Base Class
OsiSolverInterface::ApplyCutsReturnCodeInternal class for obtaining status from the applyCuts method
OsiSolverLinearizedQuadraticThis is to allow the user to replace initialSolve and resolve
OsiSolverLinkThis is to allow the user to replace initialSolve and resolve This version changes coefficients
OsiSolverResultSolver Result Class
OsiSOSDefine Special Ordered Sets of type 1 and 2
OsiSOSBranchingObjectBranching object for Special ordered sets
OsiSpxSolverInterfaceSOPLEX Solver Interface
OsiSymSolverInterfaceOSI Solver Interface for SYMPHONY
Bonmin::OsiTMINLPInterfaceThis 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::MessagesMessages outputed by an OsiTMINLPInterface
Bonmin::OsiTMINLPInterface::OaMessageHandlerLike a CoinMessageHandler but can print a cut also
Bonmin::OsiTMINLPInterface::OaMessagesClass to store OA Messages
Bonmin::OsiTMINLPInterface::SimpleErrorError class to throw exceptions from OsiTMINLPInterface
OsiTwoWayBranchingObjectThis just adds two-wayness to a branching object
OsiUsesBiLinearDefine a single variable class which is involved with OsiBiLinear objects
OsiVolSolverInterfaceVol(ume) Solver Interface
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_
OsiXprSolverInterfaceXPRESS-MP Solver Interface
Outfo******** DATA to be moved into protected section of ClpInterior
Ipopt::PardisoSolverInterfaceInterface to the linear solver Pardiso, derived from SparseSymLinearSolverInterface
Ipopt::PDFullSpaceSolverThis is the implemetation of the Primal-Dual System, using the full space approach with a direct linear solver
Ipopt::PDPerturbationHandlerClass for handling the perturbation factors delta_x, delta_s, delta_c, and delta_d in the primal dual system
Ipopt::PDSearchDirCalculatorImplementation of the search direction calculator that computes the pure primal dual step for the current barrier parameter
Ipopt::PDSystemSolverPure Primal Dual System Solver Base Class
Ipopt::PenaltyLSAcceptorFilter line search
Ipopt::PiecewisePenaltyClass for the Piecewise Penalty
Ipopt::PiecewisePenEntryStruct for one Piecewise Penalty entry
Ipopt::PointPerturberThis class is a simple object for generating randomly perturbed points that are withing the NLP bounds
presolvehlinkLinks to aid in packed matrix modification
Ipopt::ProbingMuOracleImplementation of the probing strategy for computing the barrier parameter
Bonmin::PseudoCosts
Bonmin::QpBranchingSolverThis class chooses a variable to branch on
Ipopt::QualityFunctionMuOracleImplementation of the probing strategy for computing the barrier parameter
Ipopt::ReferencedObjectReferencedObject class
Coin::ReferencedObjectReferencedObject class
Ipopt::ReferencerPsydo-class, from which everything has to inherit that wants to use be registered as a Referencer for a ReferencedObject
Ipopt::RegisteredOptionBase class for registered options
Ipopt::RegisteredOption::string_entryClass to hold the valid string settings for a string option
Ipopt::RegisteredOptionsClass for storing registered options
Bonmin::RegisteredOptionsClass to add a few more information to Ipopt::RegisteredOptions
RegisteredTNLPClass implemented the NLP discretization of
RegisteredTNLPs
remove_dual_actionAttempt to fix variables by bounding reduced costs
remove_fixed_actionExcise fixed variables from the model
remove_fixed_action::actionStructure to hold information necessary to reintroduce a column into the problem representation
Ipopt::RestoFilterConvergenceCheckConvergence check for the restoration phase as called by the filter
Ipopt::RestoIpoptNLPThis class maps the traditional NLP into something that is more useful by Ipopt
Ipopt::RestoIterateInitializerClass implementing the default initialization procedure (based on user options) for the iterates
Ipopt::RestoIterationOutputClass for the iteration summary output for the restoration phase
Ipopt::RestorationPhaseBase class for different restoration phases
Ipopt::RestoRestorationPhaseRecursive Restoration Phase for the.MinC_1NrmRestorationPhase
Ipopt::ScaledMatrixClass for a Matrix in conjunction with its scaling factors for row and column scaling
Ipopt::ScaledMatrixSpaceThis is the matrix space for ScaledMatrix
Ipopt::SearchDirectionCalculatorBase class for computing the search direction for the line search
Bonmin::SimpleReferenced< X >
Bonmin::SimpleReferencedPtr< X >
slack_doubleton_actionConvert an explicit bound constraint to a column bound
slack_doubleton_action::action
slack_singleton_actionFor 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::SolveStatisticsThis class collects statistics about an optimziation run, such as iteration count, final infeasibilities etc
SparseMatrixStructure
Ipopt::SparseSymLinearSolverInterfaceBase class for interfaces to symmetric indefinite linear solvers for sparse matrices
Ipopt::StandardScalingBaseThis is a base class for many standard scaling techniques
Bonmin::StartPointReaderThis class reads a file with a starting point for Ipopt initalization
Ipopt::StdAugSystemSolverSolver for the augmented system for triple type matrices
Ipopt::StdInterfaceTNLPImplementation of a TNLP for the Standard C interface
Ipopt::StreamJournalStreamJournal class
Bonmin::StrongBranchingSolverThis class is the base class for a solver that can be used in BonOsiSolverInterface to perform the strong branching solves
Ipopt::SubjectSlight Variation of the Observer Design Pattern (Subject part)
subst_constraint_action
subst_constraint_action::action
Ipopt::SumMatrixClass for Matrices which are sum of matrices
Ipopt::SumMatrixSpaceClass for matrix space for SumMatrix
Ipopt::SumSymMatrixClass for Matrices which are sum of symmetric matrices
Ipopt::SumSymMatrixSpaceClass for matrix space for SumSymMatrix
Ipopt::SymLinearSolverBase class for all derived symmetric linear solvers
Ipopt::SymMatrixThis is the base class for all derived symmetric matrix types
Ipopt::SymMatrixSpaceSymMatrixSpace base class, corresponding to the SymMatrix base class
symrecFor string evaluation
Ipopt::SymScaledMatrixClass for a Matrix in conjunction with its scaling factors for row and column scaling
Ipopt::SymScaledMatrixSpaceThis is the matrix space for SymScaledMatrix
Ipopt::SymTMatrixClass for symmetric matrices stored in triplet format
Ipopt::SymTMatrixSpaceThis is the matrix space for a SymTMatrix with fixed sparsity structure
SymWarmStart
Ipopt::TaggedObjectTaggedObject class
Ipopt::TDependencyDetectorBase class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian
Ipopt::TimedTaskThis class is used to collect timing information for a particular task
Ipopt::TimingStatisticsThis class collects all timing statistics for Ipopt
Bonmin::TMINLPBase class for all MINLPs that use a standard triplet matrix form and dense vectors
Bonmin::TMINLP2TNLPThis is an adapter class that converts a TMINLP to a TNLP to be solved by Ipopt
Bonmin::TMINLP::BranchingInfoStores branching priorities information
Bonmin::TMINLP::MarkedNonConvexStructure for marked non-convex constraints
Bonmin::TMINLP::PerturbInfoClass to store perturbation radii for variables in the model
Bonmin::TMINLP::SimpleConcaveConstraintStructure which describes a constraints of the form $f[ y F(x) ] with $ F(x) $ a concave function
Bonmin::TMINLP::SosInfoClass to store sos constraints for model
Ipopt::TNLPBase class for all NLP's that use standard triplet matrix form and dense vectors
Bonmin::TNLP2FPNLPThis 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::TNLPAdapterThis class Adapts the TNLP interface so it looks like an NLP interface
Bonmin::TNLPSolverThis is a generic class for calling an NLP solver to solve a TNLP
Bonmin::TNLPSolver::UnsolvedErrorWe will throw this error when a problem is not solved
treeImplementation of live set as a heap
Ipopt::TripletHelper
tripleton_actionWe are only going to do this if it does not increase number of elements?
tripleton_action::action
Ipopt::TripletToCSRConverterClass 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::TripletEntryClass for one triplet position entry
Ipopt::TSymDependencyDetectorBase class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian
Ipopt::TSymLinearSolverGeneral driver for linear solvers for sparse indefinite symmetric matrices
Ipopt::TSymScalingMethodBase class for the method for computing scaling factors for symmetric matrices in triplet format
useless_constraint_action
useless_constraint_action::action
Ipopt::UserScalingThis class does problem scaling by getting scaling parameters from the user (through the NLP interface)
Ipopt::VectorVector Base Class
Bonmin::vector< T >A small wrap around std::vector to give easy access to array for interfacing with fortran code
vector
Ipopt::VectorSpaceVectorSpace base class, corresponding to the Vector base class
Ipopt::WarmStartIterateInitializerClass implementing an initialization procedure for warm starts
Ipopt::WsmpSolverInterfaceInterface to the linear solver Wsmp, derived from SparseSymLinearSolverInterface
Ipopt::ZeroMatrixClass for Matrices with only zero entries
Ipopt::ZeroMatrixSpaceClass for matrix space for ZeroMatrix

Generated on Thu Jun 26 03:10:39 2008 for Bonmin by  doxygen 1.4.7