Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Bonmin::AmplInterfaceClass for providing an Osi interface to Ipopt with an ampl nl file as input
Bonmin::AmplTMINLPAmpl MINLP Interface
AslCouPair
Bonmin::AuxInfoBonmin class for passing info between components of branch-and-cuts
Couenne::AuxRelationBase class definition for relations between auxiliaries
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
Bonmin::BabSetupBase::HeuristicMethodType for heuristic method with its string identification
Base64Use this class to read and write data in base64
BasisStatusData structure to represent an LP basis on both input and output
BB_cutSimple representation of a cut by storing non zero coefficients only
BB_indexed_cutWhen doing a sprint sort of algorithm on the cuts (i.e., leave out a number of cuts at the beginning and add them only as necessary) this object represents one of these cuts
BB_init
BB_lpClass for operations at the node level
BB_packerClass taking care of packing/unpacking
BB_probClass holding data for describing the problem
BB_tm
BCP_bufferThis class describes the message buffer used for all processes of BCP
BCP_cg_parParameters used in the Cut Generator process
BCP_cg_probThis class is the central class of the Cut Generator process
BCP_cg_userBase class from which the user can derive a problem specific class to be used in the Cut Generator process
BCP_colThis class holds a column in a compressed form
BCP_cutAbstract base class that defines members common to all types of cuts
BCP_cut_algoThis is the class from which the user should derive her own algorithmic cuts
BCP_cut_coreCore cuts are the cuts that always stay in the LP formulation
BCP_cut_setThis class is just a collection of pointers to cuts with a number of methods to manipulate these cuts and/or select certain entries
BCP_fatal_errorCurrently there isn't any error handling in BCP
BCP_internal_brobjThis class is the internal representation of a branching object
BCP_lp_branching_objectThis class describes a generic branching object
BCP_lp_cut_pool
BCP_lp_integer_branching_objectThis class exist only so that we can extract information from OsiIntegerBranchingObject
BCP_lp_nodeNO OLD DOC
BCP_lp_parParameters used in the LP process
BCP_lp_parentNO OLD DOC
BCP_lp_probNO OLD DOC
BCP_lp_relaxAn object of type BCP_lp_relax holds the description of an lp relaxation
BCP_lp_resultThis class holds the results after solving an LP relaxation
BCP_lp_sos_branching_objectThis class exist only so that we can extract information from OsiIntegerBranchingObject
BCP_lp_statisticsNO OLD DOC
BCP_lp_userBase class from which the user can derive a problem specific class to be used in the LP process
BCP_lp_var_pool
BCP_lp_waiting_col
BCP_lp_waiting_row
BCP_MemPool
BCP_message_environmentThis is an abstract base class that describes the message passing environment
BCP_node_change
BCP_node_storage_in_tmNO OLD DOC
BCP_obj_change
BCP_obj_set_changeThis class stores data about how an object set (set of vars or set of cuts) changes
BCP_parameterThis parameter indeintifies a single parameter entry
BCP_parameter_set< Par >This is the class serves as a holder for a set of parameters
BCP_presolved_lp_brobjA presolved branching object candidate
BCP_problem_coreThis class describes the core of the MIP problem, the variables/cuts in it as well as the matrix corresponding the core variables and cuts
BCP_problem_core_changeThis class describes changes in the core of the problem
BCP_process
BCP_rowThis class holds a row in a compressed form
BCP_scheduler
BCP_single_environment
BCP_slave_paramsNO OLD DOC
BCP_solutionThis is the abstract base class for a solution to a Mixed Integer Programming problem
BCP_solution_genericThis class holds a MIP feasible primal solution
BCP_stringThis class is a very simple impelementation of a constant length string
BCP_tm_flagsNO OLD DOC
BCP_tm_node
BCP_tm_node_data
BCP_tm_node_to_send
BCP_tm_parParameters used in the Tree Manager process
BCP_tm_probNO OLD DOC
BCP_tm_stat
BCP_tm_userBase class from which the user can derive a problem specific class to be used in the TM process
BCP_treeNO OLD DOC
BCP_ts_node_dataSame as BCP_tm_node_data, just there's no need to use smart pointers in this process
BCP_ts_par
BCP_ts_prob
BCP_ts_user
BCP_user_class
BCP_user_data
BCP_user_pack
BCP_varAbstract base class that defines members common to all types of variables
BCP_var_algoThis is the class from which the user should derive her own algorithmic variables
BCP_var_coreCore variables are the variables that always stay in the LP formulation
BCP_var_setThis class is just a collection of pointers to variables with a number of methods to manipulate these variables and/or select certain entries
BCP_vec< T >The class BCP_vec serves the same purpose as the vector class in the standard template library
BCP_vec_change< T >This class stores a vector explicitly or relatively to another vector
BCP_vg_par
BCP_vg_probThis class is the central class of the Variable Generator process
BCP_vg_userBase class from which the user can derive a problem specific class to be used in the Cut Generator process
BCP_warmstartWarmstarting information for the LP solver
BCP_warmstart_basisThis class describes a warmstart information that consists of basis information for structural and artificial variables
BCP_warmstart_dualThis class describes a warmstart information that consists solely of the dual vector
BCP_warmstart_primaldualThis class describes a warmstart information that consists solely of the dual vector
Bigint
Couenne::BiProdDivRelIdentifies 5-tuple of the form
BM_BranchData
BM_init
BM_lp
BM_node
BM_pack
BM_par
BM_SB_result
BM_stats
BM_tm
BMSearchTreeCompareBest
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
BonminProblem
Bonmin::BonminSetup
BonminSolverSolves problems using Ipopt
BonRandomChoice
bounds_opt_rlt_values
bounds_opt_values
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
BranchingWeightBranchingWeight class
bs
Bonmin::CbcDfsDiverA more elaborate diving class
Bonmin::CbcDiverClass to do diving in the tree
Bonmin::CbcNlpStrategy
Bonmin::CbcProbedDiverClass to do probed diving in the tree
Bonmin::CbcStrategyChooseCutsA class to setup default strategy for Cbc specifying which cut generators to use
cmpVar
CoinSolverImplements a solve method for the Coin solvers
Couenne::compareSolClass for comparing solutions (used in tabu list)
Couenne::compExprStructure for comparing expressions
Couenne::compNodeStructure for comparing nodes in the dependence graph
compVarStructure for comparing variables
ConstraintThe in-memory representation of the <con> element
ConstraintOptionConstraintOption class
ConstraintsThe in-memory representation of the <constraints> element
ConstraintSolutionThe ConstraintSolution Class
ContactOptionContactOption class
Couenne::CouenneAggrProbingCut Generator for aggressive BT; i.e., an aggressive probing
Couenne::CouenneAmplInterface
Couenne::CouenneBranchingObject"Spatial" branching object
Couenne::CouenneChooseStrong
Couenne::CouenneChooseVariableChoose a variable for branching
Couenne::CouenneComplBranchingObject"Spatial" branching object for complementarity constraints
Couenne::CouenneComplObjectOsiObject for complementarity constraints $ x_1 x_2 \ge,\le,= 0 $
Couenne::CouenneConstraintClass to represent nonlinear constraints
Couenne::CouenneCrossConvCut Generator that uses relationships between auxiliaries
Couenne::CouenneCutGeneratorCut Generator for linear convexifications
Couenne::CouenneDisjCutsCut Generator for linear convexifications
Couenne::CouenneFeasPumpAn implementation of the Feasibility pump that uses linearization and Ipopt to find the two sequences of points
Couenne::CouenneFixPointCut Generator for FBBT fixpoint
Couenne::CouenneFPpoolPool of solutions
Couenne::CouenneFPsolutionClass containing a solution with infeasibility evaluation
Couenne::CouenneInfoBonmin class for passing info between components of branch-and-cuts
Couenne::CouenneInfo::NlpSolutionClass for storing an Nlp Solution
Couenne::CouenneInterface
Couenne::CouenneIterativeRounding
Couenne::CouenneMINLPInterfaceThis 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)
Couenne::CouenneMultiVarProbe
Couenne::CouenneObjectOsiObject for auxiliary variables $w=f(x)$
Couenne::CouenneObjectiveObjective function
Couenne::CouenneOrbitBranchingObj"Spatial" branching object
Couenne::CouenneOSInterface
Couenne::CouenneProblemClass for MINLP problems with symbolic information
Couenne::CouenneRecordBestSol
Couenne::CouenneSetup
CouenneSolverSolves problems using Ipopt
Couenne::CouenneSolverInterface< T >Solver interface class with a pointer to a Couenne cut generator
Couenne::CouenneSOSBranchingObject
Couenne::CouenneSOSObject
Couenne::CouenneSparseBndVec< T >
Couenne::CouenneSparseMatrixClass for sparse Matrixs (used in modifying distances in FP)
Couenne::CouenneThreeWayBranchObjSpatial, three-way branching object
Couenne::CouenneTNLPClass for handling NLPs using CouenneProblem
Couenne::CouenneTwoImpliedCut Generator for implied bounds derived from pairs of linear (in)equalities
Couenne::CouenneUserInterface
Couenne::CouenneVarObjectOsiObject for variables in a MINLP
Couenne::CouenneVTObjectOsiObject for violation transfer on variables in a MINLP
Couenne::CouExpr
CPUNumberCPUNumber class
CPUSpeedCPUSpeed class
Bonmin::CurvatureEstimator
Bonmin::CurvBranchingSolverImplementation of BonChooseVariable for curvature-based braching
CutGen
Bonmin::CutsGeneralizes OsiCuts to handle quadratic cuts
Bonmin::CutStrengthenerClass for strengthening OA cuts, and generating additional ones
Bonmin::CutStrengthener::StrengtheningTNLPClass implementing the TNLP for strengthening one cut
dataset
DefaultSolverThe Default Solver Class
Couenne::DepGraphDependence graph
Couenne::DepNodeVertex of a dependence graph
DirectoriesAndFilesDirectoriesAndFiles class
Bonmin::DiverCompare
Couenne::DomainDefine a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO structure
Couenne::DomainPointDefine a point in the solution space and the bounds around it
DoubleVectorDouble vector data structure
DualVariableValuesThe DualVariableValues Class
DualVarValueThe DualVarValue Class
Bonmin::DummyHeuristic
Bonmin::DummyPump
Bonmin::EcpCuts
ErrorClassUsed for throwing exceptions
Couenne::exprAbsClass for $ |f(x)| $
Couenne::exprAuxAuxiliary variable
Couenne::exprBinProdClass for $ \prod_{i=1}^n f_i(x) $ with $ f_i(x) $ all binary
Couenne::exprCeilClass ceiling, $ \lceil f(x) \rceil $
Couenne::exprCloneExpression clone (points to another expression)
Couenne::exprConstConstant-type operator
Couenne::exprCopy
Couenne::exprCosClass cosine, $ \cos f(x) $
Couenne::exprDivClass for divisions, $ \frac{f(x)}{g(x)} $
Couenne::expressionExpression base class
Couenne::exprExpClass for the exponential, $ e^{f(x)} $
Couenne::exprFloorClass floor, $ \lfloor f(x) \rfloor $
Couenne::exprGroupClass Group, with constant, linear and nonlinear terms: $ a_0 + \sum_{i=1}^n a_i x_i $
Couenne::ExprHessExpression matrices
Couenne::exprIf
Couenne::exprInvClass inverse: $ 1/f(x) $
Couenne::exprIVarVariable-type operator
Couenne::ExprJacJacobian of the problem (computed through Couenne expression classes)
Couenne::exprLBCosClass to compute lower bound of a cosine based on the bounds of its arguments
Couenne::exprLBDivClass to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprLBMulClass to compute lower bound of a product based on the bounds of both factors
Couenne::exprLBQuadClass to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprLBSinClass to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprLogClass logarithm, $ \log f(x)$
Couenne::exprLowerBoundLower bound
Couenne::exprMaxClass for maxima
Couenne::exprMinClass for minima
Couenne::exprMultiLinAnother class for multiplications, $ \prod_{i=1}^n f_i(x) $
Couenne::exprNormClass for $ p $-norms, $ || f(x)||_p = \left(\sum_{i=1}^n f_i(x)^p\right)^{\frac{1}{p}} $
Couenne::exprOddPowPower of an expression (binary operator), $ f(x)^k$ with $ k$ constant
Couenne::exprOpGeneral n-ary operator-type expression: requires argument list
Couenne::exprOppClass opposite, $ -f(x) $
Couenne::exprPowPower of an expression (binary operator), $ f(x)^k$ with $ k$ constant
Couenne::exprPWLinear
Couenne::exprQuadClass exprQuad, with constant, linear and quadratic terms
Couenne::exprSinClass for $ \sin f(x)$
Couenne::exprStoreStorage class for previously evaluated expressions
Couenne::exprSubClass for subtraction, $ f(x) - g(x) $
Couenne::exprSumClass sum, $ \sum_{i=1}^n f_i(x) $
Couenne::exprTrilinearClass for multiplications
Couenne::exprUBCosClass to compute lower bound of a cosine based on the bounds of its arguments
Couenne::exprUBDivClass to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUBMulClass to compute upper bound of a product based on the bounds of both factors
Couenne::exprUBQuadClass to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUBSinClass to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprUnaryExpression class for unary functions (sin, log, etc
Couenne::exprUpperBoundUpper bound
Couenne::exprVarVariable-type operator
FileUtilClass used to make it easy to read and write files
Bonmin::FilterSolver
Bonmin::FilterSolver::cachedInfoCached information for reoptimizing
Bonmin::FilterSolver::UnsolvedFilterError
Bonmin::FilterWarmStartWarm start for filter interface
Bonmin::FilterWarmStartDiff
Bonmin::FixAndSolveHeuristic
Couenne::funtriplet
GeneralFileHeaderData structure that holds general information about files that conform to one of the OSxL schemas
GeneralOptionThe GeneralOption Class
GeneralResultThe GeneralResult Class
GeneralStatusThe GeneralStatus Class
GeneralSubstatusThe GeneralSubstatus Class
Couenne::GlobalCutOff
GlobalReport
GlobalReportInstanceData
Bonmin::GuessHeuristic
Bonmin::HeuristicDive
Bonmin::HeuristicDiveFractional
Bonmin::HeuristicDiveMIP
Bonmin::HeuristicDiveMIPFractional
Bonmin::HeuristicDiveMIPVectorLength
Bonmin::HeuristicDiveVectorLength
Bonmin::HeuristicFPump
Bonmin::HeuristicInnerApproximation
Bonmin::HeuristicLocalBranching
Bonmin::HeuristicRINS
Heuristics
Bonmin::HotInfo
IndexStringPairA commonly used structure holding an index-string pair This definition is based on the definition of IndexValuePair in OSGeneral.h
IndexValuePairA commonly used structure holding an index-value pair
Couenne::indPosPair
InitBasStatusInitBasStatus class
InitConstraintValuesInitConstraintValues class
InitConValueInitConValue class
InitDualVariableValuesInitDualVariableValues class
InitDualVarValueInitDualVarValue class
Couenne::InitHeuristicA heuristic that stores the initial solution of the NLP
InitialBasisStatusInitialBasisStatus class
InitObjBoundInitObjBound class
InitObjectiveBoundsInitObjectiveBounds class
InitObjectiveValuesInitObjectiveValues class
InitObjValueInitObjValue class
InitVariableValuesInitVariableValues class
InitVariableValuesStringInitVariableValuesString class
InitVarValueInitVarValue class
InitVarValueStringInitVarValueString class
InstanceDataThe in-memory representation of the <instanceData> element
InstanceHeaderThe in-memory representation of the <instanceHeader> element
InstanceLocationOptionInstanceLocationOption class
IntegerVariableBranchingWeightsIntegerVariableBranchingWeights class
IntervalThe in-memory representation of the <interval> element
IntVectorInteger Vector data structure
Bonmin::IpoptInteriorWarmStarter
IpoptProblem
Bonmin::IpoptSolver
IpoptSolverSolves problems using Ipopt
Bonmin::IpoptSolver::UnsolvedIpoptError
Bonmin::IpoptWarmStartClass for storing warm start informations for Ipopt
Bonmin::IpoptWarmStartDiffDiff class for IpoptWarmStart
JobDependenciesJobDependencies class
JobOptionJobOption class
JobResultThe JobResult Class
KnitroProblem
KnitroSolverKnitroSolver class solves problems using Knitro
Couenne::kpowertriplet
LindoSolverLindoSolver class solves problems using Lindo
LinearConstraintCoefficientsThe in-memory representation of the <linearConstraintCoefficients> element
Bonmin::LinearCutsGenerator
Bonmin::LinearCutsGenerator::CuttingMethodType for cut generation method with its frequency and string identification
Couenne::LinMap
Bonmin::LocalSolverBasedHeuristic
Bonmin::LpBranchingSolverImplementation of BonChooseVariable for curvature-based braching
Bonmin::MatComp
Bonmin::MatComp
MathUtilThis class has routines for linear algebra
MaxTimeMaxTime class
MC_adjacency_entry
MC_cycle_cut
MC_explicit_dense_cut
MC_feas_sol
MC_graph_edge
MC_graph_node
MC_initialize
MC_lp
MC_lp_par
MC_packer
MC_path_adj_entry
MC_path_node
MC_path_node_ptr_compare
MC_problem
MC_solution
MC_switch_structure
MC_tm
MC_tm_par
MCF1_branch_decision
MCF1_branching_var
MCF1_data
MCF1_data::arc
MCF1_data::commodity
MCF1_init
MCF1_lp
MCF1_packer
MCF1_par
MCF1_tm
MCF1_var
MCF2_branch_decision
MCF2_branching_var
MCF2_data
MCF2_data::arc
MCF2_data::commodity
MCF2_init
MCF2_lp
MCF2_packer
MCF2_par
MCF2_tm
MCF2_var
MCF3_branch_decision
MCF3_data
MCF3_data::arc
MCF3_data::commodity
MCF3_init
MCF3_lp
MCF3_packer
MCF3_par
MCF3_tm
MCF3_user
MCF3_var
Bonmin::MilpRounding
MinCPUNumberMinCPUNumber class
MinCPUSpeedMinCPUSpeed class
MinDiskSpaceMinDiskSpace class
Bonmin::MinlpFeasPump
MinMemorySizeMinMemorySize class
Couenne::MultiProdRelIdentifies 5-ples of variables of the form
MY_user_dataClass taking care of interaction between user data and Bcp
myclass
myclass0
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
Nauty
NlThe in-memory representation of the <nl> element
Couenne::NlpSolveHeuristic
Node
Bonmin::NonConvexSuffTo store all data stored in the nonconvex suffixes
NonlinearExpressionsThe in-memory representation of the <nonlinearExpressions> element
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::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
ObjCoefThe in-memory representation of the objective function <coef> element
ObjectiveThe in-memory representation of the <obj> element
ObjectiveOptionObjectiveOption class
ObjectivesThe in-memory representation of the <objectives> element
ObjectiveSolutionThe ObjectiveSolution Class
ObjectiveValuesThe ObjectiveValues Class
ObjValueThe ObjValue Class
OptimizationOptionOptimizationOption class
OptimizationResultThe OptimizationResult Class
OptimizationSolutionThe OptimizationSolution Class
OptimizationSolutionStatusThe OptimizationSolutionStatus Class
OptimizationSolutionSubstatusThe OptimizationSolutionSubstatus Class
Bonmin::optionsCmp
OS_cutSimple representation of a cut by storing non zero coefficients only
OS_DipInterface
OS_init
OS_lpClass for operations at the node level
OS_packerClass taking care of packing/unpacking
OS_probClass holding data for describing the problem
OS_tm
OS_var
OSBearcatSolverXij
OSBearcatSolverXij::Factory
OSBearcatSolverXkij
OSBearcatSolverXkij::Factory
OSColGenApp
OSDecompFactoryInitializer
OSDecompParam
OSDecompSolver
OSDecompSolverFactory
OSDipApp
OSDipBlockBearcatSolver
OSDipBlockBearcatSolver::Factory
OSDipBlockCoinSolver
OSDipBlockCoinSolver::Factory
OSDipBlockSlpSolver
OSDipBlockSlpSolver::Factory
OSDipBlockSolver
OSDipBlockSolverFactory
OSDipFactoryInitializer
OSDipParam
OSExpressionTreeUsed to hold the instance in memory
OSgams2osilCreating a OSInstance from a GAMS model given as GAMS Modeling Object (GMO)
OSGeneral
OSgLParserDataThe OSgLParserData Class
OShLAn interface that specified virtual methods to be implemented by agents
OSiLParserDataThe OSiLParserData Class, used to store parser data
OSiLReaderUsed to read an OSiL string
OSiLWriterTake an OSInstance object and write a string that validates against the OSiL schema
OSInstanceThe in-memory representation of an OSiL instance.
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::SimpleErrorError class to throw exceptions from OsiTMINLPInterface
OsiXxxSolverInterface
OSMatlabThe OSMatlab Class
OSmps2osilThe OSmps2osil Class
OSnl2osilThe OSnl2osil Class
OSnLNodeThe OSnLNode Class
OSnLNodeAbsThe OSnLNodeAbs Class
OSnLNodeAllDiffThe OSnLNodeAllDiff Class
OSnLNodeCosThe OSnLNodeCos Class
OSnLNodeDivideThe OSnLNodeDivide Class
OSnLNodeEThe OSnLNodeE Class
OSnLNodeErfThe OSnLNodeErf Class
OSnLNodeExpThe OSnLNodeExp Class
OSnLNodeIfThe OSnLNodeIf Class
OSnLNodeLnThe OSnLNodeLn Class
OSnLNodeMaxThe OSnLNodeMax Class
OSnLNodeMinThe OSnLNodeMin Class
OSnLNodeMinusThe OSnLNodeMinus Class
OSnLNodeNegateThe OSnLNodeNegate Class
OSnLNodeNumberThe OSnLNodeNumber Class
OSnLNodePIThe OSnLNodePI Class
OSnLNodePlusThe OSnLNodePlus Class
OSnLNodePowerThe OSnLNodePower Class
OSnLNodeProductThe OSnLNodeProduct Class
OSnLNodeSinThe OSnLNodeSin Class
OSnLNodeSqrtThe OSnLNodeSqrt Class
OSnLNodeSquareThe OSnLNodeSquare Class
OSnLNodeSumThe OSnLNodeSum Class
OSnLNodeTimesThe OSnLNodeTimes Class
OSnLNodeVariableThe OSnLNodeVariable Class
OSNode
OSoLParserDataThe OSoLParserData Class
OSoLReaderUsed to read an OSoL string
OSoLWriterTake an OSOption object and write a string that validates against the OSoL schema
OSOptionThe Option Class
osOptionsStrucThis structure is used to store options for the OSSolverService executable
OSResultThe Result Class
OSrL2GamsReads an optimization result and stores result and solution in a Gams Modeling Object
OSrLParserDataThe OSrLParserData Class
OSrLReaderThe OSrLReader Class
OSrLWriterTake an OSResult object and write a string that validates against OSrL
OSSolverAgentUsed by a client to invoke a remote solver
OtherConOptionOtherConOption class
OtherConResultThe OtherConResult Class
OtherConstraintOptionOtherConstraintOption class
OtherConstraintResultThe OtherConstraintResult Class
OtherObjectiveOptionOtherObjectiveOption class
OtherObjectiveResultThe OtherObjectiveResult Class
OtherObjOptionOtherObjOption class
OtherObjResultThe OtherObjResult Class
OtherOptimizationResultThe OtherOptimizationResult Class
OtherOptionOtherOption class
OtherOptionEnumeration
OtherOptionsOtherOptions class
OtherResultThe OtherResult Class
OtherResultsThe OtherResults Class
OtherSolutionResultThe OtherSolutionResult Class
OtherSolutionResultsThe OtherSolutionResults Class
OtherSolverOutputThe OtherSolverOutput Class
OtherVariableOptionOtherVariableOption class
OtherVariableResultThe OtherVariableResult Class
OtherVariableResultStructA structure to information about an OtherVariableResult element
OtherVarOptionOtherVarOption class
OtherVarResultOtherVarResult Class
Bonmin::OuterApproxA class to build outer approximations
PathPairPathPair class
PathPairsPathPairs class
Couenne::powertriplet
Couenne::PowRelIdentifies 5-tuple of the form
ProcessesProcesses class
Bonmin::PseudoCosts
Bonmin::PumpForMinlp
Bonmin::QpBranchingSolverThis class chooses a variable to branch on
Couenne::QrootClass that stores result of previous calls to rootQ into a map for faster access
Bonmin::QuadCut
Couenne::quadElem
Couenne::QuadMap
QuadraticCoefficientsThe in-memory representation of the <quadraticCoefficients> element
QuadraticCuts
QuadraticTermThe in-memory representation of the <qTerm> element
QuadraticTermsData structure for holding quadratic terms
Bonmin::QuadRowStores a quadratic row of the form l < c + ax + x^T Q x < u
real_user_dataClass handling user data
Bonmin::RegisteredOptionsClass to add a few more information to Ipopt::RegisteredOptions
Report
Bonmin::RoundingFPump
Bonmin::score_sorter
Bonmin::SepaSetupAlgorithm setup
ServiceOptionServiceOption class
ServiceResultThe ServiceResult Class
Bonmin::SimpleReferenced< X >
Bonmin::SimpleReferencedPtr< X >
Couenne::simpletriplet
Couenne::SmartAsl
Bonmin::SolReaderA class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file)
solutions
SolverOptionSolverOption class
SolverOptionsSolverOptions class
SolverOutputThe SolverOutput Class
SOSVariableBranchingWeightsSOSVariableBranchingWeights class
SOSWeightsSOSWeights class
SparseHessianMatrixThe in-memory representation of a SparseHessianMatrix.
SparseJacobianMatrixSparse Jacobian matrix data structure
SparseMatrixSparse matrix data structure
SparseVectorSparse vector data structure
sparsify_trace
Bonmin::StartPointReaderThis class reads a file with a starting point for Ipopt initalization
Stat
StorageCapacityStorageCapacity class
Bonmin::StrongBranchingSolverThis class is the base class for a solver that can be used in BonOsiSolverInterface to perform the strong branching solves
Bonmin::SubMipSolverA very simple class to provide a common interface for solving MIPs with Cplex and Cbc
Couenne::SumLogAuxRelIdentifies 5-ples of variables of the form
SystemOptionSystemOption class
SystemResultThe SystemResult Class
Couenne::t_chg_boundsStatus of lower/upper bound of a variable, to be checked/modified in bound tightening
Couenne::threshold
TimeThe Time Class
TimeDomainThe in-memory representation of the <timeDomain> element
TimeDomainInterval
TimeDomainStageThe in-memory representation of the <stage> element
TimeDomainStageConThe in-memory representation of the <con> element
TimeDomainStageConstraintsThe in-memory representation of the <constraints> child of the <stage> element
TimeDomainStageObjThe in-memory representation of the <obj> element
TimeDomainStageObjectivesThe in-memory representation of the <objectives> child of the <stage> element
TimeDomainStagesThe in-memory representation of the <stages> element
TimeDomainStageVarThe in-memory representation of the element
TimeDomainStageVariablesThe in-memory representation of the <variables> child of the <stage> element
TimeMeasurementThe TimeMeasurement Class
Timer
TimeSpanTimeSpan class
TimingInformationThe TimingInformation Class
Bonmin::TMat
Bonmin::TMat::ColumnOrderStructure for ordering matrix by columns
Bonmin::TMat::RowOrderStructure for ordering matrix by columns
Bonmin::TMat::TMatOrderingStructure for ordering matrix
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::TMINLP2TNLPQuadCutsThis is a derived class fro TMINLP2TNLP to handle adding quadratic cuts
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
Bonmin::TMINLPLinObjFrom a TMINLP, this class adapts to another TMINLP where the original objective is transformed into a constraint by adding an extra variable which is minimized
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
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
Tracer
U
USER_initializeThis class is an abstract base class for the initializer class the user has to provide
VariableThe in-memory representation of the variable element
VariableOptionVariableOption class
VariablesThe in-memory representation of the variables element
VariableSolutionThe VariableSolution Class
VariableStringValuesThe VariableStringValues Class
VariableValuesThe VariableValues Class
VariableValuesStringThe VariableValuesString Class
VarStringValueVarStringValue Class
VarValueVarValue Class
VarValueStringVarValueString Class
Bonmin::vector< T >A small wrap around std::vector to give easy access to array for interfacing with fortran code
vector
WSUtilUsed by OSSolverAgent client for help in invoking a remote solver.
yy_buffer_state
yy_trans_info
yyalloc
yyguts_t
YYLTYPE
YYSTYPE

Generated on Thu Nov 10 03:12:05 2011 by  doxygen 1.4.7