Class Hierarchy

Go to the graphical class hierarchy

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

[detail level 1234]

_EKKfactinfo
AbcDualRowPivot	Dual Row Pivot Abstract Base Class
AbcDualRowDantzig	Dual Row Pivot Dantzig Algorithm Class
AbcDualRowSteepest	Dual Row Pivot Steepest Edge Algorithm Class
AbcMatrix
AbcMatrix2
AbcMatrix3
AbcNonLinearCost
AbcPrimalColumnPivot	Primal Column Pivot Abstract Base Class
AbcPrimalColumnDantzig	Primal Column Pivot Dantzig Algorithm Class
AbcPrimalColumnSteepest	Primal Column Pivot Steepest Edge Algorithm Class
AbcSimplexFactorization	This just implements AbcFactorization when an AbcMatrix object is passed
AbcTolerancesEtc
AbcWarmStartOrganizer
doubleton_action::action
remove_dual_action::action	Postsolve (bound restore) instruction
dupcol_action::action
duprow_action::action
duprow3_action::action
gubrow_action::action
twoxtwo_action::action
drop_empty_cols_action::action
drop_empty_rows_action::action
remove_fixed_action::action	Structure to hold information necessary to reintroduce a column into the problem representation
make_fixed_action::action	Structure to preserve the bound overwritten when fixing a variable
forcing_constraint_action::action
implied_free_action::action
slack_doubleton_action::action
slack_singleton_action::action
subst_constraint_action::action
do_tighten_action::action
tripleton_action::action
useless_constraint_action::action
ampl_info
OsiSolverInterface::ApplyCutsReturnCode	Internal class for obtaining status from the applyCuts method
MCF2_data::arc
MCF3_data::arc
MCF1_data::arc
auxiliary_graph
BB_prob	Class holding data for describing the problem
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
MC_solution
MKC_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
CSP_lp
MC_lp
MC_lp
MCF1_lp
MCF2_lp
MCF3_lp
MKC_lp
BCP_tm_user	Base class from which the user can derive a problem specific class to be used in the TM process
BB_tm
CSP_tm
MC_tm
MC_tm
MCF1_tm
MCF2_tm
MCF3_tm
MKC_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
MC_packer
MCF1_packer
MCF2_packer
MCF3_packer
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< MKC_var * >
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
BitVector128
blockStruct
blockStruct3
ClpNode::branchState
CglLandP::CachedData	Some informations that will be changed by the pivots and that we want to keep
CbcOrClpParam	Very simple class for setting parameters
Cgl012Cut	012Cut Generator Class
cgl_arc
cgl_graph
cgl_node
CglBK	For Bron-Kerbosch
CglCutGenerator	Cut Generator Base Class
CglAllDifferent	AllDifferent Cut Generator Class This has a number of sets
CglClique
CglFakeClique
CglDuplicateRow	DuplicateRow Cut Generator Class
CglFlowCover	Lifed Simple Generalized Flow Cover Cut Generator Class
CglGMI	Gomory cut generator with several cleaning procedures, used to test the numerical safety of the resulting cuts
CglGomory	Gomory Cut Generator Class
CglImplication	This just uses implication info
CglKnapsackCover	Knapsack Cover Cut Generator Class
CglLandP
CglLiftAndProject	Lift And Project Cut Generator Class
CglMixedIntegerRounding	Mixed Integer Rounding Cut Generator Class
CglMixedIntegerRounding2	Mixed Integer Rounding Cut Generator Class
CglOddHole	Odd Hole Cut Generator Class
CglProbing	Probing Cut Generator Class
CglRedSplit	Gomory Reduce-and-Split Cut Generator Class; See method generateCuts()
CglRedSplit2	Reduce-and-Split Cut Generator Class; See method generateCuts()
CglResidualCapacity	Residual Capacity Inequalities Cut Generator Class
CglSimpleRounding	Simple Rounding Cut Generator Class
CglStored	Stored Cut Generator Class
CglTwomir	Twostep MIR Cut Generator Class
CglZeroHalf	Zero Half Cut Generator Class
CglFlowVUB	Variable upper bound class
CglHashLink	Only store unique row cuts
LAP::CglLandPSimplex
CglMixIntRoundVUB
CglMixIntRoundVUB2
CglParam	Class collecting parameters for all cut generators
CglGMIParam	Class collecting parameters for the GMI cut generator
CglLandP::Parameters	Class storing parameters
CglRedSplit2Param	Class collecting parameters the Reduced-and-split cut generator
CglRedSplitParam	Class collecting parameters the Reduced-and-split cut generator
CglPreProcess	Class for preProcessing and postProcessing
CglTreeInfo	Information about where the cut generator is invoked from
CglTreeProbingInfo
CglUniqueRowCuts
CliqueEntry	Derived class to pick up probing info
CglKnapsackCover::CliqueType	Clique type
CglProbing::CliqueType	Clique type
ClpCholeskyBase	Base class for Clp Cholesky factorization Will do better factorization
ClpCholeskyDense
ClpCholeskyMumps	Mumps class for Clp Cholesky factorization
ClpCholeskyTaucs	Taucs class for Clp Cholesky factorization
ClpCholeskyUfl	Ufl class for Clp Cholesky factorization
ClpCholeskyWssmp	Wssmp class for Clp Cholesky factorization
ClpCholeskyWssmpKKT	WssmpKKT class for Clp Cholesky factorization
ClpCholeskyDenseC
ClpConstraint	Constraint Abstract Base Class
ClpConstraintLinear	Linear Constraint Class
ClpConstraintQuadratic	Quadratic Constraint Class
ClpDataSave	This is a tiny class where data can be saved round calls
ClpDisasterHandler	Base class for Clp disaster handling
OsiClpDisasterHandler
ClpDualRowPivot	Dual Row Pivot Abstract Base Class
ClpDualRowDantzig	Dual Row Pivot Dantzig Algorithm Class
ClpPEDualRowDantzig
ClpDualRowSteepest	Dual Row Pivot Steepest Edge Algorithm Class
ClpPEDualRowSteepest	Dual Row Pivot Steepest Edge Algorithm Class
ClpEventHandler	Base class for Clp event handling
MyEventHandler	This is so user can trap events and do useful stuff
ClpFactorization	This just implements CoinFactorization when an ClpMatrixBase object is passed
ClpHashValue
ClpLsqr	This class implements LSQR
ClpMatrixBase	Abstract base class for Clp Matrices
ClpDummyMatrix	This implements a dummy matrix as derived from ClpMatrixBase
ClpNetworkMatrix	This implements a simple network matrix as derived from ClpMatrixBase
ClpPackedMatrix
ClpDynamicMatrix	This implements a dynamic matrix when we have a limit on the number of "interesting rows"
ClpDynamicExampleMatrix	This implements a dynamic matrix when we have a limit on the number of "interesting rows"
ClpGubMatrix	This implements Gub rows plus a ClpPackedMatrix
ClpGubDynamicMatrix	This implements Gub rows plus a ClpPackedMatrix
ClpPlusMinusOneMatrix	This implements a simple +- one matrix as derived from ClpMatrixBase
ClpModel
ClpInterior	This solves LPs using interior point methods
ClpPdco	This solves problems in Primal Dual Convex Optimization
ClpPredictorCorrector	This solves LPs using the predictor-corrector method due to Mehrotra
ClpSimplex	This solves LPs using the simplex method
AbcSimplex
AbcSimplexDual	This solves LPs using the dual simplex method
AbcSimplexPrimal	This solves LPs using the primal simplex method
ClpSimplexDual	This solves LPs using the dual simplex method
ClpSimplexOther	This is for Simplex stuff which is neither dual nor primal
ClpSimplexPrimal	This solves LPs using the primal simplex method
ClpSimplexNonlinear	This solves non-linear LPs using the primal simplex method
ClpNetworkBasis	This deals with Factorization and Updates for network structures
ClpNode
ClpNodeStuff
ClpNonLinearCost
ClpObjective	Objective Abstract Base Class
ClpLinearObjective	Linear Objective Class
ClpQuadraticObjective	Quadratic Objective Class
ClpPackedMatrix2
ClpPackedMatrix3
ClpPdcoBase	Abstract base class for tailoring everything for Pcdo
myPdco	This implements a simple network matrix as derived from ClpMatrixBase
ClpPESimplex	BASE CLASS FOR THE IMPROVED SIMPLEX
ClpPresolve	This is the Clp interface to CoinPresolve
ClpPrimalColumnPivot	Primal Column Pivot Abstract Base Class
ClpPrimalColumnDantzig	Primal Column Pivot Dantzig Algorithm Class
ClpPEPrimalColumnDantzig
ClpPrimalColumnSteepest	Primal Column Pivot Steepest Edge Algorithm Class
ClpPEPrimalColumnSteepest	Primal Column Pivot Steepest Edge Algorithm Class
ClpPrimalQuadraticDantzig	Primal Column Pivot Dantzig Algorithm Class
ClpSimplexProgress	For saving extra information to see if looping
ClpSolve	This is a very simple class to guide algorithms
clpTempInfo
ClpTrustedData	For a structure to be used by trusted code
Cname
CoinAbcAnyFactorization	Abstract base class which also has some scalars so can be used from Dense or Simp
CoinAbcDenseFactorization	This deals with Factorization and Updates This is a simple dense version so other people can write a better one
CoinAbcTypeFactorization
CoinAbcStack
CoinAbcStatistics
CoinAbsFltEq	Equality to an absolute tolerance
CoinArrayWithLength	Pointer with length in bytes
CoinArbitraryArrayWithLength	Arbitrary version
CoinBigIndexArrayWithLength	CoinBigIndex * version
CoinDoubleArrayWithLength	Double * version
CoinFactorizationDoubleArrayWithLength	CoinFactorizationDouble * version
CoinFactorizationLongDoubleArrayWithLength	CoinFactorizationLongDouble * version
CoinIntArrayWithLength	Int * version
CoinUnsignedIntArrayWithLength	Unsigned int * version
CoinVoidStarArrayWithLength	Void * version
CoinBaseModel
CoinModel	This is a simple minded model which is stored in a format which makes it easier to construct and modify but not efficient for algorithms
CoinStructuredModel
CoinBuild	In many cases it is natural to build a model by adding one row at a time
CoinDenseVector< T >	Dense Vector
CoinError	Error Class thrown by an exception
CglLandP::NoBasisError
CglLandP::SimplexInterfaceError
CoinExternalVectorFirstGreater_2< S, T, V >	Function operator
CoinExternalVectorFirstGreater_3< S, T, U, V >	Function operator
CoinExternalVectorFirstLess_2< S, T, V >	Function operator
CoinExternalVectorFirstLess_3< S, T, U, V >	Function operator
CoinFactorization	This deals with Factorization and Updates
CoinFileIOBase	Base class for FileIO classes
CoinFileInput	Abstract base class for file input classes
CoinPlainFileInput	This reads plain text files
CoinFileOutput	Abstract base class for file output classes
CoinFirstAbsGreater_2< S, T >	Function operator
CoinFirstAbsGreater_3< S, T, U >	Function operator
CoinFirstAbsLess_2< S, T >	Function operator
CoinFirstAbsLess_3< S, T, U >	Function operator
CoinFirstGreater_2< S, T >	Function operator
CoinFirstGreater_3< S, T, U >	Function operator
CoinFirstLess_2< S, T >	Function operator
CoinFirstLess_3< S, T, U >	Function operator
CoinLpIO::CoinHashLink
CoinMpsIO::CoinHashLink
ClpHashValue::CoinHashLink	Data
CoinIndexedVector	Indexed Vector
CoinPartitionedVector
LAP::TabRow
CoinLpIO	Class to read and write Lp files
CoinMessageHandler	Base class for message handling
MyMessageHandler
CoinMessages	Class to hold and manipulate an array of massaged messages
CglMessage	This deals with Cgl messages (as against Osi messages etc)
ClpMessage	This deals with Clp messages (as against Osi messages etc)
CoinMessage	The standard set of Coin messages
LAP::LandPMessages	Message handler for lift-and-project simplex
LAP::LapMessages	Output messages for Cgl
CoinModelHash
CoinModelHash2	For int,int hashing
CoinModelHashLink	For names and hashing
CoinModelHashLink2
CoinModelInfo2	This is a model which is made up of Coin(Structured)Model blocks
CoinModelLink	This is for various structures/classes needed by CoinModel
CoinModelLinkedList
CoinModelTriple	For linked lists
CoinMpsCardReader	Very simple code for reading MPS data
CoinMpsIO	MPS IO Interface
CoinOneMessage	Class for one massaged message
CoinOtherFactorization	Abstract base class which also has some scalars so can be used from Dense or Simp
CoinDenseFactorization	This deals with Factorization and Updates This is a simple dense version so other people can write a better one
CoinOslFactorization
CoinSimpFactorization
CoinSnapshot::coinOwned	To say whether arrays etc are owned by CoinSnapshot
CoinPackedMatrix	Sparse Matrix Base Class
BCP_lp_relax	An object of type BCP_lp_relax holds the description of an lp relaxation
CoinPackedVectorBase	Abstract base class for various sparse vectors
CoinPackedVector	Sparse Vector
BCP_col	This class holds a column in a compressed form
BCP_row	This class holds a row in a compressed form
CoinShallowPackedVector	Shallow Sparse Vector
CoinPair< S, T >	An ordered pair
CoinParam	A base class for `keyword value' command line parameters
CoinPrePostsolveMatrix	Collects all the information about the problem that is needed in both presolve and postsolve
CoinPostsolveMatrix	Augments CoinPrePostsolveMatrix with information about the problem that is only needed during postsolve
CoinPresolveMatrix	Augments CoinPrePostsolveMatrix with information about the problem that is only needed during presolve
CoinPresolveAction	Abstract base class of all presolve routines
do_tighten_action
doubleton_action	Solve ax+by=c for y and substitute y out of the problem
drop_empty_cols_action	Physically removes empty columns in presolve, and reinserts empty columns in postsolve
drop_empty_rows_action	Physically removes empty rows in presolve, and reinserts empty rows in postsolve
drop_zero_coefficients_action	Removal of explicit zeros
dupcol_action	Detect and remove duplicate columns
duprow3_action
duprow_action	Detect and remove duplicate rows
forcing_constraint_action	Detect and process forcing constraints and useless constraints
gubrow_action	Detect and remove entries whose sum is known
implied_free_action	Detect and process implied free variables
isolated_constraint_action
make_fixed_action	Fix a variable at a specified bound
remove_dual_action	Attempt to fix variables by bounding reduced costs
remove_fixed_action	Excise fixed variables from the model
slack_doubleton_action	Convert an explicit bound constraint to a column bound
slack_singleton_action	For variables with one entry
subst_constraint_action	Detect and process implied free variables
tripleton_action	We are only going to do this if it does not increase number of elements?
twoxtwo_action	Detect interesting 2 by 2 blocks
useless_constraint_action
CoinPresolveMonitor	Monitor a row or column for modification
CoinRational
CoinRelFltEq	Equality to a scaled tolerance
CoinSearchTreeBase
CoinSearchTree< Comp >
CoinSearchTreeCompareBest	Best first search
CoinSearchTreeCompareBreadth
CoinSearchTreeCompareDepth	Depth First Search
CoinSearchTreeComparePreferred	Function objects to compare search tree nodes
CoinSearchTreeManager
CoinSet	Very simple class for containing data on set
CoinSosSet	Very simple class for containing SOS set
CoinSnapshot	NON Abstract Base Class for interfacing with cut generators or branching code or
CoinThreadRandom	Class for thread specific random numbers
CoinTimer	This class implements a timer that also implements a tracing functionality
CoinTreeNode	A class from which the real tree nodes should be derived from
BCP_tm_node
CoinTreeSiblings
CoinTriple< S, T, U >
CoinWarmStart	Abstract base class for warm start information
CoinWarmStartBasis	The default COIN simplex (basis-oriented) warm start class
AbcWarmStart
CoinWarmStartDual	WarmStart information that is only a dual vector
CoinWarmStartPrimalDual	WarmStart information that is only a dual vector
CoinWarmStartVector< T >	WarmStart information that is only a vector
CoinWarmStartVector< double >
CoinWarmStartVector< U >
CoinWarmStartVectorPair< T, U >
CoinWarmStartDiff	Abstract base class for warm start `diff' objects
CoinWarmStartBasisDiff	A `diff' between two CoinWarmStartBasis objects
CoinWarmStartDualDiff	A `diff' between two CoinWarmStartDual objects
CoinWarmStartPrimalDualDiff	A `diff' between two CoinWarmStartPrimalDual objects
CoinWarmStartVectorDiff< T >	A `diff' between two CoinWarmStartVector objects
CoinWarmStartVectorDiff< double >
CoinWarmStartVectorDiff< U >
CoinWarmStartVectorPairDiff< T, U >
CoinYacc
MCF2_data::commodity
MCF3_data::commodity
MCF1_data::commodity
OsiCuts::const_iterator	Const Iterator
CSP_colgen
CSP_lp_par
BCP_parameter_set< CSP_lp_par >
CSP_packedVector
CSP_subProblem
CSP_tm_par
BCP_parameter_set< CSP_tm_par >
CSPROBLEM
cut
cut_list
cutParams
LAP::Cuts	To store extra cuts generated by columns from which they origin
cycle
cycle_list
DELETEOBJECT
DGG_constraint_t
DGG_data_t
DGG_list_t
CglProbing::disaggregation_struct_tag	Disaggregation cuts and for building cliques
disaggregationAction	Only useful type of disaggregation is most normal For now just done for 0-1 variables Can be used for building cliques
dropped_zero	Tracking information for an explicit zero coefficient
dualColumnResult
edge
EKKHlink	This deals with Factorization and Updates This is ripped off from OSL!!!!!!!!!
FactorPointers	Pointers used during factorization
CglClique::fnode	A node of the fractional graph
CglClique::frac_graph	A graph corresponding to a fractional solution of an LP
glp_prob
Idiot	This class implements a very silly algorithm
IdiotResult	For use internally
ilp
Info	******** DATA to be moved into protected section of ClpInterior
info_weak
OsiCuts::iterator	Iterator
Knapsack
list
OsiUnitTest::TestOutcomes	Utility class to maintain a list of test outcomes
log_var
LP_parms
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 >
MKC_knapsack
MKC_knapsack_entry
MKC_knapsack_fixing
MKC_knapsack_set
MKC_lp_par
BCP_parameter_set< MKC_lp_par >
MKC_tm_par
BCP_parameter_set< MKC_tm_par >
Options	******** DATA to be moved into protected section of ClpInterior
OsiAuxInfo	This class allows for a more structured use of algorithmic tweaking to an OsiSolverInterface
OsiBabSolver	This class allows for the use of more exotic solvers e.g
OsiBranchingInformation
OsiBranchingObject	Abstract branching object base class
OsiTwoWayBranchingObject	This just adds two-wayness to a branching object
OsiIntegerBranchingObject	Simple branching object for an integer variable
BCP_lp_integer_branching_object	This class exist only so that we can extract information from OsiIntegerBranchingObject
OsiLotsizeBranchingObject	Lotsize branching object
OsiSOSBranchingObject	Branching object for Special ordered sets
BCP_lp_sos_branching_object	This class exist only so that we can extract information from OsiIntegerBranchingObject
OsiChooseVariable	This class chooses a variable to branch on
OsiChooseStrong	This class chooses a variable to branch on
OsiCut
OsiColCut	Column Cut Class
OsiRowCut	Row Cut Class
BB_cut	Simple representation of a cut by storing non zero coefficients only
OsiRowCut2	Row Cut Class which refers back to row which created it
OsiCuts::OsiCutCompare
OsiCuts	Collections of row cuts and column cuts
OsiHotInfo	This class contains the result of strong branching on a variable When created it stores enough information for strong branching
OsiObject	Abstract base class for `objects'
OsiObject2	Define a class to add a bit of complexity to OsiObject This assumes 2 way branching
OsiLotsize	Lotsize class
OsiSimpleInteger	Define a single integer class
OsiSOS	Define Special Ordered Sets of type 1 and 2
OsiPresolve	OSI interface to COIN problem simplification capabilities
OsiPseudoCosts	This class is the placeholder for the pseudocosts used by OsiChooseStrong
OsiRowCutDebugger	Validate cuts against a known solution
OsiSolverBranch	Solver Branch Class
OsiSolverInterface	Abstract Base Class for describing an interface to a solver
OsiClpSolverInterface	Clp Solver Interface
OsiCpxSolverInterface	CPLEX Solver Interface
OsiGlpkSolverInterface
OsiGrbSolverInterface	Gurobi Solver Interface
OsiMskSolverInterface
OsiSpxSolverInterface	SoPlex Solver Interface Instantiation of OsiSpxSolverInterface for SoPlex
OsiTestSolverInterface	Vol(ume) Solver Interface
OsiVolSolverInterface	Vol(ume) Solver Interface
OsiXprSolverInterface	XPRESS-MP Solver Interface
OsiSolverResult	Solver Result Class
OsiTestSolverInterface::OsiVolMatrixOneMinusOne_
OsiVolSolverInterface::OsiVolMatrixOneMinusOne_
Outfo	******** DATA to be moved into protected section of ClpInterior
ClpSimplexOther::parametricsData
parity_ilp
PATTERN
CSP_var
AbcSimplexPrimal::pivotStruct
pool_cut
pool_cut_list
presolvehlink	Links to aid in packed matrix modification
real_user_data	Class handling user data
Coin::ReferencedObject	ReferencedObject class
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_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_cycle_cut
MC_explicit_dense_cut
MC_explicit_dense_cut
BCP_cut_core	Core cuts are the cuts that always stay in the LP formulation
BCP_node_change
BCP_user_data
MCF3_user
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
CSP_var
MCF1_branching_var
MCF1_var
MCF2_branching_var
MCF2_var
MCF3_var
MKC_branching_var
MKC_var
BCP_var_core	Core variables are the variables that always stay in the LP formulation
Rname
scatterStruct
select_cut
separation_graph
short_path_node
Coin::SmartPtr< T >	Template class for Smart Pointers
Coin::SmartPtr< BCP_cut >
Coin::SmartPtr< BCP_node_change >
Coin::SmartPtr< BCP_user_data >
Coin::SmartPtr< BCP_var >
symrec	For string evaluation
OsiUnitTest::TestOutcome	A single test outcome record
triplet
UFL_parms
USER_initialize	This class is an abstract base class for the initializer class the user has to provide
BB_init
CSP_initialize
MC_initialize
MC_initialize
MCF1_init
MCF2_init
MCF3_init
MKC_initialize
UserData
LAP::Validator	Class to validate or reject a cut
VOL_alpha_factor
VOL_dual
VOL_dvector	Vector of doubles
VOL_indc
VOL_ivector	Vector of ints
VOL_lp
VOL_parms	This class contains the parameters controlling the Volume Algorithm
VOL_primal
VOL_problem	This class holds every data for the Volume Algorithm and its solve method must be invoked to solve the problem
VOL_swing
VOL_user_hooks	The user hooks should be overridden by the user to provide the problem specific routines for the volume algorithm
LP_data_and_hook
OsiTestSolverInterface	Vol(ume) Solver Interface
OsiVolSolverInterface	Vol(ume) Solver Interface
UFL
VOL_vh
Par
BCP_parameter_set< Par >	This is the class serves as a holder for a set of parameters