Bonmin::AmplInterface | Class for providing an Osi interface to Ipopt with an ampl nl file as input |
Bonmin::AmplTMINLP | Ampl MINLP Interface |
AslCouPair | |
Bonmin::AuxInfo | Bonmin class for passing info between components of branch-and-cuts |
Couenne::AuxRelation | Base class definition for relations between auxiliaries |
Bonmin::Bab | |
Bonmin::BabInfo | Bonmin class for passing info between components of branch-and-cuts |
Bonmin::BabSetupBase | A class to have all elements necessary to setup a branch-and-bound |
Bonmin::BabSetupBase::CuttingMethod | Type for cut generation method with its frequency and string identification |
Bonmin::BabSetupBase::HeuristicMethod | Type for heuristic method with its string identification |
Base64 | Use this class to read and write data in base64 |
BasisStatus | Data structure to represent an LP basis on both input and output |
BB_cut | Simple representation of a cut by storing non zero coefficients only |
BB_indexed_cut | When doing a sprint sort of algorithm on the cuts (i.e., leave out a number of cuts at the beginning and add them only as necessary) this object represents one of these cuts |
BB_init | |
BB_lp | Class for operations at the node level |
BB_packer | Class taking care of packing/unpacking |
BB_prob | Class holding data for describing the problem |
BB_tm | |
BCP_buffer | This class describes the message buffer used for all processes of BCP |
BCP_cg_par | Parameters used in the Cut Generator process |
BCP_cg_prob | This class is the central class of the Cut Generator process |
BCP_cg_user | Base class from which the user can derive a problem specific class to be used in the Cut Generator process |
BCP_col | This class holds a column in a compressed form |
BCP_cut | Abstract base class that defines members common to all types of cuts |
BCP_cut_algo | This is the class from which the user should derive her own algorithmic cuts |
BCP_cut_core | Core cuts are the cuts that always stay in the LP formulation |
BCP_cut_set | This class is just a collection of pointers to cuts with a number of methods to manipulate these cuts and/or select certain entries |
BCP_fatal_error | Currently there isn't any error handling in BCP |
BCP_internal_brobj | This class is the internal representation of a branching object |
BCP_lp_branching_object | This class describes a generic branching object |
BCP_lp_cut_pool | |
BCP_lp_integer_branching_object | This class exist only so that we can extract information from OsiIntegerBranchingObject |
BCP_lp_node | NO OLD DOC |
BCP_lp_par | Parameters used in the LP process |
BCP_lp_parent | NO OLD DOC |
BCP_lp_prob | NO OLD DOC |
BCP_lp_relax | An object of type BCP_lp_relax holds the description of an lp relaxation |
BCP_lp_result | This class holds the results after solving an LP relaxation |
BCP_lp_sos_branching_object | This class exist only so that we can extract information from OsiIntegerBranchingObject |
BCP_lp_statistics | NO OLD DOC |
BCP_lp_user | Base 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_environment | This is an abstract base class that describes the message passing environment |
BCP_node_change | |
BCP_node_storage_in_tm | NO OLD DOC |
BCP_obj_change | |
BCP_obj_set_change | This class stores data about how an object set (set of vars or set of cuts) changes |
BCP_parameter | This parameter indeintifies a single parameter entry |
BCP_parameter_set< Par > | This is the class serves as a holder for a set of parameters |
BCP_presolved_lp_brobj | A presolved branching object candidate |
BCP_problem_core | This class describes the core of the MIP problem, the variables/cuts in it as well as the matrix corresponding the core variables and cuts |
BCP_problem_core_change | This class describes changes in the core of the problem |
BCP_process | |
BCP_row | This class holds a row in a compressed form |
BCP_scheduler | |
BCP_single_environment | |
BCP_slave_params | NO OLD DOC |
BCP_solution | This is the abstract base class for a solution to a Mixed Integer Programming problem |
BCP_solution_generic | This class holds a MIP feasible primal solution |
BCP_string | This class is a very simple impelementation of a constant length string |
BCP_tm_flags | NO OLD DOC |
BCP_tm_node | |
BCP_tm_node_data | |
BCP_tm_node_to_send | |
BCP_tm_par | Parameters used in the Tree Manager process |
BCP_tm_prob | NO OLD DOC |
BCP_tm_stat | |
BCP_tm_user | Base class from which the user can derive a problem specific class to be used in the TM process |
BCP_tree | NO OLD DOC |
BCP_ts_node_data | Same as BCP_tm_node_data, just there's no need to use smart pointers in this process |
BCP_ts_par | |
BCP_ts_prob | |
BCP_ts_user | |
BCP_user_class | |
BCP_user_data | |
BCP_user_pack | |
BCP_var | Abstract base class that defines members common to all types of variables |
BCP_var_algo | This is the class from which the user should derive her own algorithmic variables |
BCP_var_core | Core variables are the variables that always stay in the LP formulation |
BCP_var_set | This class is just a collection of pointers to variables with a number of methods to manipulate these variables and/or select certain entries |
BCP_vec< 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_prob | This class is the central class of the Variable Generator process |
BCP_vg_user | Base class from which the user can derive a problem specific class to be used in the Cut Generator process |
BCP_warmstart | Warmstarting information for the LP solver |
BCP_warmstart_basis | This class describes a warmstart information that consists of basis information for structural and artificial variables |
BCP_warmstart_dual | This class describes a warmstart information that consists solely of the dual vector |
BCP_warmstart_primaldual | This class describes a warmstart information that consists solely of the dual vector |
Bigint | |
Couenne::BiProdDivRel | Identifies 5-tuple of the form |
BM_BranchData | |
BM_init | |
BM_lp | |
BM_node | |
BM_pack | |
BM_par | |
BM_SB_result | |
BM_stats | |
BM_tm | |
BMSearchTreeCompareBest | |
Bonmin::BonCbcFullNodeInfo | Holds information for recreating a subproblem by incremental change from the parent for Bonmin |
Bonmin::BonCbcPartialNodeInfo | Holds information for recreating a subproblem by incremental change from the parent for |
Bonmin::BonChooseVariable | This class chooses a variable to branch on |
Bonmin::BonChooseVariable::Messages | |
Bonmin::BonminAmplSetup | |
BonminProblem | |
Bonmin::BonminSetup | |
BonminSolver | Solves problems using Ipopt |
BonRandomChoice | |
bounds_opt_rlt_values | |
bounds_opt_values | |
Bonmin::BoundsReader | Reads a file containing change bounds for variables |
Bonmin::BqpdSolver | |
Bonmin::BqpdSolver::cachedInfo | Cached information for reoptimizing |
Bonmin::BqpdSolver::UnsolvedBqpdError | |
Bonmin::BqpdWarmStart | Warm start for filter interface |
Bonmin::BranchingTQP | This is an adapter class that converts a TMINLP2TNLP object into a TNLP, which is now just a QP |
BranchingWeight | BranchingWeight class |
bs | |
Bonmin::CbcDfsDiver | A more elaborate diving class |
Bonmin::CbcDiver | Class to do diving in the tree |
Bonmin::CbcNlpStrategy | |
Bonmin::CbcProbedDiver | Class to do probed diving in the tree |
Bonmin::CbcStrategyChooseCuts | A class to setup default strategy for Cbc specifying which cut generators to use |
cmpVar | |
CoinSolver | Implements a solve method for the Coin solvers |
Couenne::compareSol | Class for comparing solutions (used in tabu list) |
Couenne::compExpr | Structure for comparing expressions |
Couenne::compNode | Structure for comparing nodes in the dependence graph |
compVar | Structure for comparing variables |
Constraint | The in-memory representation of the <con> element |
ConstraintOption | ConstraintOption class |
Constraints | The in-memory representation of the <constraints> element |
ConstraintSolution | The ConstraintSolution Class |
ContactOption | ContactOption class |
Couenne::CouenneAggrProbing | Cut Generator for aggressive BT; i.e., an aggressive probing |
Couenne::CouenneAmplInterface | |
Couenne::CouenneBranchingObject | "Spatial" branching object |
Couenne::CouenneChooseStrong | |
Couenne::CouenneChooseVariable | Choose a variable for branching |
Couenne::CouenneComplBranchingObject | "Spatial" branching object for complementarity constraints |
Couenne::CouenneComplObject | OsiObject for complementarity constraints |
Couenne::CouenneConstraint | Class to represent nonlinear constraints |
Couenne::CouenneCrossConv | Cut Generator that uses relationships between auxiliaries |
Couenne::CouenneCutGenerator | Cut Generator for linear convexifications |
Couenne::CouenneDisjCuts | Cut Generator for linear convexifications |
Couenne::CouenneFeasPump | An implementation of the Feasibility pump that uses linearization and Ipopt to find the two sequences of points |
Couenne::CouenneFixPoint | Cut Generator for FBBT fixpoint |
Couenne::CouenneFPpool | Pool of solutions |
Couenne::CouenneFPsolution | Class containing a solution with infeasibility evaluation |
Couenne::CouenneInfo | Bonmin class for passing info between components of branch-and-cuts |
Couenne::CouenneInfo::NlpSolution | Class for storing an Nlp Solution |
Couenne::CouenneInterface | |
Couenne::CouenneIterativeRounding | |
Couenne::CouenneMINLPInterface | This 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::CouenneObject | OsiObject for auxiliary variables $w=f(x)$ |
Couenne::CouenneObjective | Objective function |
Couenne::CouenneOrbitBranchingObj | "Spatial" branching object |
Couenne::CouenneOSInterface | |
Couenne::CouenneProblem | Class for MINLP problems with symbolic information |
Couenne::CouenneRecordBestSol | |
Couenne::CouenneSetup | |
CouenneSolver | Solves 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::CouenneSparseMatrix | Class for sparse Matrixs (used in modifying distances in FP) |
Couenne::CouenneThreeWayBranchObj | Spatial, three-way branching object |
Couenne::CouenneTNLP | Class for handling NLPs using CouenneProblem |
Couenne::CouenneTwoImplied | Cut Generator for implied bounds derived from pairs of linear (in)equalities |
Couenne::CouenneUserInterface | |
Couenne::CouenneVarObject | OsiObject for variables in a MINLP |
Couenne::CouenneVTObject | OsiObject for violation transfer on variables in a MINLP |
Couenne::CouExpr | |
CPUNumber | CPUNumber class |
CPUSpeed | CPUSpeed class |
Bonmin::CurvatureEstimator | |
Bonmin::CurvBranchingSolver | Implementation of BonChooseVariable for curvature-based braching |
CutGen | |
Bonmin::Cuts | Generalizes OsiCuts to handle quadratic cuts |
Bonmin::CutStrengthener | Class for strengthening OA cuts, and generating additional ones |
Bonmin::CutStrengthener::StrengtheningTNLP | Class implementing the TNLP for strengthening one cut |
dataset | |
DefaultSolver | The Default Solver Class |
Couenne::DepGraph | Dependence graph |
Couenne::DepNode | Vertex of a dependence graph |
DirectoriesAndFiles | DirectoriesAndFiles class |
Bonmin::DiverCompare | |
Couenne::Domain | Define a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO structure |
Couenne::DomainPoint | Define a point in the solution space and the bounds around it |
DoubleVector | Double vector data structure |
DualVariableValues | The DualVariableValues Class |
DualVarValue | The DualVarValue Class |
Bonmin::DummyHeuristic | |
Bonmin::DummyPump | |
Bonmin::EcpCuts | |
ErrorClass | Used for throwing exceptions |
Couenne::exprAbs | Class for |
Couenne::exprAux | Auxiliary variable |
Couenne::exprBinProd | Class for with all binary |
Couenne::exprCeil | Class ceiling, |
Couenne::exprClone | Expression clone (points to another expression) |
Couenne::exprConst | Constant-type operator |
Couenne::exprCopy | |
Couenne::exprCos | Class cosine, |
Couenne::exprDiv | Class for divisions, |
Couenne::expression | Expression base class |
Couenne::exprExp | Class for the exponential, |
Couenne::exprFloor | Class floor, |
Couenne::exprGroup | Class Group, with constant, linear and nonlinear terms: |
Couenne::ExprHess | Expression matrices |
Couenne::exprIf | |
Couenne::exprInv | Class inverse: |
Couenne::exprIVar | Variable-type operator |
Couenne::ExprJac | Jacobian of the problem (computed through Couenne expression classes) |
Couenne::exprLBCos | Class to compute lower bound of a cosine based on the bounds of its arguments |
Couenne::exprLBDiv | Class to compute lower bound of a fraction based on the bounds of both numerator and denominator |
Couenne::exprLBMul | Class to compute lower bound of a product based on the bounds of both factors |
Couenne::exprLBQuad | Class to compute lower bound of a fraction based on the bounds of both numerator and denominator |
Couenne::exprLBSin | Class to compute lower bound of a sine based on the bounds on its arguments |
Couenne::exprLog | Class logarithm, |
Couenne::exprLowerBound | Lower bound |
Couenne::exprMax | Class for maxima |
Couenne::exprMin | Class for minima |
Couenne::exprMultiLin | Another class for multiplications, |
Couenne::exprNorm | Class for -norms, |
Couenne::exprOddPow | Power of an expression (binary operator), with constant |
Couenne::exprOp | General n-ary operator-type expression: requires argument list |
Couenne::exprOpp | Class opposite, |
Couenne::exprPow | Power of an expression (binary operator), with constant |
Couenne::exprPWLinear | |
Couenne::exprQuad | Class exprQuad, with constant, linear and quadratic terms |
Couenne::exprSin | Class for |
Couenne::exprStore | Storage class for previously evaluated expressions |
Couenne::exprSub | Class for subtraction, |
Couenne::exprSum | Class sum, |
Couenne::exprTrilinear | Class for multiplications |
Couenne::exprUBCos | Class to compute lower bound of a cosine based on the bounds of its arguments |
Couenne::exprUBDiv | Class to compute upper bound of a fraction based on the bounds of both numerator and denominator |
Couenne::exprUBMul | Class to compute upper bound of a product based on the bounds of both factors |
Couenne::exprUBQuad | Class to compute upper bound of a fraction based on the bounds of both numerator and denominator |
Couenne::exprUBSin | Class to compute lower bound of a sine based on the bounds on its arguments |
Couenne::exprUnary | Expression class for unary functions (sin, log, etc |
Couenne::exprUpperBound | Upper bound |
Couenne::exprVar | Variable-type operator |
FileUtil | Class used to make it easy to read and write files |
Bonmin::FilterSolver | |
Bonmin::FilterSolver::cachedInfo | Cached information for reoptimizing |
Bonmin::FilterSolver::UnsolvedFilterError | |
Bonmin::FilterWarmStart | Warm start for filter interface |
Bonmin::FilterWarmStartDiff | |
Bonmin::FixAndSolveHeuristic | |
Couenne::funtriplet | |
GeneralFileHeader | Data structure that holds general information about files that conform to one of the OSxL schemas |
GeneralOption | The GeneralOption Class |
GeneralResult | The GeneralResult Class |
GeneralStatus | The GeneralStatus Class |
GeneralSubstatus | The GeneralSubstatus Class |
Couenne::GlobalCutOff | |
GlobalReport | |
GlobalReportInstanceData | |
Bonmin::GuessHeuristic | |
Bonmin::HeuristicDive | |
Bonmin::HeuristicDiveFractional | |
Bonmin::HeuristicDiveMIP | |
Bonmin::HeuristicDiveMIPFractional | |
Bonmin::HeuristicDiveMIPVectorLength | |
Bonmin::HeuristicDiveVectorLength | |
Bonmin::HeuristicFPump | |
Bonmin::HeuristicInnerApproximation | |
Bonmin::HeuristicLocalBranching | |
Bonmin::HeuristicRINS | |
Heuristics | |
Bonmin::HotInfo | |
IndexStringPair | A commonly used structure holding an index-string pair This definition is based on the definition of IndexValuePair in OSGeneral.h |
IndexValuePair | A commonly used structure holding an index-value pair |
Couenne::indPosPair | |
InitBasStatus | InitBasStatus class |
InitConstraintValues | InitConstraintValues class |
InitConValue | InitConValue class |
InitDualVariableValues | InitDualVariableValues class |
InitDualVarValue | InitDualVarValue class |
Couenne::InitHeuristic | A heuristic that stores the initial solution of the NLP |
InitialBasisStatus | InitialBasisStatus class |
InitObjBound | InitObjBound class |
InitObjectiveBounds | InitObjectiveBounds class |
InitObjectiveValues | InitObjectiveValues class |
InitObjValue | InitObjValue class |
InitVariableValues | InitVariableValues class |
InitVariableValuesString | InitVariableValuesString class |
InitVarValue | InitVarValue class |
InitVarValueString | InitVarValueString class |
InstanceData | The in-memory representation of the <instanceData> element |
InstanceHeader | The in-memory representation of the <instanceHeader> element |
InstanceLocationOption | InstanceLocationOption class |
IntegerVariableBranchingWeights | IntegerVariableBranchingWeights class |
Interval | The in-memory representation of the <interval> element |
IntVector | Integer Vector data structure |
Bonmin::IpoptInteriorWarmStarter | |
IpoptProblem | |
Bonmin::IpoptSolver | |
IpoptSolver | Solves problems using Ipopt |
Bonmin::IpoptSolver::UnsolvedIpoptError | |
Bonmin::IpoptWarmStart | Class for storing warm start informations for Ipopt |
Bonmin::IpoptWarmStartDiff | Diff class for IpoptWarmStart |
JobDependencies | JobDependencies class |
JobOption | JobOption class |
JobResult | The JobResult Class |
KnitroProblem | |
KnitroSolver | KnitroSolver class solves problems using Knitro |
Couenne::kpowertriplet | |
LindoSolver | LindoSolver class solves problems using Lindo |
LinearConstraintCoefficients | The in-memory representation of the <linearConstraintCoefficients> element |
Bonmin::LinearCutsGenerator | |
Bonmin::LinearCutsGenerator::CuttingMethod | Type for cut generation method with its frequency and string identification |
Couenne::LinMap | |
Bonmin::LocalSolverBasedHeuristic | |
Bonmin::LpBranchingSolver | Implementation of BonChooseVariable for curvature-based braching |
Bonmin::MatComp | |
Bonmin::MatComp | |
MathUtil | This class has routines for linear algebra |
MaxTime | MaxTime 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_data::arc | |
MCF1_data::commodity | |
MCF1_init | |
MCF1_lp | |
MCF1_packer | |
MCF1_par | |
MCF1_tm | |
MCF1_var | |
MCF2_branch_decision | |
MCF2_branching_var | |
MCF2_data | |
MCF2_data::arc | |
MCF2_data::commodity | |
MCF2_init | |
MCF2_lp | |
MCF2_packer | |
MCF2_par | |
MCF2_tm | |
MCF2_var | |
MCF3_branch_decision | |
MCF3_data | |
MCF3_data::arc | |
MCF3_data::commodity | |
MCF3_init | |
MCF3_lp | |
MCF3_packer | |
MCF3_par | |
MCF3_tm | |
MCF3_user | |
MCF3_var | |
Bonmin::MilpRounding | |
MinCPUNumber | MinCPUNumber class |
MinCPUSpeed | MinCPUSpeed class |
MinDiskSpace | MinDiskSpace class |
Bonmin::MinlpFeasPump | |
MinMemorySize | MinMemorySize class |
Couenne::MultiProdRel | Identifies 5-ples of variables of the form |
MY_user_data | Class taking care of interaction between user data and Bcp |
myclass | |
myclass0 | |
MyTMINLP | A C++ example for interfacing an MINLP with bonmin |
Bonmin::NamesReader | A class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file) |
Bonmin::NamesReader::ltstr | String comparison strucutre |
Nauty | |
Nl | The in-memory representation of the <nl> element |
Couenne::NlpSolveHeuristic | |
Node | |
Bonmin::NonConvexSuff | To store all data stored in the nonconvex suffixes |
NonlinearExpressions | The in-memory representation of the <nonlinearExpressions> element |
Bonmin::OACutGenerator2 | Class to perform OA in its classical form |
Bonmin::OaDecompositionBase | Base class for OA algorithms |
Bonmin::OaDecompositionBase::Parameters | Parameters for algorithm |
Bonmin::OaDecompositionBase::solverManip | Small class to manipulatee various things in an OsiSolverInterface and restore them |
Bonmin::OaFeasibilityChecker | Class to perform OA in its classical form |
Bonmin::OaMessages | Output messages for Outer approximation cutting planes |
Bonmin::OaNlpOptim | Generate cuts for the nlp corresponding to continuous relaxation at a node |
ObjCoef | The in-memory representation of the objective function <coef> element |
Objective | The in-memory representation of the <obj> element |
ObjectiveOption | ObjectiveOption class |
Objectives | The in-memory representation of the <objectives> element |
ObjectiveSolution | The ObjectiveSolution Class |
ObjectiveValues | The ObjectiveValues Class |
ObjValue | The ObjValue Class |
OptimizationOption | OptimizationOption class |
OptimizationResult | The OptimizationResult Class |
OptimizationSolution | The OptimizationSolution Class |
OptimizationSolutionStatus | The OptimizationSolutionStatus Class |
OptimizationSolutionSubstatus | The OptimizationSolutionSubstatus Class |
Bonmin::optionsCmp | |
OS_cut | Simple representation of a cut by storing non zero coefficients only |
OS_DipInterface | |
OS_init | |
OS_lp | Class for operations at the node level |
OS_packer | Class taking care of packing/unpacking |
OS_prob | Class holding data for describing the problem |
OS_tm | |
OS_var | |
OSBearcatSolverXij | |
OSBearcatSolverXij::Factory | |
OSBearcatSolverXkij | |
OSBearcatSolverXkij::Factory | |
OSColGenApp | |
OSDecompFactoryInitializer | |
OSDecompParam | |
OSDecompSolver | |
OSDecompSolverFactory | |
OSDipApp | |
OSDipBlockBearcatSolver | |
OSDipBlockBearcatSolver::Factory | |
OSDipBlockCoinSolver | |
OSDipBlockCoinSolver::Factory | |
OSDipBlockSlpSolver | |
OSDipBlockSlpSolver::Factory | |
OSDipBlockSolver | |
OSDipBlockSolverFactory | |
OSDipFactoryInitializer | |
OSDipParam | |
OSExpressionTree | Used to hold the instance in memory |
OSgams2osil | Creating a OSInstance from a GAMS model given as GAMS Modeling Object (GMO) |
OSGeneral | |
OSgLParserData | The OSgLParserData Class |
OShL | An interface that specified virtual methods to be implemented by agents |
OSiLParserData | The OSiLParserData Class, used to store parser data |
OSiLReader | Used to read an OSiL string |
OSiLWriter | Take an OSInstance object and write a string that validates against the OSiL schema |
OSInstance | The in-memory representation of an OSiL instance. |
Bonmin::OsiTMINLPInterface | This 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) |
Bonmin::OsiTMINLPInterface::Messages | Messages outputed by an OsiTMINLPInterface |
Bonmin::OsiTMINLPInterface::SimpleError | Error class to throw exceptions from OsiTMINLPInterface |
OsiXxxSolverInterface | |
OSMatlab | The OSMatlab Class |
OSmps2osil | The OSmps2osil Class |
OSnl2osil | The OSnl2osil Class |
OSnLNode | The OSnLNode Class |
OSnLNodeAbs | The OSnLNodeAbs Class |
OSnLNodeAllDiff | The OSnLNodeAllDiff Class |
OSnLNodeCos | The OSnLNodeCos Class |
OSnLNodeDivide | The OSnLNodeDivide Class |
OSnLNodeE | The OSnLNodeE Class |
OSnLNodeErf | The OSnLNodeErf Class |
OSnLNodeExp | The OSnLNodeExp Class |
OSnLNodeIf | The OSnLNodeIf Class |
OSnLNodeLn | The OSnLNodeLn Class |
OSnLNodeMax | The OSnLNodeMax Class |
OSnLNodeMin | The OSnLNodeMin Class |
OSnLNodeMinus | The OSnLNodeMinus Class |
OSnLNodeNegate | The OSnLNodeNegate Class |
OSnLNodeNumber | The OSnLNodeNumber Class |
OSnLNodePI | The OSnLNodePI Class |
OSnLNodePlus | The OSnLNodePlus Class |
OSnLNodePower | The OSnLNodePower Class |
OSnLNodeProduct | The OSnLNodeProduct Class |
OSnLNodeSin | The OSnLNodeSin Class |
OSnLNodeSqrt | The OSnLNodeSqrt Class |
OSnLNodeSquare | The OSnLNodeSquare Class |
OSnLNodeSum | The OSnLNodeSum Class |
OSnLNodeTimes | The OSnLNodeTimes Class |
OSnLNodeVariable | The OSnLNodeVariable Class |
OSNode | |
OSoLParserData | The OSoLParserData Class |
OSoLReader | Used to read an OSoL string |
OSoLWriter | Take an OSOption object and write a string that validates against the OSoL schema |
OSOption | The Option Class |
osOptionsStruc | This structure is used to store options for the OSSolverService executable |
OSResult | The Result Class |
OSrL2Gams | Reads an optimization result and stores result and solution in a Gams Modeling Object |
OSrLParserData | The OSrLParserData Class |
OSrLReader | The OSrLReader Class |
OSrLWriter | Take an OSResult object and write a string that validates against OSrL |
OSSolverAgent | Used by a client to invoke a remote solver |
OtherConOption | OtherConOption class |
OtherConResult | The OtherConResult Class |
OtherConstraintOption | OtherConstraintOption class |
OtherConstraintResult | The OtherConstraintResult Class |
OtherObjectiveOption | OtherObjectiveOption class |
OtherObjectiveResult | The OtherObjectiveResult Class |
OtherObjOption | OtherObjOption class |
OtherObjResult | The OtherObjResult Class |
OtherOptimizationResult | The OtherOptimizationResult Class |
OtherOption | OtherOption class |
OtherOptionEnumeration | |
OtherOptions | OtherOptions class |
OtherResult | The OtherResult Class |
OtherResults | The OtherResults Class |
OtherSolutionResult | The OtherSolutionResult Class |
OtherSolutionResults | The OtherSolutionResults Class |
OtherSolverOutput | The OtherSolverOutput Class |
OtherVariableOption | OtherVariableOption class |
OtherVariableResult | The OtherVariableResult Class |
OtherVariableResultStruct | A structure to information about an OtherVariableResult element |
OtherVarOption | OtherVarOption class |
OtherVarResult | OtherVarResult Class |
Bonmin::OuterApprox | A class to build outer approximations |
PathPair | PathPair class |
PathPairs | PathPairs class |
Couenne::powertriplet | |
Couenne::PowRel | Identifies 5-tuple of the form |
Processes | Processes class |
Bonmin::PseudoCosts | |
Bonmin::PumpForMinlp | |
Bonmin::QpBranchingSolver | This class chooses a variable to branch on |
Couenne::Qroot | Class that stores result of previous calls to rootQ into a map for faster access |
Bonmin::QuadCut | |
Couenne::quadElem | |
Couenne::QuadMap | |
QuadraticCoefficients | The in-memory representation of the <quadraticCoefficients> element |
QuadraticCuts | |
QuadraticTerm | The in-memory representation of the <qTerm> element |
QuadraticTerms | Data structure for holding quadratic terms |
Bonmin::QuadRow | Stores a quadratic row of the form l < c + ax + x^T Q x < u |
real_user_data | Class handling user data |
Bonmin::RegisteredOptions | Class to add a few more information to Ipopt::RegisteredOptions |
Report | |
Bonmin::RoundingFPump | |
Bonmin::score_sorter | |
Bonmin::SepaSetup | Algorithm setup |
ServiceOption | ServiceOption class |
ServiceResult | The ServiceResult Class |
Bonmin::SimpleReferenced< X > | |
Bonmin::SimpleReferencedPtr< X > | |
Couenne::simpletriplet | |
Couenne::SmartAsl | |
Bonmin::SolReader | A class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file) |
solutions | |
SolverOption | SolverOption class |
SolverOptions | SolverOptions class |
SolverOutput | The SolverOutput Class |
SOSVariableBranchingWeights | SOSVariableBranchingWeights class |
SOSWeights | SOSWeights class |
SparseHessianMatrix | The in-memory representation of a SparseHessianMatrix. |
SparseJacobianMatrix | Sparse Jacobian matrix data structure |
SparseMatrix | Sparse matrix data structure |
SparseVector | Sparse vector data structure |
sparsify_trace | |
Bonmin::StartPointReader | This class reads a file with a starting point for Ipopt initalization |
Stat | |
StorageCapacity | StorageCapacity class |
Bonmin::StrongBranchingSolver | This class is the base class for a solver that can be used in BonOsiSolverInterface to perform the strong branching solves |
Bonmin::SubMipSolver | A very simple class to provide a common interface for solving MIPs with Cplex and Cbc |
Couenne::SumLogAuxRel | Identifies 5-ples of variables of the form |
SystemOption | SystemOption class |
SystemResult | The SystemResult Class |
Couenne::t_chg_bounds | Status of lower/upper bound of a variable, to be checked/modified in bound tightening |
Couenne::threshold | |
Time | The Time Class |
TimeDomain | The in-memory representation of the <timeDomain> element |
TimeDomainInterval | |
TimeDomainStage | The in-memory representation of the <stage> element |
TimeDomainStageCon | The in-memory representation of the <con> element |
TimeDomainStageConstraints | The in-memory representation of the <constraints> child of the <stage> element |
TimeDomainStageObj | The in-memory representation of the <obj> element |
TimeDomainStageObjectives | The in-memory representation of the <objectives> child of the <stage> element |
TimeDomainStages | The in-memory representation of the <stages> element |
TimeDomainStageVar | The in-memory representation of the element |
TimeDomainStageVariables | The in-memory representation of the <variables> child of the <stage> element |
TimeMeasurement | The TimeMeasurement Class |
Timer | |
TimeSpan | TimeSpan class |
TimingInformation | The TimingInformation Class |
Bonmin::TMat | |
Bonmin::TMat::ColumnOrder | Structure for ordering matrix by columns |
Bonmin::TMat::RowOrder | Structure for ordering matrix by columns |
Bonmin::TMat::TMatOrdering | Structure for ordering matrix |
Bonmin::TMINLP | Base class for all MINLPs that use a standard triplet matrix form and dense vectors |
Bonmin::TMINLP2TNLP | This is an adapter class that converts a TMINLP to a TNLP to be solved by Ipopt |
Bonmin::TMINLP2TNLPQuadCuts | This is a derived class fro TMINLP2TNLP to handle adding quadratic cuts |
Bonmin::TMINLP::BranchingInfo | Stores branching priorities information |
Bonmin::TMINLP::MarkedNonConvex | Structure for marked non-convex constraints |
Bonmin::TMINLP::PerturbInfo | Class to store perturbation radii for variables in the model |
Bonmin::TMINLP::SimpleConcaveConstraint | Structure which describes a constraints of the form $f[ y F(x) ] with a concave function |
Bonmin::TMINLP::SosInfo | Class to store sos constraints for model |
Bonmin::TMINLPLinObj | From a TMINLP, this class adapts to another TMINLP where the original objective is transformed into a constraint by adding an extra variable which is minimized |
Bonmin::TNLP2FPNLP | This is an adapter class to convert an NLP to a Feasibility Pump NLP by changing the objective function to the (2-norm) distance to a point |
Bonmin::TNLPSolver | This is a generic class for calling an NLP solver to solve a TNLP |
Bonmin::TNLPSolver::UnsolvedError | We will throw this error when a problem is not solved |
Tracer | |
U | |
USER_initialize | This class is an abstract base class for the initializer class the user has to provide |
Variable | The in-memory representation of the variable element |
VariableOption | VariableOption class |
Variables | The in-memory representation of the variables element |
VariableSolution | The VariableSolution Class |
VariableStringValues | The VariableStringValues Class |
VariableValues | The VariableValues Class |
VariableValuesString | The VariableValuesString Class |
VarStringValue | VarStringValue Class |
VarValue | VarValue Class |
VarValueString | VarValueString Class |
Bonmin::vector< T > | A small wrap around std::vector to give easy access to array for interfacing with fortran code |
vector | |
WSUtil | Used by OSSolverAgent client for help in invoking a remote solver. |
yy_buffer_state | |
yy_trans_info | |
yyalloc | |
yyguts_t | |
YYLTYPE | |
YYSTYPE | |