Bonmin::AmplInterface | Class for providing an Osi interface to Ipopt with an ampl nl file as input |
Bonmin::AmplTMINLP | Ampl MINLP Interface |
MCF2_data::arc | |
MCF1_data::arc | |
MCF3_data::arc | |
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 |
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::BonminAmplSetup | |
BonminProblem | |
Bonmin::BonminSetup | |
BonminSolver | Solves problems using Ipopt |
Bonmin::BonNWayBranchingObject | N way branching Object class |
Bonmin::BonNWayChoose | This class chooses a variable to branch on |
Bonmin::BonNWayObject | |
BonRandomChoice | |
bounds_opt_rlt_values | |
bounds_opt_values | |
Bonmin::BoundsReader | Reads a file containing change bounds for variables |
Bonmin::BqpdSolver | |
Bonmin::BqpdWarmStart | Warm start for filter interface |
Bonmin::TMINLP::BranchingInfo | Stores branching priorities information |
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::BqpdSolver::cachedInfo | Cached information for reoptimizing |
Bonmin::FilterSolver::cachedInfo | Cached information for reoptimizing |
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 |
Bonmin::TMat::ColumnOrder | Structure for ordering matrix by columns |
MCF2_data::commodity | |
MCF3_data::commodity | |
MCF1_data::commodity | |
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::CouenneBab | |
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::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::BabSetupBase::CuttingMethod | Type for cut generation method with its frequency and string identification |
Bonmin::LinearCutsGenerator::CuttingMethod | Type for cut generation method with its frequency and string identification |
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 | These are bound expression classes |
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 |
OSBearcatSolverXij::Factory | |
OSBearcatSolverXkij::Factory | |
FileUtil | Class used to make it easy to read and write files |
Bonmin::FilterSolver | |
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 | |
Sepa::HeuristicInnerApproximation | |
Bonmin::HeuristicLocalBranching | |
Bonmin::BabSetupBase::HeuristicMethod | Type for heuristic method with its string identification |
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::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 | |
Couenne::LinMap | |
Bonmin::LocalSolverBasedHeuristic | |
Bonmin::LpBranchingSolver | Implementation of BonChooseVariable for curvature-based braching |
Bonmin::NamesReader::ltstr | String comparison strucutre |
Bonmin::TMINLP::MarkedNonConvex | Structure for marked non-convex constraints |
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_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 | |
Bonmin::BonChooseVariable::Messages | |
Bonmin::OsiTMINLPInterface::Messages | Messages written by an OsiTMINLPInterface |
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::n_way_consequences | |
Bonmin::NamesReader | A class for reading a .col or .row file containing name for variables and constraints (usually ampl generated file) |
Nauty | |
Nl | The in-memory representation of the <nl> element |
Couenne::CouenneInfo::NlpSolution | Class for storing an Nlp Solution |
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::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_AMPL_SUFFIX | |
OSBearcatSolverXij | |
OSBearcatSolverXkij | |
OSColGenApp | |
OSCommandLine | This class is used to store command line options for the OSSolverService executable and to provide methods to manipulate them |
OSCommandLineReader | The OSCommandLineReader Class |
OSDecompFactoryInitializer | |
OSDecompParam | |
OSDecompSolver | |
OSDecompSolverFactory | |
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) |
OsiXxxSolverInterface | |
OSMatlab | The OSMatlab Class |
OSmps2osil | The OSmps2osil Class |
OSnl2OS | The OSnl2OS 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 |
OSosrl2ampl | The OSosrl2ampl Class |
OSOutput | This class handles all the output from OSSolverService, OSAmplClient and other executables derived from them. Every output statement in the code uses methods in this class, passing information about the area that originated the request as well as the print, verbosity or severity level of the message. The message creates output only if the print level matches the user specifications. The main advantage of doing things this way is that multiple output streams can be maintained, each tailored to a specific need and containing only output that the user really wants to see. There can be as many output streams as needed; each one has an identifying name ("stdout" and "stderr" are reserved names) and an array of print levels, one for each area. The class is implemented as a Singleton, which means that two private methods must be defined in the header but must *never* be implemented: a copy constructor, and an equality operator |
OSOutputChannel | Class that holds information about one output channel (file, device, stream, peripheral, etc.) |
OSReferencedObject | ReferencedObject class |
OSReferencer | Pseudo-class, from which everything has to inherit that wants to use be registered as a Referencer for a ReferencedObject |
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 |
OSSmartPtr< T > | Template class for Smart Pointers |
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 |
Bonmin::OaDecompositionBase::Parameters | Parameters for algorithm |
PathPair | PathPair class |
PathPairs | PathPairs class |
Bonmin::TMINLP::PerturbInfo | Class to store perturbation radii for variables in the model |
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::RobotSetup | Algorithm setup |
Bonmin::RoundingFPump | |
Bonmin::TMat::RowOrder | Structure for ordering matrix by columns |
Bonmin::score_sorter | |
Sepa::SepaSetup | Algorithm setup |
Sepa::SepaTMINLP2OsiLP | A transformer class to build outer approximations i.e |
ServiceOption | ServiceOption class |
ServiceResult | The ServiceResult Class |
Bonmin::TMINLP::SimpleConcaveConstraint | Structure which describes a constraints of the form $f[ y F(x) ] with a concave function |
Bonmin::OsiTMINLPInterface::SimpleError | Error class to throw exceptions from OsiTMINLPInterface |
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 | |
Bonmin::OaDecompositionBase::solverManip | Small class to manipulatee various things in an OsiSolverInterface and restore them |
SolverOption | SolverOption class |
SolverOptions | SolverOptions class |
SolverOutput | The SolverOutput Class |
Bonmin::TMINLP::SosInfo | Class to store sos constraints for model |
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::CutStrengthener::StrengtheningTNLP | Class implementing the TNLP for strengthening one cut |
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::TMatOrdering | Structure for ordering matrix |
Bonmin::TMINLP | Base class for all MINLPs that use a standard triplet matrix form and dense vectors |
Bonmin::TMINLP2OsiLP | A transformer class to build outer approximations i.e |
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::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 |
Tracer | |
U | |
Bonmin::BqpdSolver::UnsolvedBqpdError | |
Bonmin::TNLPSolver::UnsolvedError | We will throw this error when a problem is not solved |
Bonmin::FilterSolver::UnsolvedFilterError | |
Bonmin::IpoptSolver::UnsolvedIpoptError | |
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 | |