Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
MCF1_data::arc
MCF2_data::arc
MCF3_data::arc
AslCouPair
Couenne::AuxRelationBase class definition for relations between auxiliaries
Base64Use this class to read and write data in base64
BasisStatusData structure to represent an LP basis on both input and output
BB_cutSimple representation of a cut by storing non zero coefficients only
BB_indexed_cutWhen doing a sprint sort of algorithm on the cuts (i.e., leave out a number of cuts at the beginning and add them only as necessary) this object represents one of these cuts
BB_init
BB_lpClass for operations at the node level
BB_packerClass taking care of packing/unpacking
BB_probClass holding data for describing the problem
BB_tm
BCP_bufferThis class describes the message buffer used for all processes of BCP
BCP_cg_parParameters used in the Cut Generator process
BCP_cg_probThis class is the central class of the Cut Generator process
BCP_cg_userBase class from which the user can derive a problem specific class to be used in the Cut Generator process
BCP_colThis class holds a column in a compressed form
BCP_cutAbstract base class that defines members common to all types of cuts
BCP_cut_algoThis is the class from which the user should derive her own algorithmic cuts
BCP_cut_coreCore cuts are the cuts that always stay in the LP formulation
BCP_cut_setThis class is just a collection of pointers to cuts with a number of methods to manipulate these cuts and/or select certain entries
BCP_fatal_errorCurrently there isn't any error handling in BCP
BCP_internal_brobjThis class is the internal representation of a branching object
BCP_lp_branching_objectThis class describes a generic branching object
BCP_lp_cut_pool
BCP_lp_integer_branching_objectThis class exist only so that we can extract information from OsiIntegerBranchingObject
BCP_lp_nodeNO OLD DOC
BCP_lp_parParameters used in the LP process
BCP_lp_parentNO OLD DOC
BCP_lp_probNO OLD DOC
BCP_lp_relaxAn object of type BCP_lp_relax holds the description of an lp relaxation
BCP_lp_resultThis class holds the results after solving an LP relaxation
BCP_lp_sos_branching_objectThis class exist only so that we can extract information from OsiIntegerBranchingObject
BCP_lp_statisticsNO OLD DOC
BCP_lp_userBase class from which the user can derive a problem specific class to be used in the LP process
BCP_lp_var_pool
BCP_lp_waiting_col
BCP_lp_waiting_row
BCP_MemPool
BCP_message_environmentThis is an abstract base class that describes the message passing environment
BCP_node_change
BCP_node_storage_in_tmNO OLD DOC
BCP_obj_change
BCP_obj_set_changeThis class stores data about how an object set (set of vars or set of cuts) changes
BCP_parameterThis parameter indeintifies a single parameter entry
BCP_parameter_set< Par >This is the class serves as a holder for a set of parameters
BCP_presolved_lp_brobjA presolved branching object candidate
BCP_problem_coreThis class describes the core of the MIP problem, the variables/cuts in it as well as the matrix corresponding the core variables and cuts
BCP_problem_core_changeThis class describes changes in the core of the problem
BCP_process
BCP_rowThis class holds a row in a compressed form
BCP_scheduler
BCP_single_environment
BCP_slave_paramsNO OLD DOC
BCP_solutionThis is the abstract base class for a solution to a Mixed Integer Programming problem
BCP_solution_genericThis class holds a MIP feasible primal solution
BCP_stringThis class is a very simple impelementation of a constant length string
BCP_tm_flagsNO OLD DOC
BCP_tm_node
BCP_tm_node_data
BCP_tm_node_to_send
BCP_tm_parParameters used in the Tree Manager process
BCP_tm_probNO OLD DOC
BCP_tm_stat
BCP_tm_userBase class from which the user can derive a problem specific class to be used in the TM process
BCP_treeNO OLD DOC
BCP_ts_node_dataSame as BCP_tm_node_data, just there's no need to use smart pointers in this process
BCP_ts_par
BCP_ts_prob
BCP_ts_user
BCP_user_class
BCP_user_data
BCP_user_pack
BCP_varAbstract base class that defines members common to all types of variables
BCP_var_algoThis is the class from which the user should derive her own algorithmic variables
BCP_var_coreCore variables are the variables that always stay in the LP formulation
BCP_var_setThis class is just a collection of pointers to variables with a number of methods to manipulate these variables and/or select certain entries
BCP_vec< T >The class BCP_vec serves the same purpose as the vector class in the standard template library
BCP_vec_change< T >This class stores a vector explicitly or relatively to another vector
BCP_vg_par
BCP_vg_probThis class is the central class of the Variable Generator process
BCP_vg_userBase class from which the user can derive a problem specific class to be used in the Cut Generator process
BCP_warmstartWarmstarting information for the LP solver
BCP_warmstart_basisThis class describes a warmstart information that consists of basis information for structural and artificial variables
BCP_warmstart_dualThis class describes a warmstart information that consists solely of the dual vector
BCP_warmstart_primaldualThis class describes a warmstart information that consists solely of the dual vector
Bigint
Couenne::BiProdDivRelIdentifies 5-tuple of the form
BonminProblem
BonminSolverSolves problems using Ipopt
bounds_opt_rlt_values
bounds_opt_values
BranchingWeightBranchingWeight class
bs
cmpVar
CoinSolverImplements a solve method for the Coin solvers
MCF2_data::commodity
MCF3_data::commodity
MCF1_data::commodity
Couenne::compareSolClass for comparing solutions (used in tabu list)
Couenne::compExprStructure for comparing expressions
Couenne::compNodeStructure for comparing nodes in the dependence graph
compVarStructure for comparing variables
ConstraintThe in-memory representation of the <con> element
ConstraintOptionConstraintOption class
ConstraintsThe in-memory representation of the <constraints> element
ConstraintSolutionThe ConstraintSolution Class
ContactOptionContactOption class
Couenne::CouenneAggrProbingCut Generator for aggressive BT; i.e., an aggressive probing
Couenne::CouenneAmplInterface
Couenne::CouenneBab
Couenne::CouenneBranchingObject"Spatial" branching object
Couenne::CouenneChooseStrong
Couenne::CouenneChooseVariableChoose a variable for branching
Couenne::CouenneComplBranchingObject"Spatial" branching object for complementarity constraints
Couenne::CouenneComplObjectOsiObject for complementarity constraints $ x_1 x_2 \ge,\le,= 0 $
Couenne::CouenneConstraintClass to represent nonlinear constraints
Couenne::CouenneCrossConvCut Generator that uses relationships between auxiliaries
Couenne::CouenneCutGeneratorCut Generator for linear convexifications
Couenne::CouenneDisjCutsCut Generator for linear convexifications
Couenne::CouenneFeasPumpAn implementation of the Feasibility pump that uses linearization and Ipopt to find the two sequences of points
Couenne::CouenneFixPointCut Generator for FBBT fixpoint
Couenne::CouenneFPpoolPool of solutions
Couenne::CouenneFPsolutionClass containing a solution with infeasibility evaluation
Couenne::CouenneInfoBonmin class for passing info between components of branch-and-cuts
Couenne::CouenneInterface
Couenne::CouenneIterativeRounding
Couenne::CouenneMINLPInterfaceThis is class provides an Osi interface for a Mixed Integer Linear Program expressed as a TMINLP (so that we can use it for example as the continuous solver in Cbc)
Couenne::CouenneMultiVarProbe
Couenne::CouenneObjectOsiObject for auxiliary variables $w=f(x)$
Couenne::CouenneObjectiveObjective function
Couenne::CouenneOrbitBranchingObj"Spatial" branching object
Couenne::CouenneOSInterface
Couenne::CouenneProblemClass for MINLP problems with symbolic information
Couenne::CouenneRecordBestSol
Couenne::CouenneSetup
CouenneSolverSolves problems using Ipopt
Couenne::CouenneSolverInterface< T >Solver interface class with a pointer to a Couenne cut generator
Couenne::CouenneSOSBranchingObject
Couenne::CouenneSOSObject
Couenne::CouenneSparseBndVec< T >
Couenne::CouenneSparseMatrixClass for sparse Matrixs (used in modifying distances in FP)
Couenne::CouenneThreeWayBranchObjSpatial, three-way branching object
Couenne::CouenneTNLPClass for handling NLPs using CouenneProblem
Couenne::CouenneTwoImpliedCut Generator for implied bounds derived from pairs of linear (in)equalities
Couenne::CouenneUserInterface
Couenne::CouenneVarObjectOsiObject for variables in a MINLP
Couenne::CouenneVTObjectOsiObject for violation transfer on variables in a MINLP
Couenne::CouExpr
CPUNumberCPUNumber class
CPUSpeedCPUSpeed class
CutGen
dataset
DefaultSolverThe Default Solver Class
Couenne::DepGraphDependence graph
Couenne::DepNodeVertex of a dependence graph
DirectoriesAndFilesDirectoriesAndFiles class
Couenne::DomainDefine a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO structure
Couenne::DomainPointDefine a point in the solution space and the bounds around it
DoubleVectorDouble vector data structure
DualVariableValuesThe DualVariableValues Class
DualVarValueThe DualVarValue Class
ErrorClassUsed for throwing exceptions
Couenne::exprAbsClass for $ |f(x)| $
Couenne::exprAuxAuxiliary variable
Couenne::exprBinProdClass for $ \prod_{i=1}^n f_i(x) $ with $ f_i(x) $ all binary
Couenne::exprCeilClass ceiling, $ \lceil f(x) \rceil $
Couenne::exprCloneExpression clone (points to another expression)
Couenne::exprConstConstant-type operator
Couenne::exprCopy
Couenne::exprCosClass cosine, $ \cos f(x) $
Couenne::exprDivClass for divisions, $ \frac{f(x)}{g(x)} $
Couenne::expressionExpression base class
Couenne::exprExpClass for the exponential, $ e^{f(x)} $
Couenne::exprFloorClass floor, $ \lfloor f(x) \rfloor $
Couenne::exprGroupClass Group, with constant, linear and nonlinear terms: $ a_0 + \sum_{i=1}^n a_i x_i $
Couenne::ExprHessExpression matrices
Couenne::exprIf
Couenne::exprInvClass inverse: $ 1/f(x) $
Couenne::exprIVarVariable-type operator
Couenne::ExprJacJacobian of the problem (computed through Couenne expression classes)
Couenne::exprLBCosClass to compute lower bound of a cosine based on the bounds of its arguments
Couenne::exprLBDivClass to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprLBMulClass to compute lower bound of a product based on the bounds of both factors
Couenne::exprLBQuadClass to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprLBSinClass to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprLogClass logarithm, $ \log f(x)$
Couenne::exprLowerBoundThese are bound expression classes
Couenne::exprMaxClass for maxima
Couenne::exprMinClass for minima
Couenne::exprMultiLinAnother class for multiplications, $ \prod_{i=1}^n f_i(x) $
Couenne::exprNormClass for $ p $-norms, $ || f(x)||_p = \left(\sum_{i=1}^n f_i(x)^p\right)^{\frac{1}{p}} $
Couenne::exprOddPowPower of an expression (binary operator), $ f(x)^k$ with $ k$ constant
Couenne::exprOpGeneral n-ary operator-type expression: requires argument list
Couenne::exprOppClass opposite, $ -f(x) $
Couenne::exprPowPower of an expression (binary operator), $ f(x)^k$ with $ k$ constant
Couenne::exprPWLinear
Couenne::exprQuadClass exprQuad, with constant, linear and quadratic terms
Couenne::exprSinClass for $ \sin f(x)$
Couenne::exprStoreStorage class for previously evaluated expressions
Couenne::exprSubClass for subtraction, $ f(x) - g(x) $
Couenne::exprSumClass sum, $ \sum_{i=1}^n f_i(x) $
Couenne::exprTrilinearClass for multiplications
Couenne::exprUBCosClass to compute lower bound of a cosine based on the bounds of its arguments
Couenne::exprUBDivClass to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUBMulClass to compute upper bound of a product based on the bounds of both factors
Couenne::exprUBQuadClass to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUBSinClass to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprUnaryExpression class for unary functions (sin, log, etc
Couenne::exprUpperBoundUpper bound
Couenne::exprVarVariable-type operator
OSDipBlockBearcatSolver::Factory
OSDipBlockCoinSolver::Factory
OSDipBlockSlpSolver::Factory
OSBearcatSolverXij::Factory
OSBearcatSolverXkij::Factory
FileUtilClass used to make it easy to read and write files
Couenne::funtriplet
GeneralFileHeaderData structure that holds general information about files that conform to one of the OSxL schemas
GeneralOptionThe GeneralOption Class
GeneralResultThe GeneralResult Class
GeneralStatusThe GeneralStatus Class
GeneralSubstatusThe GeneralSubstatus Class
Couenne::GlobalCutOff
GlobalReport
GlobalReportInstanceData
Heuristics
IndexStringPairA commonly used structure holding an index-string pair This definition is based on the definition of IndexValuePair in OSGeneral.h
IndexValuePairA commonly used structure holding an index-value pair
Couenne::indPosPair
InitBasStatusInitBasStatus class
InitConstraintValuesInitConstraintValues class
InitConValueInitConValue class
InitDualVariableValuesInitDualVariableValues class
InitDualVarValueInitDualVarValue class
Couenne::InitHeuristicA heuristic that stores the initial solution of the NLP
InitialBasisStatusInitialBasisStatus class
InitObjBoundInitObjBound class
InitObjectiveBoundsInitObjectiveBounds class
InitObjectiveValuesInitObjectiveValues class
InitObjValueInitObjValue class
InitVariableValuesInitVariableValues class
InitVariableValuesStringInitVariableValuesString class
InitVarValueInitVarValue class
InitVarValueStringInitVarValueString class
InstanceDataThe in-memory representation of the <instanceData> element
InstanceHeaderThe in-memory representation of the <instanceHeader> element
InstanceLocationOptionInstanceLocationOption class
IntegerVariableBranchingWeightsIntegerVariableBranchingWeights class
IntervalThe in-memory representation of the <interval> element
IntVectorInteger Vector data structure
IpoptProblem
IpoptSolverSolves problems using Ipopt
JobDependenciesJobDependencies class
JobOptionJobOption class
JobResultThe JobResult Class
KnitroProblem
KnitroSolverKnitroSolver class solves problems using Knitro
Couenne::kpowertriplet
LindoSolverLindoSolver class solves problems using Lindo
LinearConstraintCoefficientsThe in-memory representation of the <linearConstraintCoefficients> element
Couenne::LinMap
MathUtilThis class has routines for linear algebra
MaxTimeMaxTime class
MC_adjacency_entry
MC_cycle_cut
MC_explicit_dense_cut
MC_feas_sol
MC_graph_edge
MC_graph_node
MC_initialize
MC_lp
MC_lp_par
MC_packer
MC_path_adj_entry
MC_path_node
MC_path_node_ptr_compare
MC_problem
MC_solution
MC_switch_structure
MC_tm
MC_tm_par
MCF1_branch_decision
MCF1_branching_var
MCF1_data
MCF1_init
MCF1_lp
MCF1_packer
MCF1_par
MCF1_tm
MCF1_var
MCF2_branch_decision
MCF2_branching_var
MCF2_data
MCF2_init
MCF2_lp
MCF2_packer
MCF2_par
MCF2_tm
MCF2_var
MCF3_branch_decision
MCF3_data
MCF3_init
MCF3_lp
MCF3_packer
MCF3_par
MCF3_tm
MCF3_user
MCF3_var
MinCPUNumberMinCPUNumber class
MinCPUSpeedMinCPUSpeed class
MinDiskSpaceMinDiskSpace class
MinMemorySizeMinMemorySize class
Couenne::MultiProdRelIdentifies 5-ples of variables of the form
MY_user_dataClass taking care of interaction between user data and Bcp
myclass
myclass0
Nauty
NlThe in-memory representation of the <nl> element
Couenne::CouenneInfo::NlpSolutionClass for storing an Nlp Solution
Couenne::NlpSolveHeuristic
Node
NonlinearExpressionsThe in-memory representation of the <nonlinearExpressions> element
ObjCoefThe in-memory representation of the objective function <coef> element
ObjectiveThe in-memory representation of the <obj> element
ObjectiveOptionObjectiveOption class
ObjectivesThe in-memory representation of the <objectives> element
ObjectiveSolutionThe ObjectiveSolution Class
ObjectiveValuesThe ObjectiveValues Class
ObjValueThe ObjValue Class
OptimizationOptionOptimizationOption class
OptimizationResultThe OptimizationResult Class
OptimizationSolutionThe OptimizationSolution Class
OptimizationSolutionStatusThe OptimizationSolutionStatus Class
OptimizationSolutionSubstatusThe OptimizationSolutionSubstatus Class
OS_cutSimple representation of a cut by storing non zero coefficients only
OS_DipInterface
OS_init
OS_lpClass for operations at the node level
OS_packerClass taking care of packing/unpacking
OS_probClass holding data for describing the problem
OS_tm
OS_var
OSBearcatSolverXij
OSBearcatSolverXkij
OSColGenApp
OSCommandLineThis class is used to store command line options for the OSSolverService executable and to provide methods to manipulate them
OSCommandLineReaderThe OSCommandLineReader Class
OSDecompFactoryInitializer
OSDecompParam
OSDecompSolver
OSDecompSolverFactory
OSDipApp
OSDipBlockBearcatSolver
OSDipBlockCoinSolver
OSDipBlockSlpSolver
OSDipBlockSolver
OSDipBlockSolverFactory
OSDipFactoryInitializer
OSDipParam
OSExpressionTreeUsed to hold the instance in memory
OSgams2osilCreating a OSInstance from a GAMS model given as GAMS Modeling Object (GMO)
OSGeneral
OSgLParserDataThe OSgLParserData Class
OShLAn interface that specified virtual methods to be implemented by agents
OSiLParserDataThe OSiLParserData Class, used to store parser data
OSiLReaderUsed to read an OSiL string
OSiLWriterTake an OSInstance object and write a string that validates against the OSiL schema
OSInstanceThe in-memory representation of an OSiL instance.
OsiXxxSolverInterface
OSMatlabThe OSMatlab Class
OSmps2osilThe OSmps2osil Class
OSnl2osilThe OSnl2osil Class
OSnLNodeThe OSnLNode Class
OSnLNodeAbsThe OSnLNodeAbs Class
OSnLNodeAllDiffThe OSnLNodeAllDiff Class
OSnLNodeCosThe OSnLNodeCos Class
OSnLNodeDivideThe OSnLNodeDivide Class
OSnLNodeEThe OSnLNodeE Class
OSnLNodeErfThe OSnLNodeErf Class
OSnLNodeExpThe OSnLNodeExp Class
OSnLNodeIfThe OSnLNodeIf Class
OSnLNodeLnThe OSnLNodeLn Class
OSnLNodeMaxThe OSnLNodeMax Class
OSnLNodeMinThe OSnLNodeMin Class
OSnLNodeMinusThe OSnLNodeMinus Class
OSnLNodeNegateThe OSnLNodeNegate Class
OSnLNodeNumberThe OSnLNodeNumber Class
OSnLNodePIThe OSnLNodePI Class
OSnLNodePlusThe OSnLNodePlus Class
OSnLNodePowerThe OSnLNodePower Class
OSnLNodeProductThe OSnLNodeProduct Class
OSnLNodeSinThe OSnLNodeSin Class
OSnLNodeSqrtThe OSnLNodeSqrt Class
OSnLNodeSquareThe OSnLNodeSquare Class
OSnLNodeSumThe OSnLNodeSum Class
OSnLNodeTimesThe OSnLNodeTimes Class
OSnLNodeVariableThe OSnLNodeVariable Class
OSNode
OSoLParserDataThe OSoLParserData Class
OSoLReaderUsed to read an OSoL string
OSoLWriterTake an OSOption object and write a string that validates against the OSoL schema
OSOptionThe Option Class
osOptionsStrucThis structure is used to store options for the OSSolverService executable
OSResultThe Result Class
OSrL2GamsReads an optimization result and stores result and solution in a Gams Modeling Object
OSrLParserDataThe OSrLParserData Class
OSrLReaderThe OSrLReader Class
OSrLWriterTake an OSResult object and write a string that validates against OSrL
OSServiceMethodsThis class implements wrappers for the different service methods. By exposing the API these methods can be used by the OSAmplClient and OSSolverService executable as well as other third-party programs
OSSolverAgentUsed by a client to invoke a remote solver
OtherConOptionOtherConOption class
OtherConResultThe OtherConResult Class
OtherConstraintOptionOtherConstraintOption class
OtherConstraintResultThe OtherConstraintResult Class
OtherObjectiveOptionOtherObjectiveOption class
OtherObjectiveResultThe OtherObjectiveResult Class
OtherObjOptionOtherObjOption class
OtherObjResultThe OtherObjResult Class
OtherOptimizationResultThe OtherOptimizationResult Class
OtherOptionOtherOption class
OtherOptionEnumeration
OtherOptionsOtherOptions class
OtherResultThe OtherResult Class
OtherResultsThe OtherResults Class
OtherSolutionResultThe OtherSolutionResult Class
OtherSolutionResultsThe OtherSolutionResults Class
OtherSolverOutputThe OtherSolverOutput Class
OtherVariableOptionOtherVariableOption class
OtherVariableResultThe OtherVariableResult Class
OtherVariableResultStructA structure to information about an OtherVariableResult element
OtherVarOptionOtherVarOption class
OtherVarResultOtherVarResult Class
PathPairPathPair class
PathPairsPathPairs class
Couenne::powertriplet
Couenne::PowRelIdentifies 5-tuple of the form
ProcessesProcesses class
Couenne::QrootClass that stores result of previous calls to rootQ into a map for faster access
Couenne::quadElem
Couenne::QuadMap
QuadraticCoefficientsThe in-memory representation of the <quadraticCoefficients> element
QuadraticCuts
QuadraticTermThe in-memory representation of the <qTerm> element
QuadraticTermsData structure for holding quadratic terms
real_user_dataClass handling user data
Report
ServiceOptionServiceOption class
ServiceResultThe ServiceResult Class
Couenne::simpletriplet
Couenne::SmartAsl
solutions
SolverOptionSolverOption class
SolverOptionsSolverOptions class
SolverOutputThe SolverOutput Class
SOSVariableBranchingWeightsSOSVariableBranchingWeights class
SOSWeightsSOSWeights class
SparseHessianMatrixThe in-memory representation of a SparseHessianMatrix.
SparseJacobianMatrixSparse Jacobian matrix data structure
SparseMatrixSparse matrix data structure
SparseVectorSparse vector data structure
sparsify_trace
Stat
StorageCapacityStorageCapacity class
Couenne::SumLogAuxRelIdentifies 5-ples of variables of the form
SystemOptionSystemOption class
SystemResultThe SystemResult Class
Couenne::t_chg_boundsStatus of lower/upper bound of a variable, to be checked/modified in bound tightening
Couenne::threshold
TimeThe Time Class
TimeDomainThe in-memory representation of the <timeDomain> element
TimeDomainInterval
TimeDomainStageThe in-memory representation of the <stage> element
TimeDomainStageConThe in-memory representation of the <con> element
TimeDomainStageConstraintsThe in-memory representation of the <constraints> child of the <stage> element
TimeDomainStageObjThe in-memory representation of the <obj> element
TimeDomainStageObjectivesThe in-memory representation of the <objectives> child of the <stage> element
TimeDomainStagesThe in-memory representation of the <stages> element
TimeDomainStageVarThe in-memory representation of the element
TimeDomainStageVariablesThe in-memory representation of the <variables> child of the <stage> element
TimeMeasurementThe TimeMeasurement Class
Timer
TimeSpanTimeSpan class
TimingInformationThe TimingInformation Class
Tracer
U
USER_initializeThis class is an abstract base class for the initializer class the user has to provide
VariableThe in-memory representation of the variable element
VariableOptionVariableOption class
VariablesThe in-memory representation of the variables element
VariableSolutionThe VariableSolution Class
VariableStringValuesThe VariableStringValues Class
VariableValuesThe VariableValues Class
VariableValuesStringThe VariableValuesString Class
VarStringValueVarStringValue Class
VarValueVarValue Class
VarValueStringVarValueString Class
WSUtilUsed by OSSolverAgent client for help in invoking a remote solver.
yy_buffer_state
yy_trans_info
yyalloc
yyguts_t
YYLTYPE
YYSTYPE

Generated on 22 May 2012 by  doxygen 1.6.1