Cgl 0.59.7

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1 2 3 4 5 6]

_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 |
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 |
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
ClpDualRowSteepest | 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
ClpPresolve | This is the Clp interface to CoinPresolve
ClpPrimalColumnPivot | Primal Column Pivot Abstract Base Class
ClpPrimalColumnDantzig | Primal Column Pivot Dantzig Algorithm Class
ClpPrimalColumnSteepest | 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
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
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
ClpHashValue::CoinHashLink | Data
CoinLpIO::CoinHashLink |
CoinMpsIO::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
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
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
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
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 |
std::complex | STL class
std::list< T >::const_iterator | STL iterator class
std::forward_list< T >::const_iterator | STL iterator class
std::vector< T >::const_iterator | STL iterator class
std::map< K, T >::const_iterator | STL iterator class
std::unordered_map< K, T >::const_iterator | STL iterator class
std::basic_string< Char >::const_iterator | STL iterator class
std::multimap< K, T >::const_iterator | STL iterator class
std::unordered_multimap< K, T >::const_iterator | STL iterator class
std::unordered_multiset< K >::const_iterator | STL iterator class
std::set< K >::const_iterator | STL iterator class
std::wstring::const_iterator | STL iterator class
std::string::const_iterator | STL iterator class
std::unordered_set< K >::const_iterator | STL iterator class
std::multiset< K >::const_iterator | STL iterator class
OsiCuts::const_iterator | Const Iterator
std::deque< T >::const_iterator | STL iterator class
std::forward_list< T >::const_reverse_iterator | STL iterator class
std::basic_string< Char >::const_reverse_iterator | STL iterator class
std::map< K, T >::const_reverse_iterator | STL iterator class
std::unordered_multiset< K >::const_reverse_iterator | STL iterator class
std::unordered_map< K, T >::const_reverse_iterator | STL iterator class
std::multimap< K, T >::const_reverse_iterator | STL iterator class
std::unordered_multimap< K, T >::const_reverse_iterator | STL iterator class
std::list< T >::const_reverse_iterator | STL iterator class
std::set< K >::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::multiset< K >::const_reverse_iterator | STL iterator class
std::wstring::const_reverse_iterator | STL iterator class
std::vector< T >::const_reverse_iterator | STL iterator class
std::deque< T >::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 |
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
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
CglClique::fnode | A node of the fractional graph
std::forward_list< T > | STL class
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 |
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::multiset< K >::iterator | STL iterator class
std::list< T >::iterator | STL iterator class
std::unordered_multiset< K >::iterator | STL iterator class
std::unordered_map< K, T >::iterator | STL iterator class
std::basic_string< Char >::iterator | STL iterator class
std::string::iterator | STL iterator class
std::map< K, T >::iterator | STL iterator class
std::set< K >::iterator | STL iterator class
std::forward_list< T >::iterator | STL iterator class
std::unordered_set< K >::iterator | STL iterator class
std::wstring::iterator | STL iterator class
std::multimap< K, T >::iterator | STL iterator class
std::unordered_multimap< K, T >::iterator | STL iterator class
std::vector< T >::iterator | STL iterator class
std::deque< T >::iterator | STL iterator class
OsiCuts::iterator | Iterator
std::list< T > | STL class
OsiUnitTest::TestOutcomes | Utility class to maintain a list of test outcomes
std::list< TestOutcome > |
log_var |
std::map< K, T > | STL class
std::multimap< K, T > | STL class
std::multiset< K > | STL class
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
OsiLotsizeBranchingObject | Lotsize branching object
OsiSOSBranchingObject | Branching object for Special ordered sets
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
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
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
std::queue< T > | STL class
Coin::ReferencedObject | ReferencedObject class
std::unordered_map< K, T >::reverse_iterator | STL iterator class
std::unordered_multimap< K, T >::reverse_iterator | STL iterator class
std::multiset< K >::reverse_iterator | STL iterator class
std::basic_string< Char >::reverse_iterator | STL iterator class
std::unordered_set< K >::reverse_iterator | STL iterator class
std::forward_list< T >::reverse_iterator | STL iterator class
std::deque< T >::reverse_iterator | STL iterator class
std::string::reverse_iterator | STL iterator class
std::unordered_multiset< K >::reverse_iterator | STL iterator class
std::set< K >::reverse_iterator | STL iterator class
std::multimap< K, T >::reverse_iterator | STL iterator class
std::wstring::reverse_iterator | STL iterator class
std::vector< T >::reverse_iterator | STL iterator class
std::list< T >::reverse_iterator | STL iterator class
std::map< K, T >::reverse_iterator | STL iterator class
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
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< char > |
std::vector< CoinTreeSiblings * > |
std::vector< ColumnSelectionStrategy > |
std::vector< double > |
std::vector< int > |
std::vector< OsiColCut * > |
std::vector< OsiRowCut * > |
std::vector< RowSelectionStrategy > |
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 |