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

[detail level 123]

ampl_utils
Bonmin	Define an n-way class for variables
BonNWayChoose	This class chooses a variable to branch on
n_way_consequences
BonNWayObject
BonNWayBranchingObject	N way branching Object class
RobotSetup	Algorithm setup
HeuristicInnerApproximation
BonminAmplSetup
BabSetupBase	A class to have all elements necessary to setup a branch-and-bound
CuttingMethod	Type for cut generation method with its frequency and string identification
HeuristicMethod	Type for heuristic method with its string identification
BonminSetup
CbcStrategyChooseCuts	A class to setup default strategy for Cbc specifying which cut generators to use
SubMipSolver	A very simple class to provide a common interface for solving MIPs with Cplex and Cbc
HotInfo
BonChooseVariable	This class chooses a variable to branch on
Messages
CurvBranchingSolver	Implementation of BonChooseVariable for curvature-based braching
LpBranchingSolver	Implementation of BonChooseVariable for curvature-based braching
PseudoCosts
QpBranchingSolver	This class chooses a variable to branch on
DummyHeuristic
EcpCuts
MinlpFeasPump
OACutGenerator2	Class to perform OA in its classical form
OaDecompositionBase	Base class for OA algorithms
Parameters	Parameters for algorithm
solverManip	Small class to manipulatee various things in an OsiSolverInterface and restore them
OaFeasibilityChecker	Class to perform OA in its classical form
OaMessages	Output messages for Outer approximation cutting planes
OaNlpOptim	Generate cuts for the nlp corresponding to continuous relaxation at a node
LinearCutsGenerator
CuttingMethod	Type for cut generation method with its frequency and string identification
OuterApprox	A class to build outer approximations
QuadCut
Cuts	Generalizes OsiCuts to handle quadratic cuts
QuadRow	Stores a quadratic row of the form l < c + ax + x^T Q x < u
TMat
ColumnOrder	Structure for ordering matrix by columns
RowOrder	Structure for ordering matrix by columns
TMatOrdering	Structure for ordering matrix
TMINLP2TNLPQuadCuts	This is a derived class fro TMINLP2TNLP to handle adding quadratic cuts
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
BabInfo	Bonmin class for passing info between components of branch-and-cuts
Bab
CbcNlpStrategy
BonCbcFullNodeInfo	Holds information for recreating a subproblem by incremental change from the parent for Bonmin
BonCbcPartialNodeInfo	Holds information for recreating a subproblem by incremental change from the parent for
CbcDiver	Class to do diving in the tree
CbcProbedDiver	Class to do probed diving in the tree
CbcDfsDiver	A more elaborate diving class
DiverCompare
GuessHeuristic
DummyPump
FixAndSolveHeuristic
HeuristicDive
HeuristicDiveFractional
MatComp
HeuristicDiveMIP
HeuristicDiveMIPFractional
HeuristicDiveMIPVectorLength
HeuristicDiveVectorLength
score_sorter
HeuristicFPump
RoundingFPump
HeuristicLocalBranching
HeuristicRINS
LocalSolverBasedHeuristic
MilpRounding
PumpForMinlp
AmplInterface	Class for providing an Osi interface to Ipopt with an ampl nl file as input
NonConvexSuff	To store all data stored in the nonconvex suffixes
AmplTMINLP	Ampl MINLP Interface
SolReader	A class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file)
AuxInfo	Bonmin class for passing info between components of branch-and-cuts
BoundsReader	Reads a file containing change bounds for variables
BranchingTQP	This is an adapter class that converts a TMINLP2TNLP object into a TNLP, which is now just a QP
NamesReader	A class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file)
ltstr	String comparison strucutre
CurvatureEstimator
CutStrengthener	Class for strengthening OA cuts, and generating additional ones
StrengtheningTNLP	Class implementing the TNLP for strengthening one cut
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)
Messages	Messages written by an OsiTMINLPInterface
SimpleError	Error class to throw exceptions from OsiTMINLPInterface
optionsCmp
RegisteredOptions	Class to add a few more information to Ipopt::RegisteredOptions
StartPointReader	This class reads a file with a starting point for Ipopt initalization
StrongBranchingSolver	This class is the base class for a solver that can be used in BonOsiSolverInterface to perform the strong branching solves
TMINLP	Base class for all MINLPs that use a standard triplet matrix form and dense vectors
BranchingInfo	Stores branching priorities information
MarkedNonConvex	Structure for marked non-convex constraints
PerturbInfo	Class to store perturbation radii for variables in the model
SimpleConcaveConstraint	Structure which describes a constraints of the form $f[ y F(x) ] with a concave function
SosInfo	Class to store sos constraints for model
TMINLP2OsiLP	A transformer class to build outer approximations i.e
TMINLP2TNLP	This is an adapter class that converts a TMINLP to a TNLP to be solved by Ipopt
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
TNLPSolver	This is a generic class for calling an NLP solver to solve a TNLP
UnsolvedError	We will throw this error when a problem is not solved
vector	A small wrap around std::vector to give easy access to array for interfacing with fortran code
SimpleReferenced
SimpleReferencedPtr
BqpdSolver
cachedInfo	Cached information for reoptimizing
UnsolvedBqpdError
BqpdWarmStart	Warm start for filter interface
Transposer
FilterSolver
cachedInfo	Cached information for reoptimizing
UnsolvedFilterError
FilterWarmStart	Warm start for filter interface
FilterWarmStartDiff
IpoptInteriorWarmStarter
IpoptSolver
UnsolvedIpoptError
IpoptWarmStart	Class for storing warm start informations for Ipopt
IpoptWarmStartDiff	Diff class for IpoptWarmStart
Couenne	General include file for different compilers
CouenneAggrProbing	Cut Generator for aggressive BT; i.e., an aggressive probing
CouenneBTPerfIndicator
CouenneFixPoint	Cut Generator for FBBT fixpoint
CouenneMultiVarProbe
CouenneSparseBndVec
CouenneTwoImplied	Cut Generator for implied bounds derived from pairs of linear (in)equalities
threshold
indPosPair
CouenneBranchingObject	"Spatial" branching object
CouenneSolverInterface	Solver interface class with a pointer to a Couenne cut generator
CouenneChooseStrong
CouenneChooseVariable	Choose a variable for branching
CouenneComplBranchingObject	"Spatial" branching object for complementarity constraints
CouenneComplObject	OsiObject for complementarity constraints $x_1 x_2 \ge,\le,= 0$
CouenneObject	OsiObject for auxiliary variables $w=f(x)$
CouenneOrbitBranchingObj	"Spatial" branching object
CouenneSOSBranchingObject
CouenneSOSObject
CouenneThreeWayBranchObj	Spatial, three-way branching object
CouenneVarObject	OsiObject for variables in a MINLP
CouenneVTObject	OsiObject for violation transfer on variables in a MINLP
CouenneCutGenerator	Cut Generator for linear convexifications
AuxRelation	Base class definition for relations between auxiliaries
SumLogAuxRel	Identifies 5-ples of variables of the form
MultiProdRel	Identifies 5-ples of variables of the form
BiProdDivRel	Identifies 5-tuple of the form
PowRel	Identifies 5-tuple of the form
CouenneCrossConv	Cut Generator that uses relationships between auxiliaries
CouenneScalar
CouenneSparseVector
compare_scalars
CouenneExprMatrix
compare_pair_ind
CouennePSDcon	Class to represent positive semidefinite constraints //////////////////
CouenneSdpCuts	These are cuts of the form
CouenneDisjCuts	Cut Generator for linear convexifications
DomainPoint	Define a point in the solution space and the bounds around it
Domain	Define a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO structure
exprAux	Auxiliary variable
compExpr	Structure for comparing expressions
exprLowerBound	These are bound expression classes
exprUpperBound	Upper bound
exprClone	Expression clone (points to another expression)
exprConst	Constant-type operator
exprCopy
expression	Expression base class
exprIVar	Variable-type operator
exprOp	General n-ary operator-type expression: requires argument list
exprStore	Storage class for previously evaluated expressions
exprUnary	Expression class for unary functions (sin, log, etc.)
exprVar	Variable-type operator
t_chg_bounds	Status of lower/upper bound of a variable, to be checked/modified in bound tightening
CouExpr
exprLBCos	Class to compute lower bound of a cosine based on the bounds of its arguments
exprUBCos	Class to compute lower bound of a cosine based on the bounds of its arguments
exprLBDiv	Class to compute lower bound of a fraction based on the bounds of both numerator and denominator
exprUBDiv	Class to compute upper bound of a fraction based on the bounds of both numerator and denominator
exprLBMul	Class to compute lower bound of a product based on the bounds of both factors
exprUBMul	Class to compute upper bound of a product based on the bounds of both factors
exprLBQuad	Class to compute lower bound of a fraction based on the bounds of both numerator and denominator
exprUBQuad	Class to compute upper bound of a fraction based on the bounds of both numerator and denominator
exprLBSin	Class to compute lower bound of a sine based on the bounds on its arguments
exprUBSin	Class to compute lower bound of a sine based on the bounds on its arguments
exprAbs	Class for
exprBinProd	Class for $\prod_{i=1}^n f_i(x)$ with all binary
exprCeil	Class ceiling, $\lceil f(x) \rceil$
exprCos	Class cosine, $\cos f(x)$
exprDiv	Class for divisions, $\frac{f(x)}{g(x)}$
exprEvenPow	Power of an expression (binary operator) with even exponent, with $k\in \mathbb Z$ constant even
exprExp	Class for the exponential, $e^{f(x)}$
exprFloor	Class floor, $\lfloor f(x) \rfloor$
exprGroup	Class Group, with constant, linear and nonlinear terms: $a_0 + \sum_{i=1}^n a_i x_i$
exprIf
exprInv	Class inverse:
exprLog	Class logarithm, $\log f(x)$
exprMax
exprMin
exprMul	Class for multiplications, $\prod_{i=1}^n f_i(x)$
exprMultiLin	Another class for multiplications, $\prod_{i=1}^n f_i(x)$
exprNorm	Class for -norms, $\|\| f(x)\|\|_p = \left(\sum_{i=1}^n f_i(x)^p\right)^{\frac{1}{p}}$
exprOddPow	Power of an expression (binary operator), with constant
exprOpp	Class opposite,
exprPow	Power of an expression (binary operator), with constant
exprPWLinear
exprQuad	Class exprQuad, with constant, linear and quadratic terms
exprSignPow	Power of an expression (binary operator), $f(x)\|f(x)\|^{k-1}$ with $k \in \mathbb R$ constant
exprSin	Class for $\sin f(x)$
exprSub	Class for subtraction,
exprSum	Class sum, $\sum_{i=1}^n f_i(x)$
exprTrilinear	Class for multiplications
ExprHess	Expression matrices
ExprJac	Jacobian of the problem (computed through Couenne expression classes)
InitHeuristic	A heuristic that stores the initial solution of the NLP
NlpSolveHeuristic
CouenneFeasPump	An implementation of the Feasibility pump that uses linearization and Ipopt to find the two sequences of points
CouenneFPsolution	Class containing a solution with infeasibility evaluation
compareSol	Class for comparing solutions (used in tabu list)
CouenneFPpool	Pool of solutions
CouenneIterativeRounding	An iterative rounding heuristic, tailored for nonconvex MINLPs
CouenneInterface
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)
CouenneTNLP	Class for handling NLPs using CouenneProblem
CouenneUserInterface
CouenneInfo	Bonmin class for passing info between components of branch-and-cuts
NlpSolution	Class for storing an Nlp Solution
SmartAsl
CouenneSetup
CouenneBab
CouenneOSInterface
GlobalCutOff
CouenneProblem	Class for MINLP problems with symbolic information
CouenneConstraint	Class to represent nonlinear constraints
CouenneObjective	Objective function
CouenneRecordBestSol
compNode	Structure for comparing nodes in the dependence graph
DepNode	Vertex of a dependence graph
DepGraph	Dependence graph
CouenneAmplInterface
quadElem
LinMap
QuadMap
funtriplet
simpletriplet
powertriplet
kpowertriplet
Qroot	Class that stores result of previous calls to rootQ into a map for faster access
CouenneSparseMatrix	Class for sparse Matrixs (used in modifying distances in FP)
FilterTypes
Ipopt
SmartPtr
Osi
Sepa
HeuristicInnerApproximation
SepaSetup	Algorithm setup
SepaTMINLP2OsiLP	A transformer class to build outer approximations i.e
AslCouPair
Base64	Use this class to read and write data in base64
BaseMatrix	Data structure to represent a point of departure for constructing a matrix by modifying parts of a previously defined matrix
BasisStatus	Data structure to represent an LP basis on both input and output
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
BB_init
BB_lp	Class for operations at the node level
BB_packer	Class taking care of packing/unpacking
BB_prob	Class holding data for describing the problem
BB_tm
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_cg_prob	This class is the central class of the Cut Generator process
BCP_cg_user	Base class from which the user can derive a problem specific class to be used in the Cut Generator process
BCP_col	This class holds a column in a compressed form
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
BCP_cut_core	Core cuts are the cuts that always stay in the LP formulation
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_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_cut_pool
BCP_lp_integer_branching_object	This class exist only so that we can extract information from OsiIntegerBranchingObject
BCP_lp_node	NO OLD DOC
BCP_lp_par	Parameters used in the LP process
BCP_lp_parent	NO OLD DOC
BCP_lp_prob	NO OLD DOC
BCP_lp_relax	An object of type `BCP_lp_relax` holds the description of an lp relaxation
BCP_lp_result	This class holds the results after solving an LP relaxation
BCP_lp_sos_branching_object	This class exist only so that we can extract information from OsiIntegerBranchingObject
BCP_lp_statistics	NO OLD DOC
BCP_lp_user	Base 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_environment	This is an abstract base class that describes the message passing environment
BCP_node_change
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_parameter_set	This is the class serves as a holder for a set of parameters
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_row	This class holds a row in a compressed form
BCP_scheduler
BCP_single_environment
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
BCP_string	This class is a very simple impelementation of a constant length string
BCP_tm_flags	NO OLD DOC
BCP_tm_node
BCP_tm_node_data
BCP_tm_node_to_send
BCP_tm_par	Parameters used in the Tree Manager process
BCP_tm_prob	NO OLD DOC
BCP_tm_stat
BCP_tm_user	Base class from which the user can derive a problem specific class to be used in the TM process
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_ts_prob
BCP_ts_user
BCP_user_class
BCP_user_data
BCP_user_pack
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
BCP_var_core	Core variables are the variables that always stay in the LP formulation
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	The class BCP_vec serves the same purpose as the vector class in the standard template library
BCP_vec_change	This class stores a vector explicitly or relatively to another vector
BCP_vg_par
BCP_vg_prob	This class is the central class of the Variable Generator process
BCP_vg_user	Base class from which the user can derive a problem specific class to be used in the Cut Generator process
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_init
BM_lp
BM_node
BM_pack
BM_par
BM_SB_result
BM_stats
BM_tm
BMSearchTreeCompareBest
BonminProblem
BonminSolver	Solves problems using Ipopt
BonRandomChoice
BranchingWeight	BranchingWeight class
cmpVar
CoinSolver	Implements a solve method for the Coin solvers
CompletelyPositiveMatricesCone	The CompletelyPositiveMatricesCone Class
compVar	Structure for comparing variables
Cone	The in-memory representation of a generic cone Specific cone types are derived from this generic class
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
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
ConReferenceMatrixValues	Data structure to represent the nonzeros in a conReferenceMatrix element
ConstantMatrixElements	Data structure to represent the constant elements in a MatrixType object
ConstantMatrixValues	To represent the nonzeros in a constantMatrix element
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
CopositiveMatricesCone	The CopositiveMatricesCone Class
CouenneSolver	Solves problems using Ipopt
CPUNumber	CPUNumber class
CPUSpeed	CPUSpeed class
CsdpSolver	Solves problems using Csdp
DefaultSolver	The Default Solver Class
DirectoriesAndFiles	DirectoriesAndFiles class
DoubleVector	Double vector data structure
DualCone	The in-memory representation of a dual cone
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
ExprNode	A generic class from which we derive both OSnLNode and OSnLMNode
FileUtil	Class used to make it easy to read and write files
GeneralFileHeader	Data structure that holds general information about files that conform to one of the OSxL schemas
GeneralMatrixElements	Data structure to represent the nonzero values in a generalMatrix element
GeneralMatrixValues	Data structure to represent the nonzeros in a generalMatrix element
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
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
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
IntersectionCone	The in-memory representation of an intersection cone
Interval	The in-memory representation of the <interval> element
IntVector	Integer Vector data structure
IpoptProblem
IpoptSolver	Solves problems using Ipopt
JobDependencies	JobDependencies class
JobOption	JobOption class
JobResult	The JobResult Class
KnitroProblem
KnitroSolver	KnitroSolver class solves problems using Knitro
less_than_str
LindoSolver	LindoSolver class solves problems using Lindo
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
LinearMatrixElements	Data structure to represent the nonzero values in a linearMatrix element
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
LinearMatrixValues	Data structure to represent the linear expressions in a LinearMatrixElement object
MathUtil	This class has routines for linear algebra
Matrices	The in-memory representation of the <matrices> element
MatrixBlock	Data structure to represent a MatrixBlock object (derived from MatrixType)
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
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
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
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
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
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
MatrixExpressionTree	Used to hold the instance in memory
MatrixNode	Generic class from which we derive matrix constructors (BaseMatrix, MatrixElements, MatrixTransformation and MatrixBlocks) as well as matrix types (OSMatrix and MatrixBlock)
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
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)
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_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
arc
commodity
MCF1_init
MCF1_lp
MCF1_packer
MCF1_par
MCF1_tm
MCF1_var
MCF2_branch_decision
MCF2_branching_var
MCF2_data
arc
commodity
MCF2_init
MCF2_lp
MCF2_packer
MCF2_par
MCF2_tm
MCF2_var
MCF3_branch_decision
MCF3_data
arc
commodity
MCF3_init
MCF3_lp
MCF3_packer
MCF3_par
MCF3_tm
MCF3_user
MCF3_var
MinCPUNumber	MinCPUNumber class
MinCPUSpeed	MinCPUSpeed class
MinDiskSpace	MinDiskSpace class
MinMemorySize	MinMemorySize class
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
MY_user_data	Class taking care of interaction between user data and Bcp
myclass
myclass0
MyTMINLP	A C++ example for interfacing an MINLP with bonmin
Nauty
Nl	The in-memory representation of the <nl> element
Node
NonlinearExpressions	The in-memory representation of the <nonlinearExpressions> element
NonnegativeCone	The NonnegativeCone Class
NonpositiveCone	The NonpositiveCone Class
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
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)
ObjReferenceMatrixValues	To represent the nonzeros in an objReferenceMatrix element
objStrongPri
ObjValue	The ObjValue Class
OptimizationOption	OptimizationOption class
OptimizationResult	The OptimizationResult Class
OptimizationSolution	The OptimizationSolution Class
OptimizationSolutionStatus	The OptimizationSolutionStatus Class
OptimizationSolutionSubstatus	The OptimizationSolutionSubstatus Class
OrthantCone	The OrthantCone Class
OS_AMPL_SUFFIX
OS_cut	Simple representation of a cut by storing non zero coefficients only
OS_DipInterface
OS_init
OS_lp	Class for operations at the node level
OS_packer	Class taking care of packing/unpacking
OS_prob	Class holding data for describing the problem
OS_tm
OS_var
OSBearcatSolverXij
Factory
OSBearcatSolverXkij
Factory
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
OSDecompSolverFactory
OSDipApp
OSDipBlockBearcatSolver
Factory
OSDipBlockCoinSolver
Factory
OSDipBlockSlpSolver
Factory
OSDipBlockSolver
OSDipBlockSolverFactory
OSDipFactoryInitializer
OSDipParam
OSExpressionTree	Used to hold 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
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.
OSMatlab	The OSMatlab Class
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
OSmps2OS	The OSmps2OS Class
OSmps2osil	The OSmps2osil Class
OSnl2OS	The OSnl2OS Class
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
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
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
OSOutputChannel	Class that holds information about one output channel (file, device, stream, peripheral, etc.)
OSReferencedObject	ReferencedObject class
OSReferencer	Pseudo-class, from which everything has to inherit that wants to use be registered as a Referencer for a ReferencedObject
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
OSSmartPtr	Template class for Smart Pointers
OSSolverAgent	Used by a client to invoke a remote solver
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
OtherOptionOrResultEnumeration
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
PathPair	PathPair class
PathPairs	PathPairs class
PolarCone	The in-memory representation of a polar cone
PolyhedralCone	The in-memory representation of a polyhedral cone
Processes	Processes class
ProductCone	The in-memory representation of a product cone
QuadraticCoefficients	The in-memory representation of the <quadraticCoefficients> element
QuadraticCone	The in-memory representation of a quadratic cone
QuadraticTerm	The in-memory representation of the <qTerm> element
QuadraticTerms	Data structure for holding quadratic terms
real_user_data	Class handling user data
RotatedQuadraticCone	The in-memory representation of a rotated quadratic cone
ScalarExpressionTree	Used to hold part of the instance in memory
SemidefiniteCone	The in-memory representation of a cone of semidefinite matrices
ServiceOption	ServiceOption class
ServiceResult	The ServiceResult Class
SolverOption	SolverOption class
SolverOptions	SolverOptions class
SolverOutput	The SolverOutput Class
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
StorageCapacity	StorageCapacity class
SystemOption	SystemOption class
SystemResult	The SystemResult Class
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
TimeMeasurement	The TimeMeasurement Class
TimeSpan	TimeSpan class
TimingInformation	The TimingInformation Class
U
USER_initialize	This class is an abstract base class for the initializer class the user has to provide
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
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
VarReferenceMatrixValues	A concrete class that is used to store a specific type of matrix values, references to variable indexes defined in the core section
VarStringValue	VarStringValue Class
VarValue	VarValue Class
VarValueString	VarValueString Class
WSUtil	Used by OSSolverAgent client for help in invoking a remote solver.
yy_buffer_state
yy_trans_info
yyalloc
yyguts_t
YYLTYPE
YYSTYPE