This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

MCF2_data::arc
MCF1_data::arc
MCF3_data::arc
AslCouPair
Couenne::AuxRelation	Base class definition for relations between auxiliaries
Couenne::BiProdDivRel	Identifies 5-tuple of the form
Couenne::MultiProdRel	Identifies 5-ples of variables of the form
Couenne::PowRel	Identifies 5-tuple of the form
Couenne::SumLogAuxRel	Identifies 5-ples of variables of the form
Bonmin::Bab
Couenne::CouenneBab
Bonmin::BabSetupBase	A class to have all elements necessary to setup a branch-and-bound
Bonmin::BonminSetup
Bonmin::BonminAmplSetup
Bonmin::RobotSetup	Algorithm setup
Couenne::CouenneSetup
Sepa::SepaSetup	Algorithm setup
Base64	Use this class to read and write data in base64
BasisStatus	Data structure to represent an LP basis on both input and output
BB_prob	Class holding data for describing the problem
BCinfo
BCP_buffer	This class describes the message buffer used for all processes of BCP
BCP_cg_par	Parameters used in the Cut Generator process
BCP_parameter_set< BCP_cg_par >
BCP_fatal_error	Currently there isn't any error handling in BCP
BCP_internal_brobj	This class is the internal representation of a branching object
BCP_lp_branching_object	This class describes a generic branching object
BCP_lp_node	NO OLD DOC
BCP_lp_par	Parameters used in the LP process
BCP_parameter_set< BCP_lp_par >
BCP_lp_parent	NO OLD DOC
BCP_lp_result	This class holds the results after solving an LP relaxation
BCP_lp_statistics	NO OLD DOC
BCP_lp_waiting_col
BCP_lp_waiting_row
BCP_MemPool
BCP_message_environment	This is an abstract base class that describes the message passing environment
BCP_single_environment
BCP_node_storage_in_tm	NO OLD DOC
BCP_obj_change
BCP_obj_set_change	This class stores data about how an object set (set of vars or set of cuts) changes
BCP_parameter	This parameter indeintifies a single parameter entry
BCP_presolved_lp_brobj	A presolved branching object candidate
BCP_problem_core	This 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_change	This class describes changes in the core of the problem
BCP_process
BCP_cg_prob	This class is the central class of the Cut Generator process
BCP_lp_prob	NO OLD DOC
BCP_tm_prob	NO OLD DOC
BCP_ts_prob
BCP_vg_prob	This class is the central class of the Variable Generator process
BCP_scheduler
BCP_slave_params	NO OLD DOC
BCP_solution	This is the abstract base class for a solution to a Mixed Integer Programming problem
BCP_solution_generic	This class holds a MIP feasible primal solution
MC_solution
BCP_string	This class is a very simple impelementation of a constant length string
BCP_tm_flags	NO OLD DOC
BCP_tm_node_data
BCP_tm_node_to_send
BCP_tm_par	Parameters used in the Tree Manager process
BCP_parameter_set< BCP_tm_par >
BCP_tm_stat
BCP_tree	NO OLD DOC
BCP_ts_node_data	Same as BCP_tm_node_data, just there's no need to use smart pointers in this process
BCP_ts_par
BCP_parameter_set< BCP_ts_par >
BCP_user_class
BCP_cg_user	Base class from which the user can derive a problem specific class to be used in the Cut Generator process
BCP_lp_user	Base class from which the user can derive a problem specific class to be used in the LP process
BB_lp	Class for operations at the node level
BM_lp
MC_lp
MCF1_lp
MCF2_lp
MCF3_lp
OS_lp	Class for operations at the node level
BCP_tm_user	Base class from which the user can derive a problem specific class to be used in the TM process
BB_tm
BM_tm
MC_tm
MCF1_tm
MCF2_tm
MCF3_tm
OS_tm
BCP_ts_user
BCP_vg_user	Base class from which the user can derive a problem specific class to be used in the Cut Generator process
BCP_user_pack
BB_packer	Class taking care of packing/unpacking
BM_pack
MC_packer
MCF1_packer
MCF2_packer
MCF3_packer
OS_packer	Class taking care of packing/unpacking
BCP_vec< T >	The class BCP_vec serves the same purpose as the vector class in the standard template library
BCP_vec< BCP_child_action >
BCP_vec< BCP_col * >
BCP_vec< BCP_cut * >
BCP_cut_set	This class is just a collection of pointers to cuts with a number of methods to manipulate these cuts and/or select certain entries
BCP_vec< BCP_cut_core * >
BCP_vec< BCP_lp_result * >
BCP_vec< BCP_lp_waiting_col * >
BCP_lp_var_pool
BCP_vec< BCP_lp_waiting_row * >
BCP_lp_cut_pool
BCP_vec< BCP_obj_change >
BCP_vec< BCP_row * >
BCP_vec< BCP_string >
BCP_vec< BCP_tm_node * >
BCP_vec< BCP_user_data * >
BCP_vec< BCP_var * >
BCP_var_set	This 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< BCP_var_core * >
BCP_vec< BCP_vec< BCP_cut * > >
BCP_vec< BCP_vec< BCP_row * > >
BCP_vec< char >
BCP_vec< Coin::SmartPtr< BCP_cut > >
BCP_vec< Coin::SmartPtr< BCP_var > >
BCP_vec< double >
BCP_vec< int >
BCP_vec< std::pair< BCP_string, BCP_parameter > >
BCP_vec< std::pair< int, int > >
BCP_vec_change< T >	This class stores a vector explicitly or relatively to another vector
BCP_vec_change< char >
BCP_vec_change< double >
BCP_vg_par
BCP_parameter_set< BCP_vg_par >
BCP_warmstart	Warmstarting information for the LP solver
BCP_warmstart_basis	This class describes a warmstart information that consists of basis information for structural and artificial variables
BCP_warmstart_dual	This class describes a warmstart information that consists solely of the dual vector
BCP_warmstart_primaldual	This class describes a warmstart information that consists solely of the dual vector
Bigint
BM_BranchData
BM_par
BCP_parameter_set< BM_par >
BM_SB_result
BM_stats
BMSearchTreeCompareBest
Bonmin::BoundsReader	Reads a file containing change bounds for variables
Bonmin::TMINLP::BranchingInfo	Stores branching priorities information
BranchingWeight	BranchingWeight class
CbcCompareBase
Bonmin::DiverCompare
CbcFullNodeInfo
Bonmin::BonCbcFullNodeInfo	Holds information for recreating a subproblem by incremental change from the parent for Bonmin
CbcHeuristic
Bonmin::DummyHeuristic
Bonmin::GuessHeuristic
Bonmin::HeuristicDive
Bonmin::HeuristicDiveFractional
Bonmin::HeuristicDiveVectorLength
Bonmin::HeuristicDiveMIP
Bonmin::HeuristicDiveMIPFractional
Bonmin::HeuristicDiveMIPVectorLength
Bonmin::HeuristicFPump
Bonmin::HeuristicInnerApproximation
Bonmin::LocalSolverBasedHeuristic
Bonmin::DummyPump
Bonmin::FixAndSolveHeuristic
Bonmin::HeuristicLocalBranching
Bonmin::HeuristicRINS
Bonmin::PumpForMinlp
Bonmin::MilpRounding
Couenne::CouenneFeasPump	An implementation of the Feasibility pump that uses linearization and Ipopt to find the two sequences of points
Couenne::CouenneIterativeRounding	An iterative rounding heuristic, tailored for nonconvex MINLPs
Couenne::InitHeuristic	A heuristic that stores the initial solution of the NLP
Couenne::NlpSolveHeuristic
Sepa::HeuristicInnerApproximation
CbcPartialNodeInfo
Bonmin::BonCbcPartialNodeInfo	Holds information for recreating a subproblem by incremental change from the parent for
CbcStrategy
Bonmin::CbcNlpStrategy
CbcStrategyDefault
Bonmin::CbcStrategyChooseCuts	A class to setup default strategy for Cbc specifying which cut generators to use
CbcTree
Bonmin::CbcDfsDiver	A more elaborate diving class
Bonmin::CbcDiver	Class to do diving in the tree
Bonmin::CbcProbedDiver	Class to do probed diving in the tree
CglCutGenerator
Bonmin::LinearCutsGenerator
Bonmin::OaDecompositionBase	Base class for OA algorithms
Bonmin::EcpCuts
Bonmin::MinlpFeasPump
Bonmin::OACutGenerator2	Class to perform OA in its classical form
Bonmin::OaFeasibilityChecker	Class to perform OA in its classical form
Bonmin::OaNlpOptim	Generate cuts for the nlp corresponding to continuous relaxation at a node
Couenne::CouenneAggrProbing	Cut Generator for aggressive BT; i.e., an aggressive probing
Couenne::CouenneCrossConv	Cut Generator that uses relationships between auxiliaries
Couenne::CouenneCutGenerator	Cut Generator for linear convexifications
Couenne::CouenneDisjCuts	Cut Generator for linear convexifications
Couenne::CouenneFixPoint	Cut Generator for FBBT fixpoint
Couenne::CouenneMultiVarProbe
Couenne::CouenneSdpCuts	These are cuts of the form
Couenne::CouenneTwoImplied	Cut Generator for implied bounds derived from pairs of linear (in)equalities
cmpVar
CoinError
Bonmin::OsiTMINLPInterface::SimpleError	Error class to throw exceptions from OsiTMINLPInterface
CoinMessages
Bonmin::BonChooseVariable::Messages
Bonmin::OaMessages	Output messages for Outer approximation cutting planes
Bonmin::OsiTMINLPInterface::Messages	Messages written by an OsiTMINLPInterface
CoinPackedMatrix
BCP_lp_relax	An object of type `BCP_lp_relax` holds the description of an lp relaxation
CoinPackedVector
BCP_col	This class holds a column in a compressed form
BCP_row	This class holds a row in a compressed form
CoinTreeNode
BCP_tm_node
CoinWarmStartBasis
Bonmin::BqpdWarmStart	Warm start for filter interface
Bonmin::FilterWarmStart	Warm start for filter interface
Bonmin::IpoptWarmStart	Class for storing warm start informations for Ipopt
CoinWarmStartPrimalDual
Bonmin::BqpdWarmStart	Warm start for filter interface
Bonmin::FilterWarmStart	Warm start for filter interface
Bonmin::IpoptWarmStart	Class for storing warm start informations for Ipopt
CoinWarmStartPrimalDualDiff
Bonmin::FilterWarmStartDiff
Bonmin::IpoptWarmStartDiff	Diff class for IpoptWarmStart
MCF2_data::commodity
MCF3_data::commodity
MCF1_data::commodity
Couenne::CouenneExprMatrix::compare_pair_ind
Couenne::CouenneSparseVector::compare_scalars
Couenne::compareSol	Class for comparing solutions (used in tabu list)
Couenne::compExpr	Structure for comparing expressions
Couenne::compNode	Structure for comparing nodes in the dependence graph
compVar	Structure for comparing variables
Cone	The in-memory representation of a generic cone Specific cone types are derived from this generic class
CompletelyPositiveMatricesCone	The CompletelyPositiveMatricesCone Class
CopositiveMatricesCone	The CopositiveMatricesCone Class
DualCone	The in-memory representation of a dual cone
IntersectionCone	The in-memory representation of an intersection cone
NonnegativeCone	The NonnegativeCone Class
NonpositiveCone	The NonpositiveCone Class
OrthantCone	The OrthantCone Class
PolarCone	The in-memory representation of a polar cone
PolyhedralCone	The in-memory representation of a polyhedral cone
ProductCone	The in-memory representation of a product cone
QuadraticCone	The in-memory representation of a quadratic cone
RotatedQuadraticCone	The in-memory representation of a rotated quadratic cone
SemidefiniteCone	The in-memory representation of a cone of semidefinite matrices
Cones	The in-memory representation of the <cones> element
ConReferenceMatrixElement	Data structure to represent an entry in a conReferenceMatrix element, which consists of a constraint reference as well as a value type
Constraint	The in-memory representation of the <con> element
ConstraintOption	ConstraintOption class
Constraints	The in-memory representation of the <constraints> element
ConstraintSolution	The ConstraintSolution Class
ContactOption	ContactOption class
Couenne::CouenneBTPerfIndicator
Couenne::CouenneConstraint	Class to represent nonlinear constraints
Couenne::CouennePSDcon	Class to represent positive semidefinite constraints //////////////////
Couenne::CouenneExprMatrix
Couenne::CouenneFPpool	Pool of solutions
Couenne::CouenneFPsolution	Class containing a solution with infeasibility evaluation
Couenne::CouenneObjective	Objective function
Couenne::CouenneProblem	Class for MINLP problems with symbolic information
Couenne::CouenneRecordBestSol
Couenne::CouenneScalar
Couenne::CouenneSparseBndVec< T >
Couenne::CouenneSparseMatrix	Class for sparse Matrixs (used in modifying distances in FP)
Couenne::CouenneSparseVector
Couenne::CouenneUserInterface
Couenne::CouenneAmplInterface
Couenne::CouenneOSInterface
Couenne::CouExpr
CPUNumber	CPUNumber class
CPUSpeed	CPUSpeed class
Bonmin::BabSetupBase::CuttingMethod	Type for cut generation method with its frequency and string identification
DecompApp
OSDipApp
DefaultSolver	The Default Solver Class
BonminSolver	Solves problems using Ipopt
CoinSolver	Implements a solve method for the Coin solvers
CouenneSolver	Solves problems using Ipopt
CsdpSolver	Solves problems using Csdp
IpoptSolver	Solves problems using Ipopt
KnitroSolver	KnitroSolver class solves problems using Knitro
LindoSolver	LindoSolver class solves problems using Lindo
Couenne::DepGraph	Dependence graph
Couenne::DepNode	Vertex of a dependence graph
DirectoriesAndFiles	DirectoriesAndFiles class
Couenne::Domain	Define a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO structure
Couenne::DomainPoint	Define a point in the solution space and the bounds around it
DoubleVector	Double vector data structure
DualVariableValues	The DualVariableValues Class
DualVarValue	The DualVarValue Class
ErrorClass	Used for throwing exceptions
ExpandedMatrixBlocks	Sparse matrix data structure for matrices that can hold nonconstant values and have block structure In addition it is assumed that all nesting of blocks has been resolved
Couenne::expression	Expression base class
Couenne::exprConst	Constant-type operator
Couenne::exprCopy
Couenne::exprClone	Expression clone (points to another expression)
Couenne::exprStore	Storage class for previously evaluated expressions
Couenne::exprLBQuad	Class to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprOp	General n-ary operator-type expression: requires argument list
Couenne::exprDiv	Class for divisions, $\frac{f(x)}{g(x)}$
Couenne::exprIf
Couenne::exprLBCos	Class to compute lower bound of a cosine based on the bounds of its arguments
Couenne::exprLBDiv	Class to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprLBMul	Class to compute lower bound of a product based on the bounds of both factors
Couenne::exprLBSin	Class to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprMax
Couenne::exprMin
Couenne::exprMul	Class for multiplications, $\prod_{i=1}^n f_i(x)$
Couenne::exprBinProd	Class for $\prod_{i=1}^n f_i(x)$ with all binary
Couenne::exprMultiLin	Another class for multiplications, $\prod_{i=1}^n f_i(x)$
Couenne::exprTrilinear	Class for multiplications
Couenne::exprNorm	Class for -norms, $\|\| f(x)\|\|_p = \left(\sum_{i=1}^n f_i(x)^p\right)^{\frac{1}{p}}$
Couenne::exprPow	Power of an expression (binary operator), with constant
Couenne::exprEvenPow	Power of an expression (binary operator) with even exponent, with $k\in \mathbb Z$ constant even
Couenne::exprOddPow	Power of an expression (binary operator), with constant
Couenne::exprPWLinear
Couenne::exprSub	Class for subtraction,
Couenne::exprSum	Class sum, $\sum_{i=1}^n f_i(x)$
Couenne::exprGroup	Class Group, with constant, linear and nonlinear terms: $a_0 + \sum_{i=1}^n a_i x_i$
Couenne::exprQuad	Class exprQuad, with constant, linear and quadratic terms
Couenne::exprUBCos	Class to compute lower bound of a cosine based on the bounds of its arguments
Couenne::exprUBDiv	Class to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUBMul	Class to compute upper bound of a product based on the bounds of both factors
Couenne::exprUBSin	Class to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprUBQuad	Class to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUnary	Expression class for unary functions (sin, log, etc.)
Couenne::exprAbs	Class for
Couenne::exprCeil	Class ceiling, $\lceil f(x) \rceil$
Couenne::exprCos	Class cosine, $\cos f(x)$
Couenne::exprExp	Class for the exponential, $e^{f(x)}$
Couenne::exprFloor	Class floor, $\lfloor f(x) \rfloor$
Couenne::exprInv	Class inverse:
Couenne::exprLog	Class logarithm, $\log f(x)$
Couenne::exprOpp	Class opposite,
Couenne::exprSin	Class for $\sin f(x)$
Couenne::exprVar	Variable-type operator
Couenne::exprAux	Auxiliary variable
Couenne::exprIVar	Variable-type operator
Couenne::exprLowerBound	These are bound expression classes
Couenne::exprUpperBound	Upper bound
Couenne::ExprHess	Expression matrices
Couenne::ExprJac	Jacobian of the problem (computed through Couenne expression classes)
ExprNode	A generic class from which we derive both OSnLNode and OSnLMNode
OSnLMNode	The OSnLMNode Class for nonlinear expressions involving matrices
OSnLMNodeDiagonalMatrixFromVector
OSnLMNodeIdentityMatrix
OSnLMNodeMatrixCon
OSnLMNodeMatrixDiagonal
OSnLMNodeMatrixDotTimes
OSnLMNodeMatrixInverse
OSnLMNodeMatrixLowerTriangle
OSnLMNodeMatrixMinus
OSnLMNodeMatrixNegate
OSnLMNodeMatrixObj
OSnLMNodeMatrixPlus
OSnLMNodeMatrixProduct	The OSnLMNodeMatrixProduct Class
OSnLMNodeMatrixReference
OSnLMNodeMatrixScalarTimes
OSnLMNodeMatrixSubmatrixAt
OSnLMNodeMatrixSum
OSnLMNodeMatrixTimes
OSnLMNodeMatrixTranspose
OSnLMNodeMatrixUpperTriangle
OSnLMNodeMatrixVar
OSnLNode	The OSnLNode Class for nonlinear expressions
OSnLNodeAbs	The OSnLNodeAbs Class
OSnLNodeAllDiff	The OSnLNodeAllDiff Class
OSnLNodeCos	The OSnLNodeCos Class
OSnLNodeDivide	The OSnLNodeDivide Class
OSnLNodeE	The OSnLNodeE Class
OSnLNodeErf	The OSnLNodeErf Class
OSnLNodeExp	The OSnLNodeExp Class
OSnLNodeIf	The OSnLNodeIf Class
OSnLNodeLn	The OSnLNodeLn Class
OSnLNodeMatrixDeterminant	The next few nodes evaluate to a scalar even though one or more of its arguments are matrices
OSnLNodeMatrixToScalar	The OSnLNodeMatrixTrace Class
OSnLNodeMatrixTrace	The OSnLNodeMatrixTrace Class
OSnLNodeMax	The OSnLNodeMax Class
OSnLNodeMin	The OSnLNodeMin Class
OSnLNodeMinus	The OSnLNodeMinus Class
OSnLNodeNegate	The OSnLNodeNegate Class
OSnLNodeNumber	The OSnLNodeNumber Class
OSnLNodePI	The OSnLNodePI Class
OSnLNodePlus	The OSnLNodePlus Class
OSnLNodePower	The OSnLNodePower Class
OSnLNodeProduct	The OSnLNodeProduct Class
OSnLNodeSin	The OSnLNodeSin Class
OSnLNodeSqrt	The OSnLNodeSqrt Class
OSnLNodeSquare	The OSnLNodeSquare Class
OSnLNodeSum	The OSnLNodeSum Class
OSnLNodeTimes	The OSnLNodeTimes Class
OSnLNodeVariable	The OSnLNodeVariable Class
Couenne::exprSignPow	Power of an expression (binary operator), $f(x)\|f(x)\|^{k-1}$ with $k \in \mathbb R$ constant
FileUtil	Class used to make it easy to read and write files
Couenne::funtriplet
Couenne::powertriplet
Couenne::kpowertriplet
Couenne::simpletriplet
GeneralFileHeader	Data structure that holds general information about files that conform to one of the OSxL schemas
GeneralOption	The GeneralOption Class
GeneralResult	The GeneralResult Class
GeneralSparseMatrix	Sparse matrix data structure for matrices that can hold nonconstant values
GeneralStatus	The GeneralStatus Class
GeneralSubstatus	The GeneralSubstatus Class
Couenne::GlobalCutOff
Bonmin::BabSetupBase::HeuristicMethod	Type for heuristic method with its string identification
IndexStringPair	A commonly used structure holding an index-string pair This definition is based on the definition of IndexValuePair in OSGeneral.h
IndexValuePair	A commonly used structure holding an index-value pair
Couenne::indPosPair
InitBasStatus	InitBasStatus class
InitConstraintValues	InitConstraintValues class
InitConValue	InitConValue class
InitDualVariableValues	InitDualVariableValues class
InitDualVarValue	InitDualVarValue class
InitialBasisStatus	InitialBasisStatus class
InitObjBound	InitObjBound class
InitObjectiveBounds	InitObjectiveBounds class
InitObjectiveValues	InitObjectiveValues class
InitObjValue	InitObjValue class
InitVariableValues	InitVariableValues class
InitVariableValuesString	InitVariableValuesString class
InitVarValue	InitVarValue class
InitVarValueString	InitVarValueString class
InstanceData	The in-memory representation of the <instanceData> element
InstanceHeader	The in-memory representation of the <instanceHeader> element
InstanceLocationOption	InstanceLocationOption class
IntegerVariableBranchingWeights	IntegerVariableBranchingWeights class
Interval	The in-memory representation of the <interval> element
IntVector	Integer Vector data structure
OtherOptionOrResultEnumeration
JobDependencies	JobDependencies class
JobOption	JobOption class
JobResult	The JobResult Class
less_than_str
LinearConstraintCoefficients	The in-memory representation of the <linearConstraintCoefficients> element
LinearMatrixElement	Data structure to represent an expression in a linearMatrix element A LinearMatrixElement is a (finite) sum of LinearMatrixElementTerms, with an optional additive constant
LinearMatrixElementTerm	Data structure to represent a term in a linearMatrix element A term has the form c*x_{k}, where c defaults to 1 and k is a valid index for a variable This is essentially an index-value pair, but with the presence of a default value
Couenne::LinMap
Bonmin::NamesReader::ltstr	String comparison strucutre
Bonmin::TMINLP::MarkedNonConvex	Structure for marked non-convex constraints
Bonmin::MatComp
MathUtil	This class has routines for linear algebra
Matrices	The in-memory representation of the <matrices> element
MatrixCon	The in-memory representation of the <matrixCon> element
MatrixConstraints	The in-memory representation of the <matrixConstraints> element
MatrixConstraintSolution	The in-memory representation of the <MatrixConstraintSolution> element
MatrixElementValues	Abstract class to help represent the elements in a MatrixType object From this we derive concrete classes that are used to store specific types of values, such as constant values, variable references, general nonlinear expressions, etc
ConReferenceMatrixValues	Data structure to represent the nonzeros in a conReferenceMatrix element
ConstantMatrixValues	To represent the nonzeros in a constantMatrix element
GeneralMatrixValues	Data structure to represent the nonzeros in a generalMatrix element
LinearMatrixValues	Data structure to represent the linear expressions in a LinearMatrixElement object
ObjReferenceMatrixValues	To represent the nonzeros in an objReferenceMatrix element
VarReferenceMatrixValues	A concrete class that is used to store a specific type of matrix values, references to variable indexes defined in the core section
MatrixExpression	The in-memory representation of the <expr> element, which is like a nonlinear expression, but since it involves matrices, the expression could be linear, so a "shape" attribute is added to distinguish linear and nonlinear expressions
MatrixExpressions	The in-memory representation of the <matrixExpressions> element
MatrixNode	Generic class from which we derive matrix constructors (BaseMatrix, MatrixElements, MatrixTransformation and MatrixBlocks) as well as matrix types (OSMatrix and MatrixBlock)
MatrixConstructor	Data structure to describe one step in the construction of a matrix. To facilitate parsing of complicated matrix constructors and the recursion implicit in the block structure, we distinguish the following types: 1 - BaseMatrix 2 - several types of Elements (e.g., constant, var reference, etc.) 3 - Transformation 4 - MatrixBlocks 5 - MatrixBlock 6 - OSMatrix Most of the logic of this representation is derived from the OSnLNode class
BaseMatrix	Data structure to represent a point of departure for constructing a matrix by modifying parts of a previously defined matrix
MatrixBlocks	Data structure to represent the nonzeroes of a matrix in a blockwise fashion. Each block can be given elementwise, through transformation, or by nested blocks, and so on, recursively
MatrixElements	Abstract class to help represent the elements in a MatrixType object From this we derive concrete classes that are used to store specific types of values, such as constant values, variable references, general nonlinear expressions, etc
ConReferenceMatrixElements	Data structure to represent row reference elements in a MatrixType object Each nonzero element is of the form x_{k} where k is the index of a constraint
ConstantMatrixElements	Data structure to represent the constant elements in a MatrixType object
GeneralMatrixElements	Data structure to represent the nonzero values in a generalMatrix element
LinearMatrixElements	Data structure to represent the nonzero values in a linearMatrix element
MixedRowReferenceMatrixElements	Data structure to represent row reference elements in a MatrixType object Each nonzero element references a row (if index is negative) or constraint (otherwise) This class allows the combining of row and constraint references in a single matrix constructor
ObjReferenceMatrixElements	Data structure to represent objective reference elements in a MatrixType object Each nonzero element is of the form x_{k} where k is the index of an objective (i.e., less than zero)
VarReferenceMatrixElements	Data structure to represent variable reference elements in a MatrixType object Each nonzero element is of the form x_{k} where k is the index of a variable
MatrixTransformation	Data structure to represent the nonzeroes of a matrix by transformation from other (previously defined) matrices
MatrixType	Data structure to represent a MatrixType object (from which we derive OSMatrix and MatrixBlock)
MatrixBlock	Data structure to represent a MatrixBlock object (derived from MatrixType)
OSMatrix	Data structure to represent a matrix object (derived from MatrixType)
OSMatrixWithMatrixConIdx	This class extends OSMatrix for use, e.g., in the matrixCon section of OSoL and OSrL
OSMatrixWithMatrixObjIdx	This class extends OSMatrix for use, e.g., in the matrixObj section of OSoL and OSrL
OSMatrixWithMatrixVarIdx	This class extends OSMatrix for use, e.g., in the matrixVar section of OSoL and OSrL
MatrixObj	The in-memory representation of the <matrixObj> element
MatrixObjectives	The in-memory representation of the <matrixObjectives> element
MatrixObjectiveSolution	The in-memory representation of the <MatrixVariableSolution> element
MatrixProgramming	The in-memory representation of the <matrixProgramming> element
MatrixProgrammingSolution	The in-memory representation of the <MatrixProgrammingSolution> element
MatrixVar	The in-memory representation of the <matrixVar> element
MatrixVariables	The in-memory representation of the <matrixVariables> element
MatrixVariableSolution	The in-memory representation of the <MatrixVariableSolution> element
MatrixVariableValues	The in-memory representation of the <matrixVariables> element
MaxTime	MaxTime class
MC_adjacency_entry
MC_feas_sol
MC_graph_edge
MC_graph_node
MC_lp_par
BCP_parameter_set< MC_lp_par >
MC_path_adj_entry
MC_path_node
MC_path_node_ptr_compare
MC_problem
MC_switch_structure
MC_tm_par
BCP_parameter_set< MC_tm_par >
MCF1_branch_decision
MCF1_data
MCF1_par
BCP_parameter_set< MCF1_par >
MCF2_branch_decision
MCF2_data
MCF2_par
BCP_parameter_set< MCF2_par >
MCF3_branch_decision
MCF3_data
MCF3_par
BCP_parameter_set< MCF3_par >
MinCPUNumber	MinCPUNumber class
MinCPUSpeed	MinCPUSpeed class
MinDiskSpace	MinDiskSpace class
MinMemorySize	MinMemorySize class
myclass
myclass0
Bonmin::n_way_consequences
Bonmin::NamesReader	A class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file)
Nauty
Nl	The in-memory representation of the <nl> element
NlpProblemDef
KnitroProblem
Node
Bonmin::NonConvexSuff	To store all data stored in the nonconvex suffixes
NonlinearExpressions	The in-memory representation of the <nonlinearExpressions> element
ObjCoef	The in-memory representation of the objective function <coef> element
Objective	The in-memory representation of the <obj> element
ObjectiveOption	ObjectiveOption class
Objectives	The in-memory representation of the <objectives> element
ObjectiveSolution	The ObjectiveSolution Class
ObjectiveValues	The ObjectiveValues Class
objPri
objStrongPri
ObjValue	The ObjValue Class
OptimizationOption	OptimizationOption class
OptimizationResult	The OptimizationResult Class
OptimizationSolution	The OptimizationSolution Class
OptimizationSolutionStatus	The OptimizationSolutionStatus Class
OptimizationSolutionSubstatus	The OptimizationSolutionSubstatus Class
Bonmin::optionsCmp
OS_AMPL_SUFFIX
OS_DipInterface
OS_prob	Class holding data for describing the problem
OSColGenApp
OSCommandLine	This class is used to store command line options for the OSSolverService executable and to provide methods to manipulate them
OSCommandLineReader	The OSCommandLineReader Class
OSDecompFactoryInitializer
OSDecompParam
OSDecompSolver
OSBearcatSolverXij
OSBearcatSolverXkij
OSDecompSolverFactory
OSBearcatSolverXij::Factory
OSBearcatSolverXkij::Factory
OSDipBlockSolver
OSDipBlockBearcatSolver
OSDipBlockCoinSolver
OSDipBlockSlpSolver
OSDipBlockSolverFactory
OSDipBlockBearcatSolver::Factory
OSDipBlockCoinSolver::Factory
OSDipBlockSlpSolver::Factory
OSDipFactoryInitializer
OSDipParam
OSExpressionTree	Used to hold the instance in memory
MatrixExpressionTree	Used to hold the instance in memory
ScalarExpressionTree	Used to hold part of the instance in memory
OSgams2osil	Creating a OSInstance from a GAMS model given as GAMS Modeling Object (GMO)
OSGeneral
OSgLParserData	The OSgLParserData Class
OShL	An interface that specified virtual methods to be implemented by agents
OSSolverAgent	Used by a client to invoke a remote solver
OsiBabSolver
Bonmin::AuxInfo	Bonmin class for passing info between components of branch-and-cuts
Bonmin::BabInfo	Bonmin class for passing info between components of branch-and-cuts
Couenne::CouenneInfo	Bonmin class for passing info between components of branch-and-cuts
OsiBranchingObject
Bonmin::BonNWayBranchingObject	N way branching Object class
Couenne::CouenneThreeWayBranchObj	Spatial, three-way branching object
OsiChooseVariable
Bonmin::BonChooseVariable	This class chooses a variable to branch on
Couenne::CouenneChooseStrong
Bonmin::BonNWayChoose	This class chooses a variable to branch on
BonRandomChoice
Couenne::CouenneChooseVariable	Choose a variable for branching
OsiCuts
Bonmin::Cuts	Generalizes OsiCuts to handle quadratic cuts
OsiHotInfo
Bonmin::HotInfo
OsiIntegerBranchingObject
BCP_lp_integer_branching_object	This class exist only so that we can extract information from OsiIntegerBranchingObject
OSiLParserData	The OSiLParserData Class, used to store parser data
OSiLReader	Used to read an OSiL string
OSiLWriter	Take an OSInstance object and write a string that validates against the OSiL schema
OSInstance	The in-memory representation of an OSiL instance.
OsiObject
Bonmin::BonNWayObject
Couenne::CouenneObject	OsiObject for auxiliary variables $w=f(x)$
Couenne::CouenneComplObject	OsiObject for complementarity constraints $x_1 x_2 \ge,\le,= 0$
Couenne::CouenneVarObject	OsiObject for variables in a MINLP
Couenne::CouenneVTObject	OsiObject for violation transfer on variables in a MINLP
OsiPseudoCosts
Bonmin::PseudoCosts
OsiRowCut
BB_cut	Simple representation of a cut by storing non zero coefficients only
BB_cut	Simple representation of a cut by storing non zero coefficients only
Bonmin::QuadCut
OS_cut	Simple representation of a cut by storing non zero coefficients only
OsiSolverInterface
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::AmplInterface	Class for providing an Osi interface to Ipopt with an ampl nl file as input
Couenne::CouenneInterface
Couenne::CouenneMINLPInterface	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)
OsiSOS
Couenne::CouenneSOSObject
OsiSOSBranchingObject
BCP_lp_sos_branching_object	This class exist only so that we can extract information from OsiIntegerBranchingObject
Couenne::CouenneSOSBranchingObject
OsiTwoWayBranchingObject
Couenne::CouenneBranchingObject	"Spatial" branching object
Couenne::CouenneComplBranchingObject	"Spatial" branching object for complementarity constraints
Couenne::CouenneOrbitBranchingObj	"Spatial" branching object
OSMatlab	The OSMatlab Class
OSmps2OS	The OSmps2OS Class
OSmps2osil	The OSmps2osil Class
OSnl2OS	The OSnl2OS Class
OSnLParserData	The OSnLParserData Class
OSNode
OSoLParserData	The OSoLParserData Class
OSoLReader	Used to read an OSoL string
OSoLWriter	Take an OSOption object and write a string that validates against the OSoL schema
OSOption	The Option Class
osOptionsStruc	This structure is used to store options for the OSSolverService executable
OSosrl2ampl	The OSosrl2ampl Class
OSOutputChannel	Class that holds information about one output channel (file, device, stream, peripheral, etc.)
OSReferencedObject	ReferencedObject class
OSOutput	This class handles all the output from OSSolverService, OSAmplClient and other executables derived from them. Every output statement in the code uses methods in this class, passing information about the area that originated the request as well as the print, verbosity or severity level of the message. The message creates output only if the print level matches the user specifications. The main advantage of doing things this way is that multiple output streams can be maintained, each tailored to a specific need and containing only output that the user really wants to see. There can be as many output streams as needed; each one has an identifying name ("stdout" and "stderr" are reserved names) and an array of print levels, one for each area. The class is implemented as a Singleton, which means that two private methods must be defined in the header but must never be implemented: a copy constructor, and an equality operator
OSReferencer	Pseudo-class, from which everything has to inherit that wants to use be registered as a Referencer for a ReferencedObject
OSSmartPtr< T >	Template class for Smart Pointers
OSResult	The Result Class
OSrL2Gams	Reads an optimization result and stores result and solution in a Gams Modeling Object
OSrLParserData	The OSrLParserData Class
OSrLReader	The OSrLReader Class
OSrLWriter	Take an OSResult object and write a string that validates against OSrL
OtherConOption	OtherConOption class
OtherConResult	The OtherConResult Class
OtherConstraintOption	OtherConstraintOption class
OtherConstraintResult	The OtherConstraintResult Class
OtherMatrixVariableResult	The in-memory representation of the <matrixVariables> <other> element
OtherObjectiveOption	OtherObjectiveOption class
OtherObjectiveResult	The OtherObjectiveResult Class
OtherObjOption	OtherObjOption class
OtherObjResult	The OtherObjResult Class
OtherOptimizationResult	The OtherOptimizationResult Class
OtherOption	OtherOption class
OtherOptions	OtherOptions class
OtherResult	The OtherResult Class
OtherResults	The OtherResults Class
OtherSolutionResult	The OtherSolutionResult Class
OtherSolutionResults	The OtherSolutionResults Class
OtherSolverOutput	The OtherSolverOutput Class
OtherVariableOption	OtherVariableOption class
OtherVariableResult	The OtherVariableResult Class
OtherVariableResultStruct	A structure to information about an OtherVariableResult element
OtherVarOption	OtherVarOption class
OtherVarResult	OtherVarResult Class
Bonmin::OuterApprox	A class to build outer approximations
Bonmin::OaDecompositionBase::Parameters	Parameters for algorithm
PathPair	PathPair class
PathPairs	PathPairs class
Bonmin::TMINLP::PerturbInfo	Class to store perturbation radii for variables in the model
Processes	Processes class
Couenne::Qroot	Class that stores result of previous calls to rootQ into a map for faster access
Couenne::quadElem
Couenne::QuadMap
QuadraticCoefficients	The in-memory representation of the <quadraticCoefficients> element
QuadraticTerm	The in-memory representation of the <qTerm> element
QuadraticTerms	Data structure for holding quadratic terms
Bonmin::QuadRow	Stores a quadratic row of the form l < c + ax + x^T Q x < u
real_user_data	Class handling user data
ReferencedObject
Bonmin::BqpdSolver::cachedInfo	Cached information for reoptimizing
Bonmin::CurvatureEstimator
Bonmin::CutStrengthener	Class for strengthening OA cuts, and generating additional ones
Bonmin::IpoptInteriorWarmStarter
Bonmin::StrongBranchingSolver	This class is the base class for a solver that can be used in BonOsiSolverInterface to perform the strong branching solves
Bonmin::CurvBranchingSolver	Implementation of BonChooseVariable for curvature-based braching
Bonmin::LpBranchingSolver	Implementation of BonChooseVariable for curvature-based braching
Bonmin::QpBranchingSolver	This class chooses a variable to branch on
Bonmin::TMINLP	Base class for all MINLPs that use a standard triplet matrix form and dense vectors
Bonmin::AmplTMINLP	Ampl MINLP Interface
Bonmin::TMINLPLinObj	From 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
BonminProblem
MyTMINLP	A C++ example for interfacing an MINLP with bonmin
MyTMINLP	A C++ example for interfacing an MINLP with bonmin
Bonmin::TMINLP2OsiLP	A transformer class to build outer approximations i.e
Sepa::SepaTMINLP2OsiLP	A transformer class to build outer approximations i.e
Bonmin::TNLPSolver	This is a generic class for calling an NLP solver to solve a TNLP
Bonmin::BqpdSolver
Bonmin::FilterSolver
Bonmin::IpoptSolver
Couenne::CouenneInfo::NlpSolution	Class for storing an Nlp Solution
Couenne::SmartAsl
ReferencedObject
BCP_cut	Abstract base class that defines members common to all types of cuts
BCP_cut_algo	This is the class from which the user should derive her own algorithmic cuts
BB_cut	Simple representation of a cut by storing non zero coefficients only
BB_cut	Simple representation of a cut by storing non zero coefficients only
BB_indexed_cut	When 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
MC_cycle_cut
MC_explicit_dense_cut
OS_cut	Simple representation of a cut by storing non zero coefficients only
BCP_cut_core	Core cuts are the cuts that always stay in the LP formulation
BCP_node_change
BCP_user_data
BM_node
MCF3_user
MY_user_data	Class taking care of interaction between user data and Bcp
MY_user_data	Class taking care of interaction between user data and Bcp
BCP_var	Abstract base class that defines members common to all types of variables
BCP_var_algo	This is the class from which the user should derive her own algorithmic variables
MCF1_branching_var
MCF1_var
MCF2_branching_var
MCF2_var
MCF3_var
OS_var
BCP_var_core	Core variables are the variables that always stay in the LP formulation
Bonmin::BqpdWarmStart	Warm start for filter interface
Bonmin::FilterSolver::cachedInfo	Cached information for reoptimizing
Bonmin::FilterWarmStart	Warm start for filter interface
Bonmin::LinearCutsGenerator::CuttingMethod	Type for cut generation method with its frequency and string identification
Bonmin::SimpleReferenced< X >
Bonmin::SimpleReferencedPtr< X >
RegisteredOptions
Bonmin::RegisteredOptions	Class to add a few more information to Ipopt::RegisteredOptions
Bonmin::RoundingFPump
Bonmin::score_sorter
ServiceOption	ServiceOption class
ServiceResult	The ServiceResult Class
Bonmin::TMINLP::SimpleConcaveConstraint	Structure which describes a constraints of the form $f[ y F(x) ] with a concave function
Ipopt::SmartPtr< T >
Ipopt::SmartPtr< Bonmin::Bonmin::AmplTMINLP >
Ipopt::SmartPtr< Bonmin::Bonmin::RegisteredOptions >
Ipopt::SmartPtr< Bonmin::Bonmin::TMINLP2TNLP >
Ipopt::SmartPtr< Bonmin::BqpdSolver::cachedInfo >
Ipopt::SmartPtr< Bonmin::BranchingTQP >
Ipopt::SmartPtr< Bonmin::CurvatureEstimator >
Ipopt::SmartPtr< Bonmin::IpoptInteriorWarmStarter >
Ipopt::SmartPtr< Bonmin::RegisteredOptions >
Ipopt::SmartPtr< Bonmin::TMINLP >
Ipopt::SmartPtr< Bonmin::TMINLP2OsiLP >
Ipopt::SmartPtr< Bonmin::TMINLP2TNLP >
Ipopt::SmartPtr< Bonmin::TNLPSolver >
Ipopt::SmartPtr< BonminProblem >
Ipopt::SmartPtr< CompoundSymMatrix >
Ipopt::SmartPtr< CompoundSymMatrixSpace >
Ipopt::SmartPtr< CompoundVectorSpace >
Ipopt::SmartPtr< const Ipopt::Journalist >
Ipopt::SmartPtr< Couenne::SmartAsl >
Ipopt::SmartPtr< Ipopt::AmplSuffixHandler >
Ipopt::SmartPtr< Ipopt::IpoptApplication >
Ipopt::SmartPtr< Ipopt::Journalist >
Ipopt::SmartPtr< Ipopt::OptionsList >
Ipopt::SmartPtr< Ipopt::TNLP >
Ipopt::SmartPtr< Journalist >
Ipopt::SmartPtr< OptionsList >
Ipopt::SmartPtr< TNLP >
Ipopt::SmartPtr< TSymLinearSolver >
Bonmin::SolReader	A class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file)
Bonmin::OaDecompositionBase::solverManip	Small class to manipulatee various things in an OsiSolverInterface and restore them
SolverOption	SolverOption class
SolverOptions	SolverOptions class
SolverOutput	The SolverOutput Class
Bonmin::TMINLP::SosInfo	Class to store sos constraints for model
SOSVariableBranchingWeights	SOSVariableBranchingWeights class
SOSWeights	SOSWeights class
SparseHessianMatrix	The in-memory representation of a SparseHessianMatrix.
SparseIntVector	Sparse vector data structure for integer vectors
SparseJacobianMatrix	Sparse Jacobian matrix data structure
SparseMatrix	Sparse matrix data structure
SparseVector	Sparse vector data structure
Bonmin::StartPointReader	This class reads a file with a starting point for Ipopt initalization
StorageCapacity	StorageCapacity class
Bonmin::SubMipSolver	A very simple class to provide a common interface for solving MIPs with Cplex and Cbc
SystemOption	SystemOption class
SystemResult	The SystemResult Class
T
Couenne::CouenneSolverInterface< T >	Solver interface class with a pointer to a Couenne cut generator
Couenne::t_chg_bounds	Status of lower/upper bound of a variable, to be checked/modified in bound tightening
Couenne::threshold
Time	The Time Class
TimeDomain	The in-memory representation of the <timeDomain> element
TimeDomainInterval
TimeDomainStage	The in-memory representation of the <stage> element
TimeDomainStageCon	The in-memory representation of the <con> element
TimeDomainStageConstraints	The in-memory representation of the <constraints> child of the <stage> element
TimeDomainStageObj	The in-memory representation of the <obj> element
TimeDomainStageObjectives	The in-memory representation of the <objectives> child of the <stage> element
TimeDomainStages	The in-memory representation of the <stages> element
TimeDomainStageVar	The in-memory representation of the *element*
TimeDomainStageVariables	The in-memory representation of the <variables> child of the <stage> element
TimeSpan	TimeSpan class
TimeMeasurement	The TimeMeasurement Class
TimingInformation	The TimingInformation Class
Bonmin::TMat
Bonmin::TMat::TMatOrdering	Structure for ordering matrix
Bonmin::TMat::ColumnOrder	Structure for ordering matrix by columns
Bonmin::TMat::RowOrder	Structure for ordering matrix by columns
TNLP
Bonmin::BranchingTQP	This is an adapter class that converts a TMINLP2TNLP object into a TNLP, which is now just a QP
Bonmin::CutStrengthener::StrengtheningTNLP	Class implementing the TNLP for strengthening one cut
Bonmin::TMINLP2TNLP	This is an adapter class that converts a TMINLP to a TNLP to be solved by Ipopt
Bonmin::TMINLP2TNLPQuadCuts	This is a derived class fro TMINLP2TNLP to handle adding quadratic cuts
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
Couenne::CouenneTNLP	Class for handling NLPs using CouenneProblem
IpoptProblem
Bonmin::Transposer
U
Bonmin::TNLPSolver::UnsolvedError	We will throw this error when a problem is not solved
Bonmin::BqpdSolver::UnsolvedBqpdError
Bonmin::FilterSolver::UnsolvedFilterError
Bonmin::IpoptSolver::UnsolvedIpoptError
USER_initialize	This class is an abstract base class for the initializer class the user has to provide
BB_init
BM_init
MC_initialize
MCF1_init
MCF2_init
MCF3_init
OS_init
Variable	The in-memory representation of the variable element
VariableOption	VariableOption class
Variables	The in-memory representation of the variables element
VariableSolution	The VariableSolution Class
VariableStringValues	The VariableStringValues Class
VariableValues	The VariableValues Class
VariableValuesString	The VariableValuesString Class
VarStringValue	VarStringValue Class
VarValue	VarValue Class
VarValueString	VarValueString Class
vector
Bonmin::vector< T >	A small wrap around std::vector to give easy access to array for interfacing with fortran code
Bonmin::vector< Bonmin::HotInfo >
Bonmin::vector< Bonmin::QuadRow * >
Bonmin::vector< Bonmin::TMINLP::VariableType >
Bonmin::vector< double >
Bonmin::vector< int >
Bonmin::vector< Ipopt::Index >
Bonmin::vector< Ipopt::Number >
Bonmin::vector< Ipopt::TNLP::LinearityType >
Bonmin::vector< OsiObject * >
Bonmin::vector< QuadCut * >
Bonmin::vector< std::pair< int, int > >
WSUtil	Used by OSSolverAgent client for help in invoking a remote solver.
yy_buffer_state
yy_trans_info
yyalloc
yyguts_t
YYLTYPE
YYSTYPE
Par
BCP_parameter_set< Par >	This is the class serves as a holder for a set of parameters