Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_EKKfactinfo
AbcBranchDecisionAbstract branching decision base class
AbcBranchDefaultDecisionBranching decision default class
AbcCutGeneratorInterface between Abc and Cut Generation Library
AbcDualRowDantzigDual Row Pivot Dantzig Algorithm Class
AbcDualRowPivotDual Row Pivot Abstract Base Class
AbcDualRowSteepestDual Row Pivot Steepest Edge Algorithm Class
AbcHeuristicHeuristic base class
AbcMatrix
AbcMatrix2
AbcMatrix3
AbcMessage
AbcModelModel class for ALPS Branch and Cut
AbcNodeDesc
AbcNonLinearCost
AbcParams
AbcPrimalColumnDantzigPrimal Column Pivot Dantzig Algorithm Class
AbcPrimalColumnPivotPrimal Column Pivot Abstract Base Class
AbcPrimalColumnSteepestPrimal Column Pivot Steepest Edge Algorithm Class
AbcPseudocost
AbcRoundingRounding class
AbcSimplex
AbcSimplexDualThis solves LPs using the dual simplex method
AbcSimplexFactorizationThis just implements AbcFactorization when an AbcMatrix object is passed
AbcSimplexPrimalThis solves LPs using the primal simplex method
AbcSolutionThis class holds a MIP feasible primal solution
AbcTolerancesEtc
AbcTreeNode
AbcWarmStart
AbcWarmStartOrganizer
doubleton_action::action
remove_dual_action::actionPostsolve (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::actionStructure to hold information necessary to reintroduce a column into the problem representation
make_fixed_action::actionStructure 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
AddOffset< T >
allinfo
ALPS_PS_STATS
AlpsDecompModelDerivation of AlpsModel for DECOMP
AlpsDecompNodeDescDerivation of AlpsNodeDesc for DECOMP
AlpsDecompParamParameters passed through to Alps
AlpsDecompSolution
AlpsDecompTreeNode
AlpsEncodedThis data structure is to contain the packed form of an encodable knowledge
AlpsKnowledgeThe abstract base class of any user-defined class that Alps has to know about in order to encode/decode
AlpsKnowledgeBrokerThe base class of knowledge broker class
AlpsKnowledgeBrokerMPI
AlpsKnowledgeBrokerSerial
AlpsKnowledgePool
AlpsMessage
AlpsModel
AlpsNodeDescA class to refer to the description of a search tree node
AlpsNodePoolNode pool is used to store the nodes to be processed
AlpsNodeSelection
AlpsNodeSelectionBest
AlpsNodeSelectionBreadth
AlpsNodeSelectionDepth
AlpsNodeSelectionEstimate
AlpsNodeSelectionHybrid
AlpsParameterThis parameter indeintifies a single parameter entry
AlpsParameterSetThis is the class serves as a holder for a set of parameters
AlpsParams
AlpsPriorityQueue< T >
AlpsSolution
AlpsSolutionPoolIn the solution pool we assume that the lower the priority value the more desirable the solution is
AlpsStrLessA function object to perform lexicographic lexicographic comparison between two C style strings
AlpsSubTreeThis class contains the data pertaining to a particular subtree in the search tree
AlpsSubTreePoolThe subtree pool is used to store subtrees
AlpsTimer
AlpsTreeNodeThis class holds one node of the search tree
AlpsTreeSelection
AlpsTreeSelectionBest
AlpsTreeSelectionBreadth
AlpsTreeSelectionDepth
AlpsTreeSelectionEstimate
ampl_info
OsiSolverInterface::ApplyCutsReturnCodeInternal class for obtaining status from the applyCuts method
MCF_Instance::arcMCF_Instance problem instance data
SDPUC_Instance::arcSDPUC_Instance problem instance data
ATM_DecompApp
ATM_Instance
ATM_Param
auxiliary_graph
CbcGenCtlBlk::babState_structState of branch-and-cut
BcpsDecompModel
BcpsDecompNodeDesc
BcpsDecompSolutionThis class holds a MIP feasible primal solution
BcpsDecompTreeNode
BitVector128
blockStruct
blockStruct3
OsiLinkedBound::boundElementAction
ClpNode::branchState
CglLandP::CachedDataSome informations that will be changed by the pivots and that we want to keep
CbcBaseModelBase model
CbcBranchAllDifferentDefine 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
CbcBranchCutDefine a cut branching class
CbcBranchDecision
CbcBranchDefaultDecisionBranching decision default class
CbcBranchDynamicDecisionBranching decision dynamic class
CbcBranchingObjectAbstract branching object base class Now just difference with OsiBranchingObject
CbcBranchToFixLotsDefine a branch class that branches so that one way variables are fixed while the other way cuts off that solution
CbcBranchUserDecisionBranching decision user class
CbcCbcParamClass for control parameters that act on a CbcModel object
CbcCliqueBranching object for cliques
CbcCliqueBranchingObjectBranching object for unordered cliques
CbcCompare
CbcCompareBase
CbcCompareDefault
CbcCompareDepth
CbcCompareEstimate
CbcCompareObjective
CbcCompareUser
CbcConsequenceAbstract base class for consequent bounds
CbcCountRowCutOsiRowCut augmented with bookkeeping
CbcCutBranchingObjectCut branching object
CbcCutGeneratorInterface between Cbc and Cut Generation Library
CbcCutModifierAbstract cut modifier base class
CbcCutSubsetModifierSimple cut modifier base class
CbcDisasterHandler
CbcDummyBranchingObjectDummy branching object
CbcDynamicPseudoCostBranchingObjectSimple branching object for an integer variable with pseudo costs
CbcEventHandlerBase class for Cbc event handling
CbcFathomFathom base class
CbcFathomDynamicProgrammingFathomDynamicProgramming class
CbcFeasibilityBase
CbcFixingBranchingObjectGeneral Branching Object class
CbcFixVariableClass for consequent bounds
CbcFollowOnDefine a follow on class
CbcFollowOn2Define a follow on class
CbcFullNodeInfoInformation required to recreate the subproblem at this node
CbcGenCtlBlk
CbcGeneralDefine a catch all class
CbcGeneralBranchingObject
CbcGeneralDepthDefine a catch all class
CbcGenParamClass for cbc-generic control parameters
CbcHeuristicHeuristic base class
CbcHeuristicCrossoverCrossover Search class
CbcHeuristicDINS
CbcHeuristicDiveDive class
CbcHeuristicDiveCoefficientDiveCoefficient class
CbcHeuristicDiveFractionalDiveFractional class
CbcHeuristicDiveGuidedDiveGuided class
CbcHeuristicDiveLineSearchDiveLineSearch class
CbcHeuristicDivePseudoCostDivePseudoCost class
CbcHeuristicDiveVectorLengthDiveVectorLength class
CbcHeuristicDWThis is unlike the other heuristics in that it is very very compute intensive
CbcHeuristicDynamic3Heuristic - just picks up any good solution
CbcHeuristicFPumpFeasibility Pump class
CbcHeuristicGreedyCoverGreedy heuristic classes
CbcHeuristicGreedyEquality
CbcHeuristicGreedySOSGreedy heuristic for SOS and L rows (and positive elements)
CbcHeuristicJustOneJust One class - this chooses one at random
CbcHeuristicLocalLocalSearch class
CbcHeuristicNaiveNaive 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
CbcHeuristicNodeA class describing the branching decisions that were made to get to the node where a heuristic was invoked from
CbcHeuristicNodeList
CbcHeuristicPartialPartial solution class If user knows a partial solution this tries to get an integer solution it uses hotstart information
CbcHeuristicPivotAndFixLocalSearch class
CbcHeuristicProximity
CbcHeuristicRandRoundLocalSearch class
CbcHeuristicRENSLocalSearch class
CbcHeuristicRINSLocalSearch class
CbcHeuristicVNDLocalSearch class
CbcIdiotBranchDefine an idiotic idea class
CbcIntegerBranchingObjectSimple branching object for an integer variable
CbcIntegerPseudoCostBranchingObjectSimple branching object for an integer variable with pseudo costs
CbcLinkDefine Special Linked Ordered Sets
CbcLinkBranchingObjectBranching object for Special ordered sets
CbcLongCliqueBranchingObjectUnordered Clique Branching Object class
CbcLotsizeLotsize class
CbcLotsizeBranchingObjectLotsize branching object
CbcMessage
CbcModelSimple Branch and bound class
CbcNauty
CbcNodeInformation required while the node is live
CbcNodeInfoInformation required to recreate the subproblem at this node
CbcNWayDefine an n-way class for variables
CbcNWayBranchingObjectN way branching Object class
CbcObject
CbcObjectUpdateData
CbcOneGeneralBranchingObjectBranching object for general objects - just one
CbcOrbitalBranchingObjectBranching object for Orbital branching
CbcOrClpParamVery simple class for setting parameters
CbcOsiParamClass for control parameters that act on a OsiSolverInterface object
CbcOsiSolverThis is for codes where solver needs to know about CbcModel Seems to provide only one value-added feature, a CbcModel object
CbcParamVery simple class for setting parameters
CbcGenCtlBlk::cbcParamsInfo_structStart and end of CbcModel parameters in parameter vector
CbcPartialNodeInfoHolds information for recreating a subproblem by incremental change from the parent
CbcRoundingRounding class
CbcRowCuts
CbcSerendipityHeuristic - just picks up any good solution found by solver - see OsiBabSolver
CbcSimpleIntegerDefine a single integer class
CbcSimpleIntegerDynamicPseudoCostDefine a single integer class but with dynamic pseudo costs
CbcSimpleIntegerFixedDefine a single integer class where branching is forced until fixed
CbcSimpleIntegerPseudoCostDefine a single integer class but with pseudo costs
CbcSolverThis allows the use of the standalone solver in a flexible manner
CbcSolver2This is to allow the user to replace initialSolve and resolve
CbcSolver3This is to allow the user to replace initialSolve and resolve
CbcSolverLongThinThis is to allow the user to replace initialSolve and resolve
CbcSolverUsefulDataThe CbcSolver class was taken out at a 9/12/09 meeting This is a feeble replacement
CbcSolverUsefulData2Structure to hold useful arrays
CbcSOSBranching object for Special Ordered Sets of type 1 and 2
CbcSOSBranchingObjectBranching object for Special ordered sets
CbcStatisticsFor gathering statistics
CbcStopNowSupport the use of a call back class to decide whether to stop
CbcStrategyStrategy base class
CbcStrategyDefaultDefault class
CbcStrategyDefaultSubTreeDefault class for sub trees
CbcStrategyNullNull class
CbcStrongInfoAbstract base class for `objects'
CbcSubProblem
CbcSymmetryClass to deal with symmetry
CbcThreadA class to encapsulate thread stuff
CbcTreeUsing MS heap implementation
CbcTreeLocal
CbcTreeVariable
CbcUserA class to allow the use of unknown user functionality
CCdata_rhvector
CCdata_user
CCdatagroup
CCrandstate
CCtsp_lpclique
CCtsp_lpcut_in
CCtsp_segment
CCtsp_skeleton
Cgl012Cut012Cut Generator Class
cgl_arc
cgl_graph
cgl_node
CglAllDifferentAllDifferent Cut Generator Class This has a number of sets
CglBKFor Bron-Kerbosch
CglClique
CglCutGeneratorCut Generator Base Class
CglDuplicateRowDuplicateRow Cut Generator Class
CglFakeClique
CglFlowCoverLifed Simple Generalized Flow Cover Cut Generator Class
CglFlowVUBVariable upper bound class
CglGMIGomory cut generator with several cleaning procedures, used to test the numerical safety of the resulting cuts
CglGMIParamClass collecting parameters for the GMI cut generator
CglGomoryGomory Cut Generator Class
CglHashLinkOnly store unique row cuts
CglImplicationThis just uses implication info
CglKnapsackCoverKnapsack Cover Cut Generator Class
CglLandP
LAP::CglLandPSimplex
CglLiftAndProjectLift And Project Cut Generator Class
CglMessageThis deals with Cgl messages (as against Osi messages etc)
CglMixedIntegerRoundingMixed Integer Rounding Cut Generator Class
CglMixedIntegerRounding2Mixed Integer Rounding Cut Generator Class
CglMixIntRoundVUB
CglMixIntRoundVUB2
CglOddHoleOdd Hole Cut Generator Class
CglParamClass collecting parameters for all cut generators
CglPreProcessClass for preProcessing and postProcessing
CglProbingProbing Cut Generator Class
CglRedSplitGomory Reduce-and-Split Cut Generator Class; See method generateCuts()
CglRedSplit2Reduce-and-Split Cut Generator Class; See method generateCuts()
CglRedSplit2ParamClass collecting parameters the Reduced-and-split cut generator
CglRedSplitParamClass collecting parameters the Reduced-and-split cut generator
CglResidualCapacityResidual Capacity Inequalities Cut Generator Class
CglSimpleRoundingSimple Rounding Cut Generator Class
CglStoredStored Cut Generator Class
CglTemporaryStored Temporary Cut Generator Class - destroyed after first use
CglTreeInfoInformation about where the cut generator is invoked from
CglTreeProbingInfo
CglTwomirTwostep MIR Cut Generator Class
CglUniqueRowCuts
CglZeroHalfZero Half Cut Generator Class
CbcGenCtlBlk::chooseStrongCtl_structControl variables for a strong branching method
CbcGenCtlBlk::cliqueCtl_structControl variable and prototype for clique cut generator
CliqueEntryDerived class to pick up probing info
CglProbing::CliqueTypeClique type
CglKnapsackCover::CliqueTypeClique type
ClpAmplObjectiveAmpl Objective Class
ClpCholeskyBaseBase class for Clp Cholesky factorization Will do better factorization
ClpCholeskyDense
ClpCholeskyDenseC
ClpCholeskyMumpsMumps class for Clp Cholesky factorization
ClpCholeskyTaucsTaucs class for Clp Cholesky factorization
ClpCholeskyUflUfl class for Clp Cholesky factorization
ClpCholeskyWssmpWssmp class for Clp Cholesky factorization
ClpCholeskyWssmpKKTWssmpKKT class for Clp Cholesky factorization
ClpConstraintConstraint Abstract Base Class
ClpConstraintAmplAmpl Constraint Class
ClpConstraintLinearLinear Constraint Class
ClpConstraintQuadraticQuadratic Constraint Class
ClpDataSaveThis is a tiny class where data can be saved round calls
ClpDisasterHandlerBase class for Clp disaster handling
ClpDualRowDantzigDual Row Pivot Dantzig Algorithm Class
ClpDualRowPivotDual Row Pivot Abstract Base Class
ClpDualRowSteepestDual Row Pivot Steepest Edge Algorithm Class
ClpDummyMatrixThis implements a dummy matrix as derived from ClpMatrixBase
ClpDynamicExampleMatrixThis implements a dynamic matrix when we have a limit on the number of "interesting rows"
ClpDynamicMatrixThis implements a dynamic matrix when we have a limit on the number of "interesting rows"
ClpEventHandlerBase class for Clp event handling
ClpFactorizationThis just implements CoinFactorization when an ClpMatrixBase object is passed
ClpGubDynamicMatrixThis implements Gub rows plus a ClpPackedMatrix
ClpGubMatrixThis implements Gub rows plus a ClpPackedMatrix
ClpHashValue
ClpInteriorThis solves LPs using interior point methods
ClpLinearObjectiveLinear Objective Class
ClpLsqrThis class implements LSQR
ClpMatrixBaseAbstract base class for Clp Matrices
ClpMessageThis deals with Clp messages (as against Osi messages etc)
ClpModel
ClpNetworkBasisThis deals with Factorization and Updates for network structures
ClpNetworkMatrixThis implements a simple network matrix as derived from ClpMatrixBase
ClpNode
ClpNodeStuff
ClpNonLinearCost
ClpObjectiveObjective Abstract Base Class
ClpPackedMatrix
ClpPackedMatrix2
ClpPackedMatrix3
ClpPdcoThis solves problems in Primal Dual Convex Optimization
ClpPdcoBaseAbstract base class for tailoring everything for Pcdo
ClpPlusMinusOneMatrixThis implements a simple +- one matrix as derived from ClpMatrixBase
ClpPredictorCorrectorThis solves LPs using the predictor-corrector method due to Mehrotra
ClpPresolveThis is the Clp interface to CoinPresolve
ClpPrimalColumnDantzigPrimal Column Pivot Dantzig Algorithm Class
ClpPrimalColumnPivotPrimal Column Pivot Abstract Base Class
ClpPrimalColumnSteepestPrimal Column Pivot Steepest Edge Algorithm Class
ClpPrimalQuadraticDantzigPrimal Column Pivot Dantzig Algorithm Class
ClpQuadInterfaceThis is to allow the user to replace initialSolve and resolve
ClpQuadraticObjectiveQuadratic Objective Class
ClpSimplexThis solves LPs using the simplex method
ClpSimplexDualThis solves LPs using the dual simplex method
ClpSimplexNonlinearThis solves non-linear LPs using the primal simplex method
ClpSimplexOtherThis is for Simplex stuff which is neither dual nor primal
ClpSimplexPrimalThis solves LPs using the primal simplex method
ClpSimplexProgressFor saving extra information to see if looping
ClpSolveThis is a very simple class to guide algorithms
ClpTrustedDataFor a structure to be used by trusted code
CoinAbcAnyFactorizationAbstract base class which also has some scalars so can be used from Dense or Simp
CoinAbcDenseFactorizationThis deals with Factorization and Updates This is a simple dense version so other people can write a better one
CoinAbcStack
CoinAbcStatistics
CoinAbcTypeFactorization
CoinAbsFltEqEquality to an absolute tolerance
CoinArbitraryArrayWithLengthArbitrary version
CoinArrayWithLengthPointer with length in bytes
CoinBaseModel
CoinBigIndexArrayWithLengthCoinBigIndex * version
CoinBuildIn many cases it is natural to build a model by adding one row at a time
CoinDenseFactorizationThis deals with Factorization and Updates This is a simple dense version so other people can write a better one
CoinDenseVector< T >Dense Vector
CoinDoubleArrayWithLengthDouble * version
CoinErrorError Class thrown by an exception
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
CoinFactorizationThis deals with Factorization and Updates
CoinFactorizationDoubleArrayWithLengthCoinFactorizationDouble * version
CoinFactorizationLongDoubleArrayWithLengthCoinFactorizationLongDouble * version
CoinFileInputAbstract base class for file input classes
CoinFileIOBaseBase class for FileIO classes
CoinFileOutputAbstract 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
CoinHashLinkReally 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
ClpHashValue::CoinHashLinkData
CoinLpIO::CoinHashLink
CoinMpsIO::CoinHashLink
CoinIndexedVectorIndexed Vector
CoinIntArrayWithLengthInt * version
CoinLpIOClass to read and write Lp files
CoinMessageThe standard set of Coin messages
CoinMessageHandlerBase class for message handling
CoinMessagesClass to hold and manipulate an array of massaged messages
CoinModelThis is a simple minded model which is stored in a format which makes it easier to construct and modify but not efficient for algorithms
CoinModelHash
CoinModelHash2For int,int hashing
CoinModelHashLinkFor names and hashing
CoinModelInfo2This is a model which is made up of Coin(Structured)Model blocks
CoinModelLinkThis is for various structures/classes needed by CoinModel
CoinModelLinkedList
CoinModelTripleFor linked lists
CoinMpsCardReaderVery simple code for reading MPS data
CoinMpsIOMPS IO Interface
CoinOneMessageClass for one massaged message
CoinOslFactorization
CoinOtherFactorizationAbstract base class which also has some scalars so can be used from Dense or Simp
CoinSnapshot::coinOwnedTo say whether arrays etc are owned by CoinSnapshot
CoinPackedMatrixSparse Matrix Base Class
CoinPackedVectorSparse Vector
CoinPackedVectorBaseAbstract base class for various sparse vectors
CoinPair< S, T >An ordered pair
CoinParamA base class for `keyword value' command line parameters
CoinPartitionedVector
CoinPostsolveMatrixAugments CoinPrePostsolveMatrix with information about the problem that is only needed during postsolve
CoinPrePostsolveMatrixCollects all the information about the problem that is needed in both presolve and postsolve
CoinPresolveActionAbstract base class of all presolve routines
CoinPresolveMatrixAugments CoinPrePostsolveMatrix with information about the problem that is only needed during presolve
CoinPresolveMonitorMonitor a row or column for modification
CoinRational
CoinRelFltEqEquality to a scaled tolerance
CoinSearchTree< Comp >
CoinSearchTreeBase
CoinSearchTreeCompareBestBest first search
CoinSearchTreeCompareBreadth
CoinSearchTreeCompareDepthDepth First Search
CoinSearchTreeComparePreferredFunction objects to compare search tree nodes
CoinSearchTreeManager
CoinSetVery simple class for containing data on set
CoinShallowPackedVectorShallow Sparse Vector
CoinSimpFactorization
CoinSnapshotNON Abstract Base Class for interfacing with cut generators or branching code or
CoinSosSetVery simple class for containing SOS set
CoinStructuredModel
CoinThreadRandomClass for thread specific random numbers
CoinTimerThis class implements a timer that also implements a tracing functionality
CoinTreeNodeA class from which the real tree nodes should be derived from
CoinTreeSiblings
CoinTriple< S, T, U >
CoinUnsignedIntArrayWithLengthUnsigned int * version
CoinVoidStarArrayWithLengthVoid * version
CoinWarmStartAbstract base class for warm start information
CoinWarmStartBasisThe default COIN simplex (basis-oriented) warm start class
CoinWarmStartBasisDiffA `diff' between two CoinWarmStartBasis objects
CoinWarmStartDiffAbstract base class for warm start `diff' objects
CoinWarmStartDualWarmStart information that is only a dual vector
CoinWarmStartDualDiffA `diff' between two CoinWarmStartDual objects
CoinWarmStartPrimalDualWarmStart information that is only a dual vector
CoinWarmStartPrimalDualDiffA `diff' between two CoinWarmStartPrimalDual objects
CoinWarmStartVector< T >WarmStart information that is only a vector
CoinWarmStartVectorDiff< T >A `diff' between two CoinWarmStartVector objects
CoinWarmStartVectorPair< T, U >
CoinWarmStartVectorPairDiff< T, U >
CoinYacc
CbcGenCtlBlk::combineCtl_structControl variable and prototype for combine heuristic
MCF_Instance::commodity
ConcordeGraph
ConcordeSubtourCut
OsiCuts::const_iteratorConst Iterator
cut
cut_list
cutParams
LAP::CutsTo store extra cuts generated by columns from which they origin
CVRPsep_LPSol
cycle
cycle_list
CbcGenCtlBlk::debugSolInfo_structArray of primal variable values for debugging
DecompAlgoBase class for DECOMP algorithms
DecompAlgoCClass for DECOMP algorithm Cutting Plane Method
DecompAlgoCGLAn interface to CGL cut generator library
DecompAlgoDClass for DECOMP algorithm Decomp
DecompAlgoModel
DecompAlgoPCClass for DECOMP algorithm Price and Cut
DecompAlgoRC
DecompAppThe main application class
DecompAppModel
DecompConstraintSet
DecompCut
DecompCutOsi
DecompCutPool
DecompMainParam
DecompMemPool
DecompModel
DecompNodeStats
DecompObjBound
DecompParam
DecompSolution
DecompSolverResultStorage of solver result
DecompStats
DecompVar
DecompVarPool
DecompWaitingCol
DecompWaitingRow
DeletePtrObject
DGG_constraint_t
DGG_data_t
DGG_list_t
DippyAlgoCPython-enabled DecompAlgoC
DippyAlgoMixinMixin class for Dip Algorithms
DippyAlgoPCPython-enabled DecompAlgoPC
DippyAlgoRCPython-enabled DecompAlgoRC
DippyDecompApp
DippyDecompCut
CglProbing::disaggregation_struct_tagDisaggregation cuts and for building cliques
disaggregationActionOnly useful type of disaggregation is most normal For now just done for 0-1 variables Can be used for building cliques
CbcGenCtlBlk::djFixCtl_structControl use of reduced cost fixing prior to B&C
do_tighten_action
doubleton_actionSolve ax+by=c for y and substitute y out of the problem
drop_empty_cols_actionPhysically removes empty columns in presolve, and reinserts empty columns in postsolve
drop_empty_rows_actionPhysically removes empty rows in presolve, and reinserts empty rows in postsolve
drop_zero_coefficients_actionRemoval of explicit zeros
dropped_zeroTracking information for an explicit zero coefficient
dualColumnResult
dupcol_actionDetect and remove duplicate columns
duprow3_action
duprow_actionDetect and remove duplicate rows
edge
EKKHlinkThis deals with Factorization and Updates This is ripped off from OSL!!!!!!!!!
FactorPointersPointers used during factorization
CbcGenCtlBlk::flowCtl_structControl variable and prototype for flow cover cut generator
CglClique::fnodeA node of the fractional graph
forcing_constraint_actionDetect and process forcing constraints and useless constraints
CbcGenCtlBlk::fpumpCtl_structControl variable and prototype for feasibility pump heuristic
CglClique::frac_graphA graph corresponding to a fractional solution of an LP
GAP_DecompApp
GAP_DecompParam
GAP_Instance
GAP_KnapPisingerTypes and protos for combo algorithm API:
GAP_Knapsack
CbcGenCtlBlk::genParamsInfo_structStart and end of cbc-generic parameters in parameter vector
glp_prob
CbcGenCtlBlk::gomoryCtl_structControl variable and prototype for Gomory cut generator
CbcGenCtlBlk::greedyCoverCtl_structControl variable and prototype for greedy cover heuristic
CbcGenCtlBlk::greedyEqualityCtl_structControl variable and prototype for greedy equality heuristic
gubrow_actionDetect and remove entries whose sum is known
IdiotThis class implements a very silly algorithm
IdiotResultFor use internally
ilp
implied_free_actionDetect and process implied free variables
Info******** DATA to be moved into protected section of ClpInterior
info_weak
is_greater_thanD
is_less_thanD
isetset
isolated_constraint_action
itemrec
itemset
OsiCuts::iteratorIterator
KnapModel
KnapNodeDesc
KnapParams
CbcGenCtlBlk::knapsackCtl_structControl variable and prototype for knapsack cover cut generator
KnapSolution
KnapTreeNode
LAP::LandPMessagesMessage handler for lift-and-project simplex
LAP::LapMessagesOutput messages for Cgl
less_than_str
CbcGenCtlBlk::localTreeCtl_structControl variables for local tree
log_var
make_fixed_actionFix a variable at a specified bound
MCF_DecompApp
MCF_DecompParam
MCF_Instance
MCF_Param
MILP_DecompApp
MILP_Param
CbcGenCtlBlk::mirCtl_structControl variable and prototype for MIR cut generator
MMKP_DecompApp
MMKP_DecompParam
MMKP_Instance
MMKP_MCKnap
MMKP_MemPool
MMKP_Model
MMKP_Param
MMKPModel
myclass
myclass0
MyEventHandlerThis is so user can trap events and do useful stuff
MyMessageHandler
myPdcoThis implements a simple network matrix as derived from ClpMatrixBase
CglLandP::NoBasisError
Node
SDPUC_Instance::node
CbcGenCtlBlk::oddHoleCtl_structControl variable and prototype for odd hole cut generator
Options******** DATA to be moved into protected section of ClpInterior
ordintv
ordrec
ordstack
OsiAuxInfoThis class allows for a more structured use of algorithmic tweaking to an OsiSolverInterface
OsiBabSolverThis class allows for the use of more exotic solvers e.g
OsiBiLinearDefine BiLinear objects
OsiBiLinearBranchingObjectBranching object for BiLinear objects
OsiBiLinearEqualityDefine Continuous BiLinear objects for an == bound
OsiBranchingInformation
OsiBranchingObjectAbstract branching object base class
OsiCbcSolverInterfaceCbc Solver Interface
OsiChooseStrongThis class chooses a variable to branch on
OsiChooseStrongSubsetThis class chooses a variable to branch on
OsiChooseVariableThis class chooses a variable to branch on
OsiClpDisasterHandler
OsiClpSolverInterfaceClp Solver Interface
OsiColCutColumn Cut Class
OsiCpxSolverInterfaceCPLEX Solver Interface
OsiCut
OsiCuts::OsiCutCompare
OsiCutsCollections of row cuts and column cuts
OsiDataClass collecting pointers on data for OsiEmpty
OsiGlpkSolverInterface
OsiGrbSolverInterfaceGurobi Solver Interface
OsiHotInfoThis class contains the result of strong branching on a variable When created it stores enough information for strong branching
OsiIntegerBranchingObjectSimple branching object for an integer variable
OsiLinkDefine Special Linked Ordered Sets
OsiLinkBranchingObjectBranching object for Linked ordered sets
OsiLinkedBoundList of bounds which depend on other bounds
OsiLotsizeLotsize class
OsiLotsizeBranchingObjectLotsize branching object
OsiMskSolverInterface
OsiNullSolverInterface
OsiObjectAbstract base class for `objects'
OsiObject2Define a class to add a bit of complexity to OsiObject This assumes 2 way branching
OsiOldLink
OsiOldLinkBranchingObjectBranching object for Linked ordered sets
OsiOneLinkDefine data for one link
CbcGenCtlBlk::osiParamsInfo_structStart and end of OsiSolverInterface parameters in parameter vector
OsiPresolveOSI interface to COIN problem simplification capabilities
OsiPseudoCostsThis class is the placeholder for the pseudocosts used by OsiChooseStrong
OsiRowCutRow Cut Class
OsiRowCut2Row Cut Class which refers back to row which created it
OsiRowCutDebuggerValidate cuts against a known solution
OsiSimpleFixedIntegerDefine a single integer class - but one where you keep branching until fixed even if satisfied
OsiSimpleIntegerDefine a single integer class
OsiSolverBranchSolver Branch Class
OsiSolverInterfaceAbstract Base Class for describing an interface to a solver
OsiSolverLinearizedQuadraticThis is to allow the user to replace initialSolve and resolve
OsiSolverLinkThis is to allow the user to replace initialSolve and resolve This version changes coefficients
OsiSolverResultSolver Result Class
OsiSOSDefine Special Ordered Sets of type 1 and 2
OsiSOSBranchingObjectBranching object for Special ordered sets
OsiSpxSolverInterfaceSoPlex Solver Interface Instantiation of OsiSpxSolverInterface for SoPlex
OsiTestSolverInterfaceVol(ume) Solver Interface
OsiTwoWayBranchingObjectThis just adds two-wayness to a branching object
OsiUsesBiLinearDefine a single variable class which is involved with OsiBiLinear objects
OsiTestSolverInterface::OsiVolMatrixOneMinusOne_
OsiXprSolverInterfaceXPRESS-MP Solver Interface
Outfo******** DATA to be moved into protected section of ClpInterior
CglLandP::ParametersClass storing parameters
ClpSimplexOther::parametricsData
parity_ilp
partset
partvect
Perturb
AbcSimplexPrimal::pivotStruct
pool_cut
pool_cut_list
presolvehlinkLinks to aid in packed matrix modification
CbcHeuristicDive::PriorityTypeArray of priorities
CbcGenCtlBlk::probingCtl_structControl variable and prototype for probing cut generator
PseudoReducedCost
CbcGenCtlBlk::redSplitCtl_structControl variable and prototype for reduce-and-split cut generator
Coin::ReferencedObjectReferencedObject class
remove_dual_actionAttempt to fix variables by bounding reduced costs
remove_fixed_actionExcise fixed variables from the model
CbcGenCtlBlk::roundingCtl_structControl variable and prototype for simple rounding heuristic
scatterStruct
SDPUC_DecompApp
SDPUC_Instance
SDPUC_Param
select_cut
separation_graph
sg_label_writer< EdgeWeight >
sg_label_writer_vertex
short_path_node
SILCEP_Instance
CglLandP::SimplexInterfaceError
slack_doubleton_actionConvert an explicit bound constraint to a column bound
slack_singleton_actionFor variables with one entry
SmallIP_DecompApp
Coin::SmartPtr< T >Template class for Smart Pointers
solrec
solstruct
SOR_IntDblArrT
SOR_IntDblT
subst_constraint_actionDetect and process implied free variables
symrecFor string evaluation
LAP::TabRow
OsiUnitTest::TestOutcomeA single test outcome record
OsiUnitTest::TestOutcomesUtility class to maintain a list of test outcomes
SDPUC_Instance::timeseries
TotalWorkloadA functor class used in calulating total workload in a node pool
tripleton_actionWe are only going to do this if it does not increase number of elements?
TSP_Boost
TSP_Concorde
TSP_DecompApp
TSP_Instance
TSP_Param
TSP_SubtourCut
CbcGenCtlBlk::twomirCtl_structControl variable and prototype for Two-MIR cut generator
twoxtwo_actionDetect interesting 2 by 2 blocks
useless_constraint_action
UtilApp
UtilGraphLib
UtilIsGreaterThan< S, T >
UtilIsLessThan< S, T >
UtilParameters
UtilParamT
UtilTimer
LAP::ValidatorClass to validate or reject a cut
VOL_alpha_factor
VOL_dual
VOL_dvectorVector of doubles
VOL_indc
VOL_ivectorVector of ints
VOL_parmsThis class contains the parameters controlling the Volume Algorithm
VOL_primal
VOL_problemThis class holds every data for the Volume Algorithm and its solve method must be invoked to solve the problem
VOL_swing
VOL_user_hooksThe user hooks should be overridden by the user to provide the problem specific routines for the volume algorithm
VOL_vh
VRP_Boost
VRP_Concorde
VRP_CVRPsep
VRP_DecompApp
VRP_GSECCut
VRP_Instance
VRP_Param

Generated on 5 Apr 2015 for Dip-All by  doxygen 1.6.1