Class Hierarchy

Go to the graphical class hierarchy

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

[detail level 123456]

_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
std::allocator< T >	STL class
ampl_info
OsiSolverInterface::ApplyCutsReturnCode	Internal class for obtaining status from the applyCuts method
std::array< T >	STL class
std::auto_ptr< T >	STL class
auxiliary_graph
CbcGenCtlBlk::babState_struct	State of branch-and-cut
std::basic_string< Char >	STL class
std::string	STL class
std::wstring	STL class
std::basic_string< char >
std::basic_string< wchar_t >
std::bitset< Bits >	STL class
BitVector128
blockStruct
blockStruct3
OsiLinkedBound::boundElementAction
ClpNode::branchState
CglLandP::CachedData	Some informations that will be changed by the pivots and that we want to keep
CbcBaseModel	Base model
CbcBranchDecision
CbcBranchDefaultDecision	Branching decision default class
CbcBranchDynamicDecision	Branching decision dynamic class
CbcBranchUserDecision	Branching decision user class
CbcCompare
CbcCompareBase
CbcCompareDefault
CbcCompareDepth
CbcCompareEstimate
CbcCompareObjective
CbcCompareUser
CbcConsequence	Abstract base class for consequent bounds
CbcFixVariable	Class for consequent bounds
CbcCutGenerator	Interface between Cbc and Cut Generation Library
CbcCutModifier	Abstract cut modifier base class
CbcCutSubsetModifier	Simple cut modifier base class
CbcEventHandler	Base class for Cbc event handling
CbcFathom	Fathom base class
CbcFathomDynamicProgramming	FathomDynamicProgramming class
CbcFeasibilityBase
CbcGenCtlBlk
CbcHeuristic	Heuristic base class
CbcHeuristicCrossover	Crossover Search class
CbcHeuristicDINS
CbcHeuristicDive	Dive class
CbcHeuristicDiveCoefficient	DiveCoefficient class
CbcHeuristicDiveFractional	DiveFractional class
CbcHeuristicDiveGuided	DiveGuided class
CbcHeuristicDiveLineSearch	DiveLineSearch class
CbcHeuristicDivePseudoCost	DivePseudoCost class
CbcHeuristicDiveVectorLength	DiveVectorLength class
CbcHeuristicDW	This is unlike the other heuristics in that it is very very compute intensive
CbcHeuristicDynamic3	Heuristic - just picks up any good solution
CbcHeuristicFPump	Feasibility Pump class
CbcHeuristicGreedyCover	Greedy heuristic classes
CbcHeuristicGreedyEquality
CbcHeuristicGreedySOS	Greedy heuristic for SOS and L rows (and positive elements)
CbcHeuristicJustOne	Just One class - this chooses one at random
CbcHeuristicLocal	LocalSearch class
CbcHeuristicNaive	Naive class a) Fix all ints as close to zero as possible b) Fix all ints with nonzero costs and < large to zero c) Put bounds round continuous and UIs and maximize
CbcHeuristicPartial	Partial solution class If user knows a partial solution this tries to get an integer solution it uses hotstart information
CbcHeuristicPivotAndFix	LocalSearch class
CbcHeuristicProximity
CbcHeuristicRandRound	LocalSearch class
CbcHeuristicRENS	LocalSearch class
CbcHeuristicRINS	LocalSearch class
CbcHeuristicVND	LocalSearch class
CbcRounding	Rounding class
CbcSerendipity	Heuristic - just picks up any good solution found by solver - see OsiBabSolver
CbcHeuristicNode	A class describing the branching decisions that were made to get to the node where a heuristic was invoked from
CbcHeuristicNodeList
CbcModel	Simple Branch and bound class
CbcNauty
CbcNodeInfo	Information required to recreate the subproblem at this node
CbcFullNodeInfo	Information required to recreate the subproblem at this node
CbcPartialNodeInfo	Holds information for recreating a subproblem by incremental change from the parent
CbcObjectUpdateData
CbcOrClpParam	Very simple class for setting parameters
CbcParam	Very simple class for setting parameters
CbcGenCtlBlk::cbcParamsInfo_struct	Start and end of CbcModel parameters in parameter vector
CbcRowCuts
CbcSolver	This allows the use of the standalone solver in a flexible manner
CbcSolverUsefulData	The CbcSolver class was taken out at a 9/12/09 meeting This is a feeble replacement
CbcSolverUsefulData2	Structure to hold useful arrays
CbcStatistics	For gathering statistics
CbcStopNow	Support the use of a call back class to decide whether to stop
CbcStrategy	Strategy base class
CbcStrategyDefault	Default class
CbcStrategyDefaultSubTree	Default class for sub trees
CbcStrategyNull	Null class
CbcStrongInfo	Abstract base class for `objects'
CbcSymmetry	Class to deal with symmetry
CbcThread	A class to encapsulate thread stuff
CbcTree	Using MS heap implementation
CbcTreeLocal
CbcTreeVariable
CbcUser	A class to allow the use of unknown user functionality
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
CglTemporary	Stored Temporary Cut Generator Class - destroyed after first use
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
CbcGenCtlBlk::chooseStrongCtl_struct	Control variables for a strong branching method
CbcGenCtlBlk::cliqueCtl_struct	Control variable and prototype for clique cut generator
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
ClpConstraintAmpl	Ampl Constraint 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
ClpAmplObjective	Ampl Objective 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
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
CoinMpsIO::CoinHashLink
ClpHashValue::CoinHashLink	Data
CoinHashLink	Really for Conflict cuts to - a) stop duplicates b) allow half baked cuts The whichRow_ field in OsiRowCut2 is used for a type 0 - normal 1 - processed cut (conflict) 2 - unprocessed cut i.e
CoinLpIO::CoinHashLink
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
CbcMessage
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
CoinPackedVectorBase	Abstract base class for various sparse vectors
CoinPackedVector	Sparse Vector
CoinShallowPackedVector	Shallow Sparse Vector
CoinPair< S, T >	An ordered pair
CoinParam	A base class for `keyword value' command line parameters
CbcCbcParam	Class for control parameters that act on a CbcModel object
CbcGenParam	Class for cbc-generic control parameters
CbcOsiParam	Class for control parameters that act on a OsiSolverInterface object
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
CbcNode	Information required while the node is live
CoinTreeSiblings
CoinTriple< S, T, U >
CoinWarmStart	Abstract base class for warm start information
CoinWarmStartBasis	The default COIN simplex (basis-oriented) warm start class
AbcWarmStart	As CoinWarmStartBasis but with alternatives (Also uses Clp status meaning for slacks)
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
CbcGenCtlBlk::combineCtl_struct	Control variable and prototype for combine heuristic
std::complex	STL class
std::list< T >::const_iterator	STL iterator class
std::unordered_multimap< K, T >::const_iterator	STL iterator class
std::forward_list< T >::const_iterator	STL iterator class
std::map< K, T >::const_iterator	STL iterator class
std::deque< T >::const_iterator	STL iterator class
std::unordered_map< K, T >::const_iterator	STL iterator class
OsiCuts::const_iterator	Const Iterator
std::basic_string< Char >::const_iterator	STL iterator class
std::multimap< K, T >::const_iterator	STL iterator class
std::set< K >::const_iterator	STL iterator class
std::string::const_iterator	STL iterator class
std::unordered_set< K >::const_iterator	STL iterator class
std::wstring::const_iterator	STL iterator class
std::multiset< K >::const_iterator	STL iterator class
std::vector< T >::const_iterator	STL iterator class
std::unordered_multiset< K >::const_iterator	STL iterator class
std::list< T >::const_reverse_iterator	STL iterator class
std::multimap< K, T >::const_reverse_iterator	STL iterator class
std::deque< T >::const_reverse_iterator	STL iterator class
std::unordered_map< K, T >::const_reverse_iterator	STL iterator class
std::map< K, T >::const_reverse_iterator	STL iterator class
std::unordered_multimap< K, T >::const_reverse_iterator	STL iterator class
std::set< K >::const_reverse_iterator	STL iterator class
std::basic_string< Char >::const_reverse_iterator	STL iterator class
std::string::const_reverse_iterator	STL iterator class
std::unordered_set< K >::const_reverse_iterator	STL iterator class
std::vector< T >::const_reverse_iterator	STL iterator class
std::multiset< K >::const_reverse_iterator	STL iterator class
std::forward_list< T >::const_reverse_iterator	STL iterator class
std::wstring::const_reverse_iterator	STL iterator class
std::unordered_multiset< K >::const_reverse_iterator	STL iterator class
cut
cut_list
cutParams
LAP::Cuts	To store extra cuts generated by columns from which they origin
cycle
cycle_list
CbcGenCtlBlk::debugSolInfo_struct	Array of primal variable values for debugging
std::deque< T >	STL class
std::deque< StdVectorDouble >
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
CbcGenCtlBlk::djFixCtl_struct	Control use of reduced cost fixing prior to B&C
dropped_zero	Tracking information for an explicit zero coefficient
dualColumnResult
edge
EKKHlink	This deals with Factorization and Updates This is ripped off from OSL!!!!!!!!!
std::error_category	STL class
std::error_code	STL class
std::error_condition	STL class
std::exception	STL class
std::bad_alloc	STL class
std::bad_cast	STL class
std::bad_exception	STL class
std::bad_typeid	STL class
std::ios_base::failure	STL class
std::logic_error	STL class
std::domain_error	STL class
std::invalid_argument	STL class
std::length_error	STL class
std::out_of_range	STL class
std::runtime_error	STL class
std::overflow_error	STL class
std::range_error	STL class
std::underflow_error	STL class
FactorPointers	Pointers used during factorization
CbcGenCtlBlk::flowCtl_struct	Control variable and prototype for flow cover cut generator
CglClique::fnode	A node of the fractional graph
std::forward_list< T >	STL class
CbcGenCtlBlk::fpumpCtl_struct	Control variable and prototype for feasibility pump heuristic
CglClique::frac_graph	A graph corresponding to a fractional solution of an LP
CbcGenCtlBlk::genParamsInfo_struct	Start and end of cbc-generic parameters in parameter vector
glp_prob
CbcGenCtlBlk::gomoryCtl_struct	Control variable and prototype for Gomory cut generator
CbcGenCtlBlk::greedyCoverCtl_struct	Control variable and prototype for greedy cover heuristic
CbcGenCtlBlk::greedyEqualityCtl_struct	Control variable and prototype for greedy equality heuristic
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
std::ios_base	STL class
std::basic_ios< char >
std::basic_ios< wchar_t >
std::basic_ios< Char >	STL class
std::basic_istream< char >
std::basic_istream< wchar_t >
std::basic_ostream< char >
std::basic_ostream< wchar_t >
std::basic_istream< Char >	STL class
std::basic_ifstream< char >
std::basic_ifstream< wchar_t >
std::basic_iostream< char >
std::basic_iostream< wchar_t >
std::basic_istringstream< char >
std::basic_istringstream< wchar_t >
std::basic_ifstream< Char >	STL class
std::ifstream	STL class
std::wifstream	STL class
std::basic_iostream< Char >	STL class
std::basic_fstream< char >
std::basic_fstream< wchar_t >
std::basic_stringstream< char >
std::basic_stringstream< wchar_t >
std::basic_fstream< Char >	STL class
std::fstream	STL class
std::wfstream	STL class
std::basic_stringstream< Char >	STL class
std::stringstream	STL class
std::wstringstream	STL class
std::basic_istringstream< Char >	STL class
std::istringstream	STL class
std::wistringstream	STL class
std::istream	STL class
std::wistream	STL class
std::basic_ostream< Char >	STL class
std::basic_iostream< char >
std::basic_iostream< wchar_t >
std::basic_ofstream< char >
std::basic_ofstream< wchar_t >
std::basic_ostringstream< char >
std::basic_ostringstream< wchar_t >
std::basic_iostream< Char >	STL class
std::basic_ofstream< Char >	STL class
std::ofstream	STL class
std::wofstream	STL class
std::basic_ostringstream< Char >	STL class
std::ostringstream	STL class
std::wostringstream	STL class
std::ostream	STL class
std::wostream	STL class
std::ios	STL class
std::wios	STL class
std::unordered_multimap< K, T >::iterator	STL iterator class
std::map< K, T >::iterator	STL iterator class
OsiCuts::iterator	Iterator
std::multimap< K, T >::iterator	STL iterator class
std::list< T >::iterator	STL iterator class
std::basic_string< Char >::iterator	STL iterator class
std::unordered_map< K, T >::iterator	STL iterator class
std::set< K >::iterator	STL iterator class
std::string::iterator	STL iterator class
std::forward_list< T >::iterator	STL iterator class
std::unordered_set< K >::iterator	STL iterator class
std::multiset< K >::iterator	STL iterator class
std::deque< T >::iterator	STL iterator class
std::vector< T >::iterator	STL iterator class
std::unordered_multiset< K >::iterator	STL iterator class
std::wstring::iterator	STL iterator class
CbcGenCtlBlk::knapsackCtl_struct	Control variable and prototype for knapsack cover cut generator
CbcSymmetry::less_than_str
std::list< T >	STL class
OsiUnitTest::TestOutcomes	Utility class to maintain a list of test outcomes
std::list< TestOutcome >
CbcGenCtlBlk::localTreeCtl_struct	Control variables for local tree
log_var
std::map< K, T >	STL class
CbcGenCtlBlk::mirCtl_struct	Control variable and prototype for MIR cut generator
std::multimap< K, T >	STL class
std::multimap< int, int >
std::multiset< K >	STL class
CbcSymmetry::myclass
CbcSymmetry::myclass0
CbcSymmetry::Node
CbcGenCtlBlk::oddHoleCtl_struct	Control variable and prototype for odd hole cut generator
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
CbcBranchingObject	Abstract branching object base class Now just difference with OsiBranchingObject
CbcCliqueBranchingObject	Branching object for unordered cliques
CbcCutBranchingObject	Cut branching object
CbcDummyBranchingObject	Dummy branching object
CbcFixingBranchingObject	General Branching Object class
CbcIntegerBranchingObject	Simple branching object for an integer variable
CbcDynamicPseudoCostBranchingObject	Simple branching object for an integer variable with pseudo costs
CbcIntegerPseudoCostBranchingObject	Simple branching object for an integer variable with pseudo costs
CbcLinkBranchingObject	Branching object for Special ordered sets
CbcLongCliqueBranchingObject	Unordered Clique Branching Object class
CbcLotsizeBranchingObject	Lotsize branching object
CbcNWayBranchingObject	N way branching Object class
CbcOrbitalBranchingObject	Branching object for Orbital branching
CbcSOSBranchingObject	Branching object for Special ordered sets
OsiTwoWayBranchingObject	This just adds two-wayness to a branching object
OsiBiLinearBranchingObject	Branching object for BiLinear objects
OsiIntegerBranchingObject	Simple branching object for an integer variable
OsiLinkBranchingObject	Branching object for Linked ordered sets
OsiLotsizeBranchingObject	Lotsize branching object
OsiSOSBranchingObject	Branching object for Special ordered sets
OsiOldLinkBranchingObject	Branching object for Linked ordered sets
OsiChooseVariable	This class chooses a variable to branch on
OsiChooseStrong	This class chooses a variable to branch on
OsiChooseStrongSubset	This class chooses a variable to branch on
OsiCut
OsiColCut	Column Cut Class
OsiRowCut	Row Cut Class
CbcCountRowCut	OsiRowCut augmented with bookkeeping
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
OsiLinkedBound	List of bounds which depend on other bounds
OsiObject	Abstract base class for `objects'
CbcObject
CbcBranchCut	Define a cut branching class
CbcBranchAllDifferent	Define a branch class that branches so that it is only satsified if all members have different values So cut is x <= y-1 or x >= y+1
CbcBranchToFixLots	Define a branch class that branches so that one way variables are fixed while the other way cuts off that solution
CbcClique	Branching object for cliques
CbcFollowOn	Define a follow on class
CbcFollowOn2	Define a follow on class
CbcGeneral	Define a catch all class
CbcIdiotBranch	Define an idiotic idea class
CbcLink	Define Special Linked Ordered Sets
CbcLotsize	Lotsize class
CbcNWay	Define an n-way class for variables
CbcSimpleInteger	Define a single integer class
CbcSimpleIntegerDynamicPseudoCost	Define a single integer class but with dynamic pseudo costs
CbcSimpleIntegerFixed	Define a single integer class where branching is forced until fixed
CbcSimpleIntegerPseudoCost	Define a single integer class but with pseudo costs
CbcSOS	Branching object for Special Ordered Sets of type 1 and 2
OsiObject2	Define a class to add a bit of complexity to OsiObject This assumes 2 way branching
OsiBiLinear	Define BiLinear objects
OsiBiLinearEquality	Define Continuous BiLinear objects for an == bound
OsiLotsize	Lotsize class
OsiSimpleInteger	Define a single integer class
OsiSimpleFixedInteger	Define a single integer class - but one where you keep branching until fixed even if satisfied
OsiUsesBiLinear	Define a single variable class which is involved with OsiBiLinear objects
OsiSOS	Define Special Ordered Sets of type 1 and 2
OsiLink	Define Special Linked Ordered Sets
OsiOldLink
OsiOneLink	Define data for one link
CbcGenCtlBlk::osiParamsInfo_struct	Start and end of OsiSolverInterface parameters in parameter vector
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
OsiCbcSolverInterface	Cbc Solver Interface
OsiClpSolverInterface	Clp Solver Interface
CbcOsiSolver	This is for codes where solver needs to know about CbcModel Seems to provide only one value-added feature, a CbcModel object
OsiSolverLink	This is to allow the user to replace initialSolve and resolve This version changes coefficients
CbcSolver2	This is to allow the user to replace initialSolve and resolve
CbcSolver3	This is to allow the user to replace initialSolve and resolve
CbcSolverLongThin	This is to allow the user to replace initialSolve and resolve
ClpQuadInterface	This is to allow the user to replace initialSolve and resolve
OsiSolverLinearizedQuadratic	This is to allow the user to replace initialSolve and resolve
OsiCpxSolverInterface	CPLEX Solver Interface
OsiGlpkSolverInterface
OsiGrbSolverInterface	Gurobi Solver Interface
OsiMskSolverInterface
OsiSpxSolverInterface	SoPlex Solver Interface Instantiation of OsiSpxSolverInterface for SoPlex
OsiTestSolverInterface	Vol(ume) Solver Interface
OsiXprSolverInterface	XPRESS-MP Solver Interface
OsiSolverResult	Solver Result Class
OsiTestSolverInterface::OsiVolMatrixOneMinusOne_
Outfo	******** DATA to be moved into protected section of ClpInterior
ClpSimplexOther::parametricsData
parity_ilp
AbcSimplexPrimal::pivotStruct
pool_cut
pool_cut_list
presolvehlink	Links to aid in packed matrix modification
std::priority_queue< T >	STL class
CbcHeuristicDive::PriorityType	Array of priorities
CbcGenCtlBlk::probingCtl_struct	Control variable and prototype for probing cut generator
PseudoReducedCost
std::queue< T >	STL class
CbcGenCtlBlk::redSplitCtl_struct	Control variable and prototype for reduce-and-split cut generator
Coin::ReferencedObject	ReferencedObject class
std::deque< T >::reverse_iterator	STL iterator class
std::unordered_map< K, T >::reverse_iterator	STL iterator class
std::list< T >::reverse_iterator	STL iterator class
std::forward_list< T >::reverse_iterator	STL iterator class
std::map< K, T >::reverse_iterator	STL iterator class
std::unordered_multiset< K >::reverse_iterator	STL iterator class
std::multimap< K, T >::reverse_iterator	STL iterator class
std::basic_string< Char >::reverse_iterator	STL iterator class
std::string::reverse_iterator	STL iterator class
std::unordered_set< K >::reverse_iterator	STL iterator class
std::unordered_multimap< K, T >::reverse_iterator	STL iterator class
std::wstring::reverse_iterator	STL iterator class
std::set< K >::reverse_iterator	STL iterator class
std::multiset< K >::reverse_iterator	STL iterator class
std::vector< T >::reverse_iterator	STL iterator class
CbcGenCtlBlk::roundingCtl_struct	Control variable and prototype for simple rounding heuristic
scatterStruct
select_cut
separation_graph
std::set< K >	STL class
std::set< int >
short_path_node
std::smart_ptr< T >	STL class
Coin::SmartPtr< T >	Template class for Smart Pointers
std::stack< T >	STL class
symrec	For string evaluation
std::system_error	STL class
OsiUnitTest::TestOutcome	A single test outcome record
std::thread	STL class
CbcGenCtlBlk::twomirCtl_struct	Control variable and prototype for Two-MIR cut generator
std::unique_ptr< T >	STL class
std::unordered_map< K, T >	STL class
std::unordered_multimap< K, T >	STL class
std::unordered_multiset< K >	STL class
std::unordered_set< K >	STL class
std::valarray< T >	STL class
LAP::Validator	Class to validate or reject a cut
std::vector< T >	STL class
std::vector< bool >
std::vector< CbcHeuristicNode * >
std::vector< CbcNode * >
std::vector< CbcOrClpParam >
std::vector< CbcSymmetry::Node >
std::vector< char >
std::vector< CoinBigIndex >
std::vector< CoinTreeSiblings * >
std::vector< ColumnSelectionStrategy >
std::vector< double >
std::vector< int >
std::vector< OsiColCut * >
std::vector< OsiRowCut * >
std::vector< RowSelectionStrategy >
std::vector< std::pair< std::string, double > >
std::vector< std::string >
VOL_alpha_factor
VOL_dual
VOL_dvector	Vector of doubles
VOL_indc
VOL_ivector	Vector of ints
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
OsiTestSolverInterface	Vol(ume) Solver Interface
VOL_vh
std::weak_ptr< T >	STL class
K
T