| _NODE | |
| AbcBranchDecision | Abstract branching decision base class |
| AbcBranchDefaultDecision | Branching decision default class |
| AbcCutGenerator | Interface between Abc and Cut Generation Library |
| AbcHeuristic | Heuristic base class |
| AbcMessage | |
| AbcModel | Model class for ALPS Branch and Cut |
| AbcNodeDesc | |
| AbcParams | |
| AbcPseudocost | |
| AbcRounding | Rounding class |
| AbcSolution | This class holds a MIP feasible primal solution |
| AbcTreeNode | |
| duprow_action::action | |
| drop_empty_cols_action::action | |
| drop_empty_rows_action::action | |
| remove_fixed_action::action | Structure to hold information necessary to reintroduce a column into the problem representation |
| make_fixed_action::action | Structure to preserve the bound overwritten when fixing a variable |
| forcing_constraint_action::action | |
| implied_free_action::action | |
| slack_doubleton_action::action | |
| slack_singleton_action::action | |
| subst_constraint_action::action | |
| do_tighten_action::action | |
| tripleton_action::action | |
| useless_constraint_action::action | |
| doubleton_action::action | |
| dupcol_action::action | |
| CppAD::AD< Base > | |
| Ipopt::AdaptiveMuUpdate | Non-monotone mu update |
| CppAD::ADDiscrete< Base > | |
| CppAD::ADFun< Base > | |
| CppAD::ADTape< Base > | |
| Ipopt::AlgorithmBuilder | Builder to create a complete IpoptAlg object |
| Ipopt::AlgorithmStrategyObject | This is the base class for all algorithm strategy objects |
| ALPS_PS_STATS | |
| AlpsEncoded | This data structure is to contain the packed form of an encodable knowledge |
| AlpsKnowledge | The abstract base class of any user-defined class that Alps has to know about in order to encode/decode |
| AlpsKnowledgeBroker | The base class of knowledge broker class |
| AlpsKnowledgeBrokerMPI | |
| AlpsKnowledgeBrokerSerial | |
| AlpsKnowledgePool | |
| AlpsMessage | |
| AlpsModel | |
| AlpsNodeDesc | A class to refer to the description of a search tree node |
| AlpsNodePool | Node pool is used to store the nodes to be processed |
| AlpsNodeSelection | |
| AlpsNodeSelectionBest | |
| AlpsNodeSelectionBreadth | |
| AlpsNodeSelectionDepth | |
| AlpsNodeSelectionEstimate | |
| AlpsNodeSelectionHybrid | |
| AlpsParameter | This parameter indeintifies a single parameter entry |
| AlpsParameterSet | This is the class serves as a holder for a set of parameters |
| AlpsParams | |
| AlpsPriorityQueue< T > | |
| AlpsSolution | |
| AlpsSolutionPool | In the solution pool we assume that the lower the priority value the more desirable the solution is |
| AlpsStrLess | A function object to perform lexicographic lexicographic comparison between two C style strings |
| AlpsSubTree | This class contains the data pertaining to a particular subtree in the search tree |
| AlpsSubTreePool | The subtree pool is used to store subtrees |
| AlpsTimer | |
| AlpsTreeNode | This class holds one node of the search tree |
| AlpsTreeSelection | |
| AlpsTreeSelectionBest | |
| AlpsTreeSelectionBreadth | |
| AlpsTreeSelectionDepth | |
| AlpsTreeSelectionEstimate | |
| ampl_info | |
| Ipopt::AmplOptionsList::AmplOption | Ampl Option class, contains name, type and description for an AMPL option |
| Ipopt::AmplOptionsList | Class for storing a number of AMPL options that should be registered to the AMPL Solver library interface |
| Ipopt::AmplSuffixHandler | |
| Ipopt::AmplTNLP | Ampl Interface |
| OsiSolverInterface::ApplyCutsReturnCode | Internal class for obtaining status from the applyCuts method |
| MCF2_data::arc | |
| MCF3_data::arc | |
| MCF1_data::arc | |
| Array< Type > | |
| ARRAY_DESC | |
| ArrayOfMatrices | |
| Ipopt::AugRestoSystemSolver | Class that converts the an augmented system with compound restoration pieces into a smaller "pivoted" system to be solved with an existing AugSystemSolver |
| CbcGenCtlBlk::babState_struct | State of branch-and-cut |
| Ipopt::BacktrackingLineSearch | General implementation of a backtracking line search |
| Ipopt::BacktrackingLSAcceptor | Base class for backtracking line search acceptors |
| Base64 | Use this class to read and write data in base64 |
| BASE_DESC | |
| BASIS_DESC | |
| BB_cut | Simple representation of a cut by storing non zero coefficients only |
| BB_init | |
| BB_lp | Class for operations at the node level |
| BB_prob | Class holding data for describing the problem |
| BB_tm | |
| BC_NODE | |
| 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_indexed | Implementation-wise indexed cuts differ from core cuts only in having a user given index |
| 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_cut_set_change | |
| BCP_fatal_error | Currently there isn't any error handling in BCP |
| BCP_indexed_pricing_list | |
| 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_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_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_queue | |
| BCP_node_storage_in_tm | NO OLD DOC |
| BCP_obj_change | |
| 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_proc_array | This class holds an array of processes |
| BCP_proc_id | This is an abstract base class that holds the identifier of a process |
| BCP_process | |
| BCP_row | This class holds a row in a compressed form |
| BCP_single_environment | |
| BCP_single_id | |
| BCP_slave_params | NO OLD DOC |
| BCP_slave_processes | 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 | LITTLE OLD DESC |
| BCP_tm_par | Parameters used in the Tree Manager process |
| BCP_tm_prob | NO OLD DOC |
| 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_user_data | |
| 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_indexed | Implementation-wise indexed variables differ from core variables only in having a user given index |
| 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_var_set_change | |
| 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 |
| BcpsBranchObject | BcpsBranchObject contains the member data required when choosing branching entities and excuting actual branching |
| BcpsBranchStrategy | Branching strategy specifies: (1) how to select a candidate set of branching objects (2) how to compare two branching objects |
| BcpsConstraint | |
| BcpsConstraintPool | |
| BcpsFieldListMod< T > | This class contains modifications for a single std::vector<T> object |
| BcpsMessage | |
| BcpsModel | |
| BcpsNodeDesc | For a given type, the objectVecStorage_ structure holds the description |
| BcpsObject | A class for describing the objects that comprise a BCPS subproblem |
| BcpsObjectListMod | Here is the set of vectorMod_ objects that represent the list of objects of a particular type (either in relative or explicit form) |
| BcpsObjectPool | Object pool is used to store objects |
| BcpsSolution | This class holds the solution objects |
| BcpsSubTree | This class is the data structure for storing a subtree within BCPS |
| BcpsTreeNode | This class contain the data for a BCPS search tree node |
| BcpsVariable | |
| BcpsVariablePool | |
| BEST_TOURS | |
| BitVector128 | |
| BlisBranchObjectInt | |
| BlisBranchStrategyMaxInf | This class implements maximum infeasibility branching |
| BlisBranchStrategyPseudo | Blis branching strategy default class This class implements a simple default algorithm, betterBranchObject(), for choosing a branching variable |
| BlisBranchStrategyRel | Blis branching strategy default class This class implements a simple default algorithm, betterBranchObject(), for choosing a branching variable |
| BlisBranchStrategyStrong | Blis branching strategy default class This class implements a simple default algorithm, betterBranchObject(), for choosing a branching variable |
| BlisConGenerator | Interface between Blis and Cut Generation Library |
| BlisConstraint | |
| BlisHeuristic | Heuristic base class |
| BlisHeurRound | Rounding Heuristic |
| BlisMessage | |
| BlisModel | |
| BlisNodeDesc | |
| BlisObjectInt | |
| BlisParams | |
| BlisPresolve | A interface to Osi/Coin Presolve |
| BlisPseudocost | |
| BlisSolution | This class contains the solutions generated by the LP solver (either primal or dual |
| BlisStrong | |
| BlisTreeNode | This is the class in which we are finally able to concretely define the bounding procedure |
| BlisVariable | |
| blockStruct | |
| flopc::Boolean_base | |
| OsiLinkedBound::boundElementAction | |
| BRANCH_DESC | |
| BRANCH_OBJ | |
| ClpNode::branchState | |
| BUF_FIFO | |
| CglLandP::CachedData | Some informations that will be changed by the pivots and that we want to keep |
| Ipopt::CachedResults< T > | Cache Priority Enum |
| CbcBranchAllDifferent | Define 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 |
| CbcBranchCut | Define a cut branching class |
| CbcBranchDecision | Abstract branching decision base class |
| CbcBranchDefaultDecision | Branching decision default class |
| CbcBranchDynamicDecision | Branching decision dynamic class |
| CbcBranchingObject | Abstract branching object base class Now just difference with OsiBranchingObject |
| CbcBranchToFixLots | Define a branch class that branches so that one way variables are fixed while the other way cuts off that solution |
| CbcBranchUserDecision | Branching decision user class |
| CbcCbcParam | Class for control parameters that act on a CbcModel object |
| CbcChooseVariable | |
| CbcClique | Define a clique class |
| CbcCliqueBranchingObject | Branching object for unordered cliques |
| CbcCompare | |
| CbcCompareBase | |
| CbcCompareDefault | |
| CbcCompareDepth | |
| CbcCompareEstimate | |
| CbcCompareObjective | |
| CbcCompareUser | |
| CbcConsequence | Abstract base class for consequent bounds |
| CbcCountRowCut | OsiRowCut augmented with bookkeeping |
| CbcCutBranchingObject | Cut branching object |
| CbcCutGenerator | Interface between Cbc and Cut Generation Library |
| CbcCutModifier | Abstract cut modifier base class |
| CbcCutSubsetModifier | Simple cut modifier base class |
| CbcDummyBranchingObject | Dummy branching object |
| CbcDynamicPseudoCostBranchingObject | Simple branching object for an integer variable with pseudo costs |
| CbcEventHandler | Base class for Cbc event handling |
| CbcFathom | Fathom base class |
| CbcFathomDynamicProgramming | FathomDynamicProgramming class |
| CbcFeasibilityBase | |
| CbcFixingBranchingObject | General Branching Object class |
| CbcFixVariable | Class for consequent bounds |
| CbcFollowOn | Define a follow on class |
| CbcFollowOn2 | Define a follow on class |
| CbcFullNodeInfo | Holds complete information for recreating a subproblem |
| CbcGenCtlBlk | |
| CbcGenParam | Class for cbc-generic control parameters |
| CbcHeuristic | Heuristic base class |
| CbcHeuristicDive | Dive class |
| CbcHeuristicDiveCoefficient | DiveCoefficient class |
| CbcHeuristicDiveFractional | DiveFractional class |
| CbcHeuristicDiveGuided | DiveGuided class |
| CbcHeuristicDiveVectorLength | DiveVectorLength class |
| CbcHeuristicDynamic3 | Heuristic - just picks up any good solution |
| CbcHeuristicFPump | Rounding class |
| CbcHeuristicGreedyCover | Greedy heuristic classes |
| CbcHeuristicGreedyEquality | |
| CbcHeuristicLocal | LocalSearch class |
| CbcHeuristicNode | A class describing the branching decisions that were made to get to the node where a heuristics was invoked from |
| CbcHeuristicNodeList | |
| CbcHeuristicPartial | Partial solution class If user knows a partial solution this tries to get an integer solution it uses hotstart information |
| CbcHeuristicRENS | LocalSearch class |
| CbcHeuristicRINS | LocalSearch class |
| CbcIntegerBranchingObject | Simple branching object for an integer variable |
| CbcIntegerPseudoCostBranchingObject | Simple branching object for an integer variable with pseudo costs |
| CbcLink | Define Special Linked Ordered Sets |
| CbcLinkBranchingObject | Branching object for Special ordered sets |
| CbcLongCliqueBranchingObject | Unordered Clique Branching Object class |
| CbcLotsize | Lotsize class |
| CbcLotsizeBranchingObject | Lotsize branching object |
| CbcMessage | |
| CbcModel | Simple Branch and bound class |
| CbcNewTree | |
| CbcNode | Information required while the node is live |
| CbcNodeInfo | Information required to recreate the subproblem at this node |
| CbcNWay | Define an n-way class for variables |
| CbcNWayBranchingObject | N way branching Object class |
| CbcObject | |
| CbcObjectUpdateData | |
| CbcOrClpParam | Very simple class for setting parameters |
| CbcOsiParam | Class for control parameters that act on a OsiSolverInterface object |
| CbcOsiSolver | This is for codes where solver needs to know about CbcModel |
| CbcParam | Very simple class for setting parameters |
| CbcGenCtlBlk::cbcParamsInfo_struct | Start and end of CbcModel parameters in parameter vector |
| CbcPartialNodeInfo | Holds information for recreating a subproblem by incremental change from the parent |
| CbcRounding | Rounding class |
| CbcSerendipity | Heuristic - just picks up any good solution found by solver - see OsiBabSolver |
| CbcSimpleInteger | Define a single integer class |
| CbcSimpleIntegerDynamicPseudoCost | Define a single integer class but with dynamic pseudo costs |
| CbcSimpleIntegerFixed | Define a single integer class where branching is forced until fixed |
| CbcSimpleIntegerPseudoCost | Define a single integer class but with pseudo costs |
| CbcSolver | This allows the use of the standalone solver in a flexible manner It has an original OsiClpSolverInterface and CbcModel which it can use repeatedly e.g |
| CbcSolver2 | This is to allow the user to replace initialSolve and resolve |
| CbcSolver3 | This is to allow the user to replace initialSolve and resolve |
| CbcSolverLongThin | This is to allow the user to replace initialSolve and resolve |
| CbcSolverUsefulData | Structure to hold useful arrays |
| CbcSOS | Define Special Ordered Sets of type 1 and 2 |
| CbcSOSBranchingObject | Branching object for Special ordered sets |
| CbcStatistics | For gathering statistics |
| CbcStopNow | This allows the use of a call back class to decide whether to stop |
| CbcStrategy | Strategy base class |
| CbcStrategyDefault | Default class |
| CbcStrategyDefaultSubTree | Default class for sub trees |
| CbcStrategyNull | Null class |
| CbcStrongInfo | Abstract base class for `objects' |
| CbcTree | |
| CbcTreeLocal | |
| CbcUser | This allows the use of an unknown user stuff including modeling languages |
| CG_CNRP_SPEC | |
| CG_PARAMS | |
| CG_PROB | |
| CG_USER_PARAMS | |
| CGL_PARAMS | |
| CglAllDifferent | AllDifferent Cut Generator Class This has a number of sets |
| CglClique | |
| CglCutGenerator | Cut Generator Base Class |
| CglDuplicateRow | DuplicateRow Cut Generator Class |
| CglFakeClique | This works on a fake solver i.e. invented rows |
| CglFlowCover | Lifed Simple Generalized Flow Cover Cut Generator Class |
| CglFlowVUB | Varibale upper bound class |
| CglGomory | Gomory Cut Generator Class |
| CglKnapsackCover | Knapsack Cover Cut Generator Class |
| CglLandP | |
| LAP::CglLandPSimplex | |
| CglLiftAndProject | Lift And Project Cut Generator Class |
| CglMessage | This deals with Cgl messages (as against Osi messages etc) |
| CglMixedIntegerRounding | Mixed Integer Rounding Cut Generator Class |
| CglMixedIntegerRounding2 | Mixed Integer Rounding Cut Generator Class |
| CglMixIntRoundVUB | |
| CglMixIntRoundVUB2 | |
| CglOddHole | Odd Hole Cut Generator Class |
| CglParam | Class collecting parameters for all cut generators |
| CglPreProcess | Class for preProcessing and postProcessing |
| CglProbing | Probing Cut Generator Class |
| CglRedSplit | Gomory Reduce-and-Split Cut Generator Class; See method generateCuts() |
| CglRedSplitParam | Class collecting parameters the Reduced-and-split cut generator |
| CglResidualCapacity | Residual Capacity Inequalities Cut Generator Class |
| CglSimpleRounding | Simple Rounding Cut Generator Class
|
| CglStored | Stored Cut Generator Class |
| CglTemporary | Stored Temporary Cut Generator Class - destroyed after first use |
| CglTreeInfo | Information about where the cut generator is invoked from |
| CglTreeProbingInfo | |
| CglTwomir | Twostep MIR Cut Generator Class |
| CglValidator | Constants describing rejection codes |
| Ipopt::CGPenaltyCq | Class for all Chen-Goldfarb penalty method specific calculated quantities |
| Ipopt::CGPenaltyData | Class to organize all the additional data required by the Chen-Goldfarb penalty function algorithm |
| Ipopt::CGPenaltyLSAcceptor | Line search acceptor, based on the Chen-Goldfarb penalty function approach |
| Ipopt::CGPerturbationHandler | Class for handling the perturbation factors delta_x, delta_s, delta_c, and delta_d in the primal dual system |
| Ipopt::CGSearchDirCalculator | Implementation of the search direction calculator that computes the Chen-Goldfarb step for the current barrier and penalty parameter |
| CbcGenCtlBlk::chooseStrongCtl_struct | Control variables for a strong branching method |
| CbcGenCtlBlk::cliqueCtl_struct | Control variable and prototype for clique cut generator |
| CglProbing::cliqueEntry | Entries for clique |
| CglProbing::cliqueType | Clique type |
| CLOSENODE | |
| ClpAmplObjective | Ampl Objective Class |
| ClpCholeskyBase | Base class for Clp Cholesky factorization Will do better factorization |
| ClpCholeskyDense | Dense class for Clp Cholesky factorization |
| ClpCholeskyTaucs | Taucs class for Clp Cholesky factorization |
| ClpCholeskyUfl | Ufl class for Clp Cholesky factorization |
| ClpCholeskyWssmp | Wssmp class for Clp Cholesky factorization |
| ClpCholeskyWssmpKKT | WssmpKKT class for Clp Cholesky factorization |
| ClpConstraint | Constraint Abstract Base Class |
| ClpConstraintAmpl | Ampl Constraint Class |
| ClpConstraintLinear | Linear Constraint Class |
| ClpConstraintQuadratic | Quadratic Constraint Class |
| ClpDataSave | This is a tiny class where data can be saved round calls |
| ClpDisasterHandler | Base class for Clp disaster handling |
| ClpDualRowDantzig | Dual Row Pivot Dantzig Algorithm Class |
| ClpDualRowPivot | Dual Row Pivot Abstract Base Class |
| ClpDualRowSteepest | Dual Row Pivot Steepest Edge Algorithm Class |
| ClpDummyMatrix | This implements a dummy matrix as derived from ClpMatrixBase |
| ClpDynamicExampleMatrix | This implements a dynamic matrix when we have a limit on the number of "interesting rows" |
| ClpDynamicMatrix | This implements a dynamic matrix when we have a limit on the number of "interesting rows" |
| ClpEventHandler | Base class for Clp event handling |
| ClpFactorization | This just implements CoinFactorization when an ClpMatrixBase object is passed |
| ClpGubDynamicMatrix | This implements Gub rows plus a ClpPackedMatrix |
| ClpGubMatrix | This implements Gub rows plus a ClpPackedMatrix |
| ClpInterior | This solves LPs using interior point methods |
| ClpLinearObjective | Linear Objective Class |
| ClpLsqr | This class implements LSQR |
| ClpMatrixBase | Abstract base class for Clp Matrices |
| ClpMessage | This deals with Clp messages (as against Osi messages etc) |
| ClpModel | |
| ClpNetworkBasis | This deals with Factorization and Updates for network structures |
| ClpNetworkMatrix | This implements a simple network matrix as derived from ClpMatrixBase |
| ClpNode | |
| ClpNodeStuff | |
| ClpNonLinearCost | |
| ClpObjective | Objective Abstract Base Class |
| ClpPackedMatrix | |
| ClpPackedMatrix2 | |
| ClpPackedMatrix3 | |
| ClpPdco | This solves problems in Primal Dual Convex Optimization |
| ClpPdcoBase | Abstract base class for tailoring everything for Pcdo |
| ClpPlusMinusOneMatrix | This implements a simple +- one matrix as derived from ClpMatrixBase |
| ClpPredictorCorrector | This solves LPs using the predictor-corrector method due to Mehrotra |
| ClpPresolve | This is the Clp interface to CoinPresolve |
| ClpPrimalColumnDantzig | Primal Column Pivot Dantzig Algorithm Class |
| ClpPrimalColumnPivot | Primal Column Pivot Abstract Base Class |
| ClpPrimalColumnSteepest | Primal Column Pivot Steepest Edge Algorithm Class |
| ClpPrimalQuadraticDantzig | Primal Column Pivot Dantzig Algorithm Class |
| ClpQuadInterface | This is to allow the user to replace initialSolve and resolve |
| ClpQuadraticObjective | Quadratic Objective Class |
| ClpSimplex | This solves LPs using the simplex method |
| ClpSimplexDual | This solves LPs using the dual simplex method |
| ClpSimplexNonlinear | This solves non-linear LPs using the primal simplex method |
| ClpSimplexOther | This is for Simplex stuff which is neither dual nor primal |
| ClpSimplexPrimal | This solves LPs using the primal simplex method |
| ClpSimplexProgress | For saving extra information to see if looping |
| ClpSolve | This is a very simple class to guide algorithms |
| Cname | |
| CNRP_DG | |
| CNRP_LP_PARAMS | |
| CNRP_PARAMS | |
| CNRP_PROBLEM | |
| CNRP_SPEC | |
| CNRP_SPEC_CP | |
| flopc::MP::Coef | |
| flopc::MP::CoefLess | |
| CoinAbsFltEq | Equality to an absolute tolerance |
| CoinArrayWithLength | Pointer with length in bytes |
| CoinBigIndexArrayWithLength | CoinBigIndex * version |
| CoinBuild | In many cases it is natural to build a model by adding one row at a time |
| CoinDenseFactorization | This deals with Factorization and Updates This is a simple dense version so other people can write a better one |
| CoinDenseVector< T > | Dense Vector |
| CoinDoubleArrayWithLength | Double * version |
| CoinError | Error 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 |
| CoinFactorization | This deals with Factorization and Updates |
| CoinFileInput | Abstract base class for file input classes |
| CoinFileIOBase | Base class for FileIO classes |
| CoinFileOutput | Abstract base class for file output classes |
| CoinFirstAbsGreater_2< S, T > | Function operator |
| CoinFirstAbsGreater_3< S, T, U > | Function operator |
| CoinFirstAbsLess_2< S, T > | Function operator |
| CoinFirstAbsLess_3< S, T, U > | Function operator |
| CoinFirstGreater_2< S, T > | Function operator |
| CoinFirstGreater_3< S, T, U > | Function operator |
| CoinFirstLess_2< S, T > | Function operator |
| CoinFirstLess_3< S, T, U > | Function operator |
| CoinLpIO::CoinHashLink | |
| CoinMpsIO::CoinHashLink | |
| CoinIndexedVector | Indexed Vector |
| CoinIntArrayWithLength | Int * version |
| CoinLpIO | Class to read and write Lp files |
| CoinMessage | The standard set of Coin messages |
| CoinMessageHandler | Base class for message handling |
| CoinMessages | Class to hold and manipulate an array of massaged messages |
| CoinModel | This is a simple minded model which is stored in a format which makes it easier to construct and modify but not efficient for algorithms |
| CoinModelHash | |
| CoinModelHash2 | For int,int hashing |
| CoinModelHashLink | For names and hashing |
| CoinModelLink | This is for various structures/classes needed by CoinModel |
| CoinModelLinkedList | |
| CoinModelTriple | For linked lists |
| CoinMpsCardReader | Very simple code for reading MPS data |
| CoinMpsIO | MPS IO Interface |
| CoinOneMessage | Class for one massaged message |
| CoinSnapshot::coinOwned | To say whether arrays etc are owned by CoinSnapshot |
| CoinPackedMatrix | Sparse Matrix Base Class |
| CoinPackedVector | Sparse Vector |
| CoinPackedVectorBase | Abstract base class for various sparse vectors |
| CoinPair< S, T > | An ordered pair |
| CoinParam | A base class for `keyword value' command line parameters |
| CoinPostsolveMatrix | Augments CoinPrePostsolveMatrix with information about the problem that is only needed during postsolve |
| CoinPrePostsolveMatrix | Collects all the information about the problem that is needed in both presolve and postsolve |
| CoinPresolveAction | Abstract base class of all presolve routines |
| CoinPresolveMatrix | Augments CoinPrePostsolveMatrix with information about the problem that is only needed during presolve |
| CoinRelFltEq | Equality to a scaled tolerance |
| CoinSearchTree< Comp > | |
| CoinSearchTreeBase | |
| CoinSearchTreeCompareBest | Best first search |
| CoinSearchTreeCompareBreadth | |
| CoinSearchTreeCompareDepth | Depth First Search |
| CoinSearchTreeComparePreferred | Function objects to compare search tree nodes |
| CoinSearchTreeManager | |
| CoinSet | Very simple class for containing data on set |
| CoinShallowPackedVector | Shallow Sparse Vector |
| CoinSnapshot | NON Abstract Base Class for interfacing with cut generators or branching code or |
| CoinSolver | Implements a solve method for the Coin solvers |
| CoinSosSet | Very simple class for containing SOS set |
| CoinThreadRandom | Class for thread specific random numbers |
| CoinTimer | This class implements a timer that also implements a tracing functionality |
| CoinTreeNode | A class from which the real tree nodes should be derived from |
| CoinTreeSiblings | |
| CoinTriple< S, T, U > | |
| CoinUnsignedIntArrayWithLength | Unsigned int * version |
| CoinWarmStart | Abstract base class for warm start information |
| CoinWarmStartBasis | The default COIN simplex (basis-oriented) warm start class |
| CoinWarmStartBasisDiff | A `diff' between two CoinWarmStartBasis objects |
| CoinWarmStartDiff | Abstract base class for warm start `diff' objects |
| CoinWarmStartDual | WarmStart information that is only a dual vector |
| CoinWarmStartDualDiff | A `diff' between two CoinWarmStartDual objects |
| CoinWarmStartPrimalDual | WarmStart information that is only a dual vector |
| CoinWarmStartPrimalDualDiff | A `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 | |
| COL_DATA | |
| COL_ORDERED | |
| CbcGenCtlBlk::combineCtl_struct | Control variable and prototype for combine heuristic |
| MCF3_data::commodity | |
| MCF2_data::commodity | |
| MCF1_data::commodity | |
| CommonUtil | Common utilities for OS classes |
| Ipopt::CompositeNLP | This class creates a composite NLP from a list of NLP's |
| Ipopt::CompoundMatrix | Class for Matrices consisting of other matrices |
| Ipopt::CompoundMatrixSpace | This is the matrix space for CompoundMatrix |
| Ipopt::CompoundSymMatrix | Class for symmetric matrices consisting of other matrices |
| Ipopt::CompoundSymMatrixSpace | This is the matrix space for CompoundSymMatrix |
| Ipopt::CompoundVector | Class of Vectors consisting of other vectors |
| Ipopt::CompoundVectorSpace | This vectors space is the vector space for CompoundVector |
| OsiCuts::const_iterator | Const Iterator |
| flopc::Constant | Reference counted class for all "constant" types of data |
| flopc::Constant_base | Base class for all "constant" types of data |
| flopc::Constraint | |
| Constraint | The in-memory representation of the <con> element |
| flopc::Constraint_base | Semantic representation of a constraint in a Math Program |
| Constraints | The in-memory representation of the <constraints> element |
| ConstraintSolution | The ConstraintSolution Class |
| ConstraintValues | The ConstraintValues Class |
| ConValue | The ConValue Class |
| Ipopt::ConvergenceCheck | Base class for checking the algorithm termination criteria |
| CP_CUT_DATA | |
| CP_PARAMS | |
| CP_USER_PARAMS | |
| CUT_COLLECTION | |
| CUT_DATA | |
| CUT_POOL | |
| CUT_TIME_OUT | |
| cutParams | |
| flopc::DataRef | Reference to a set of data |
| DBL_EDGE_DATA | |
| DCMP_COL_SET | |
| CbcGenCtlBlk::debugSolInfo_struct | Array of primal variable values for debugging |
| Ipopt::DefaultIterateInitializer | Class implementing the default initialization procedure (based on user options) for the iterates |
| DefaultSolver | The Defalut Solver Class |
| DeletePtrObject | |
| Ipopt::DenseGenMatrix | Class for dense general matrices |
| Ipopt::DenseGenMatrixSpace | This is the matrix space for DenseGenMatrix |
| Ipopt::DenseSymMatrix | Class for dense symetrix matrices |
| Ipopt::DenseSymMatrixSpace | This is the matrix space for DenseSymMatrix |
| Ipopt::DenseVector | Dense Vector Implementation |
| Ipopt::DenseVectorSpace | This vectors space is the vector space for DenseVector |
| Ipopt::DependentResult< T > | Templated class which stores one entry for the CachedResult class |
| CppAD::det_by_lu< Scalar > | |
| CppAD::det_by_minor< Scalar > | |
| DG_EDGE | |
| DG_GRAPH | |
| DG_NET_EDGE | |
| DG_NET_ELIST | |
| DG_NET_NETWORK | |
| DG_NET_VERTEX | |
| DG_NODE | |
| DGG_constraint_t | |
| DGG_data_t | |
| DGG_list_t | |
| Ipopt::DiagMatrix | Class for diagonal matrices |
| Ipopt::DiagMatrixSpace | This is the matrix space for DiagMatrix |
| CglProbing::disaggregation_struct_tag | Disaggregation cuts and for building cliques |
| CglProbing::disaggregationAction | Only useful type of disaggregation is most normal For now just done for 0-1 variables Can be used for building cliques |
| DISTANCES | |
| CbcGenCtlBlk::djFixCtl_struct | Control use of reduced cost fixing prior to B&C |
| do_tighten_action | |
| DOUBLE_ARRAY_DESC | |
| doubleton_action | Solve ax+by=c for y and substitute y out of the problem |
| DoubleVector | Double vector data structure |
| DRAW_GRAPH_PARAMS | |
| DRAW_GRAPH_PROBLEM | |
| drop_empty_cols_action | Physically removes empty columns in presolve, and reinserts empty columns in postsolve |
| drop_empty_rows_action | Physically removes empty rows in presolve, and reinserts empty rows in postsolve |
| drop_zero_coefficients_action | Removal of explicit zeros |
| dropped_zero | Tracking information for an explicit zero coefficient |
| DualVariableValues | The DualVariableValues Class |
| DualVarValue | The DualVarValue Class |
| dupcol_action | Detect and remove duplicate columns |
| duprow_action | Detect and remove duplicate rows |
| EDGE | |
| EDGE_DATA | |
| ELIST | |
| Ipopt::EqMultiplierCalculator | Base Class for objects that compute estimates for the equality constraint multipliers y_c and y_d |
| Ipopt::EquilibrationScaling | This class does problem scaling by setting the scaling parameters based on the maximum of the gradient at the user provided initial point |
| ErrorClass | Used for throwing exceptions |
| CppAD::ErrorHandler | |
| Ipopt::ExactHessianUpdater | Implementation of the HessianUpdater for the use of exact second derivatives |
| Ipopt::ExpansionMatrix | Class for expansion/projection matrices |
| Ipopt::ExpansionMatrixSpace | This is the matrix space for ExpansionMatrix |
| LAP::CglLandPSimplex::extraInfo | |
| Ipopt::FileJournal | FileJournal class |
| FileUtil | Class used to make it easy to read and write files |
| Ipopt::Filter | Class for the filter |
| Ipopt::FilterEntry | Class for one filter entry |
| Ipopt::FilterLSAcceptor | Filter line search |
| fixEntry | Derived class to pick up probing info |
| CbcGenCtlBlk::flowCtl_struct | Control variable and prototype for flow cover cut generator |
| FNODE | |
| CglClique::fnode | A node of the fractional graph |
| forcing_constraint_action | Detect and process forcing constraints and useless constraints |
| CbcGenCtlBlk::fpumpCtl_struct | Control variable and prototype for feasibility pump heuristic |
| FRAC_GRAPH | |
| CglClique::frac_graph | A graph corresponding to a fractional solution of an LP |
| flopc::Functor | Function object |
| Ipopt::GenAugSystemSolver | Solver for the augmented system using GenKKTSolverInterfaces |
| GeneralStatus | The GeneralStatus Class |
| flopc::MP::GenerateFunctor | |
| Ipopt::GenKKTSolverInterface | Base class for interfaces to symmetric indefinite linear solvers for generic matrices |
| CbcGenCtlBlk::genParamsInfo_struct | Start and end of cbc-generic parameters in parameter vector |
| Ipopt::GenTMatrix | Class for general matrices stored in triplet format |
| Ipopt::GenTMatrixSpace | This is the matrix space for a GenTMatrix with fixed sparsity structure |
| CbcGenCtlBlk::gomoryCtl_struct | Control variable and prototype for Gomory cut generator |
| Ipopt::GradientScaling | This class does problem scaling by setting the scaling parameters based on the maximum of the gradient at the user provided initial point |
| CbcGenCtlBlk::greedyCoverCtl_struct | Control variable and prototype for greedy cover heuristic |
| CbcGenCtlBlk::greedyEqualityCtl_struct | Control variable and prototype for greedy equality heuristic |
| flopc::Handle< T > | Utility for doing reference counted pointers |
| Ipopt::HessianUpdater | Abstract base class for objects responsible for updating the Hessian information |
| HS071_NLP | C++ Example NLP for interfacing a problem with IPOPT |
| Ipopt::IdentityMatrix | Class for Matrices which are multiples of the identity matrix |
| Ipopt::IdentityMatrixSpace | This is the matrix space for IdentityMatrix |
| Idiot | This class implements a very silly algorithm |
| IdiotResult | For use internally |
| implied_free_action | Detect and process implied free variables |
| Info | ******** DATA to be moved into protected section of ClpInterior |
| flopc::insertFunctor< nbr > | Inserter for construction of a subset |
| flopc::InsertFunctor< nbr > | Internal representation of a "set" |
| InstanceData | The in-memory representation of the <instanceData> element |
| InstanceHeader | The in-memory representation of the <instanceHeader> element |
| CppAD::IntegrateLast< Fun, SizeVector, FloatVector, Float > | |
| Interval | The in-memory representation of the <interval> element |
| IntVector | Integer Vector data structure |
| Ipopt::IpoptAlgorithm | The main ipopt algorithm class |
| Ipopt::IpoptApplication | This is the main application class for making calls to Ipopt |
| Ipopt::IpoptCalculatedQuantities | Class for all IPOPT specific calculated quantities |
| Ipopt::IpoptData | Class to organize all the data required by the algorithm |
| Ipopt::IpoptException | This is the base class for all exceptions |
| Ipopt::IpoptNLP | This is the abstract base class for classes that map the traditional NLP into something that is more useful by Ipopt |
| IpoptProblem | |
| IpoptSolver | Solves problems using Ipopt |
| isolated_constraint_action | |
| Ipopt::IterateInitializer | Base class for all methods for initializing the iterates |
| Ipopt::IteratesVector | Specialized CompoundVector class specifically for the algorithm iterates |
| Ipopt::IteratesVectorSpace | Vector Space for the IteratesVector class |
| Ipopt::IterationOutput | Base class for objects that do the output summary per iteration |
| OsiCuts::iterator | Iterator |
| Ipopt::Journal | Journal class (part of the Journalist implementation |
| Ipopt::Journalist | Class responsible for all message output |
| KnapModel | |
| KnapNodeDesc | |
| KnapParams | |
| CbcGenCtlBlk::knapsackCtl_struct | Control variable and prototype for knapsack cover cut generator |
| KnapSolution | |
| KnapTreeNode | |
| KnitroProblem | |
| KnitroSolver | KnitroSolver class solves problems using Knitro |
| LAP::LandPMessages | Message handler for lift-and-project simplex |
| LAP::LapMessages | Output messages for Cgl |
| Ipopt::LeastSquareMultipliers | Class for calculator for the least-square equality constraint multipliers |
| LEVEL_GRAPH | |
| Ipopt::LimMemQuasiNewtonUpdater | Implementation of the HessianUpdater for limit-memory quasi-Newton approximation of the Lagrangian Hessian |
| LindoSolver | LindoSolver class solves problems using Lindo |
| LinearConstraintCoefficients | The in-memory representation of the <linearConstraintCoefficients> element |
| Ipopt::LineSearch | Base class for line search objects |
| CbcGenCtlBlk::localTreeCtl_struct | Control variables for local tree |
| Ipopt::LoqoMuOracle | Implementation of the LOQO formula for computing the barrier parameter |
| Ipopt::LowRankAugSystemSolver | Solver for the augmented system with LowRankUpdateSymMatrix Hessian matrices |
| Ipopt::LowRankUpdateSymMatrix | Class for symmetric matrices, represented as low-rank updates |
| Ipopt::LowRankUpdateSymMatrixSpace | This is the matrix space for LowRankUpdateSymMatrix |
| LP_data_and_hook | |
| LP_NET | |
| LP_NET_EDGE | |
| LP_NET_NODE | |
| LP_PARAMS | |
| LP_parms | |
| LP_PROB | |
| LP_SOL | |
| LPDATA | |
| LuksanVlcek1 | Implementation of Example 5.1 from Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization by L |
| LuksanVlcek2 | Implementation of Example 5.2 from Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization by L |
| LuksanVlcek3 | Implementation of Example 5.3 from Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization by L |
| LuksanVlcek4 | Implementation of Example 5.4 from Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization by L |
| LuksanVlcek5 | Implementation of Example 5.5 from Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization by L |
| LuksanVlcek6 | Implementation of Example 5.6 from Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization by L |
| LuksanVlcek7 | Implementation of Example 5.7 from Sparse and Parially Separable Test Problems for Unconstrained and Equality Constrained Optimization by L |
| Ipopt::Ma27TSolverInterface | Interface to the symmetric linear solver MA27, derived from SparseSymLinearSolverInterface |
| Ipopt::Ma28TDependencyDetector | Base class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian |
| Ipopt::Ma57TSolverInterface | Interface to the symmetric linear solver MA57, derived from SparseSymLinearSolverInterface |
| make_fixed_action | Fix a variable at a specified bound |
| MathUtil | This class has routines for linear algebra |
| MatlabException | |
| MatlabFunctionHandle | |
| Ipopt::MatlabJournal | |
| MatlabOption | |
| MatlabProgram | |
| MatlabScalar | |
| MatlabString | |
| Matrix | |
| Ipopt::Matrix | Matrix Base Class |
| Ipopt::MatrixSpace | MatrixSpace base class, corresponding to the Matrix base class |
| Ipopt::Mc19TSymScalingMethod | Class for the method for computing scaling factors for symmetric matrices in triplet format, using MC19 |
| MCF1_branch_decision | |
| MCF1_branching_var | |
| MCF1_data | |
| MCF1_init | |
| MCF1_lp | |
| MCF1_par | |
| MCF1_tm | |
| MCF1_var | |
| MCF2_branch_decision | |
| MCF2_branching_var | |
| MCF2_data | |
| MCF2_init | |
| MCF2_lp | |
| MCF2_par | |
| MCF2_tm | |
| MCF2_var | |
| MCF3_branch_decision | |
| MCF3_data | |
| MCF3_init | |
| MCF3_lp | |
| MCF3_par | |
| MCF3_tm | |
| MCF3_user | |
| MCF3_var | |
| flopc::Messenger | Inteface for hooking up to internal flopc++ message handling |
| Ipopt::MinC_1NrmRestorationPhase | Restoration Phase that minimizes the 1-norm of the constraint violation - using the interior point method (Ipopt) |
| MIPDESC | |
| CbcGenCtlBlk::mirCtl_struct | Control variable and prototype for MIR cut generator |
| MittelmannBndryCntrlDiri1 | Class implementating Example 1 |
| MittelmannBndryCntrlDiri2 | Class implementating Example 2 |
| MittelmannBndryCntrlDiri3 | Class implementating Example 3 |
| MittelmannBndryCntrlDiri3D | Class implementating Example 1 |
| MittelmannBndryCntrlDiri3D_27 | Class implementating case with convex quadratic penalty function |
| MittelmannBndryCntrlDiri3D_27BT | Class implementating case with nonconvex Beaton-Tukey like penalty function |
| MittelmannBndryCntrlDiri3Dsin | Class implementating Example 1 |
| MittelmannBndryCntrlDiri4 | Class implementating Example 4 |
| MittelmannBndryCntrlDiriBase | Base class for boundary control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-4 in Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
| MittelmannBndryCntrlDiriBase3D | Base class for boundary control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-4 in Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
| MittelmannBndryCntrlDiriBase3D_27 | Base class for boundary control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-4 in Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
| MittelmannBndryCntrlDiriBase3Dsin | Base class for boundary control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-4 in Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
| MittelmannBndryCntrlNeum1 | Class implementating Example 5 |
| MittelmannBndryCntrlNeum2 | Class implementating Example 6 |
| MittelmannBndryCntrlNeum3 | Class implementating Example 7 |
| MittelmannBndryCntrlNeum4 | Class implementating Example 8 |
| MittelmannBndryCntrlNeumBase | Base class for boundary control problems with Neumann boundary conditions, as formulated by Hans Mittelmann as Examples 5-8 in Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
| MittelmannDistCntrlDiri1 | Class implementating Example 1 |
| MittelmannDistCntrlDiri2 | Class implementating Example 2 |
| MittelmannDistCntrlDiri3 | Class implementating Example 3 |
| MittelmannDistCntrlDiri3a | |
| MittelmannDistCntrlDiriBase | Base class for distributed control problems with Dirichlet boundary conditions, as formulated by Hans Mittelmann as Examples 1-3 in Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
| MittelmannDistCntrlNeumA1 | Class implementating Example 4 |
| MittelmannDistCntrlNeumA2 | Class implementating Example 5 |
| MittelmannDistCntrlNeumA3 | Class implementating Example 6 |
| MittelmannDistCntrlNeumABase | Base class for distributed control problems with homogeneous Neumann boundary conditions, as formulated by Hans Mittelmann as Examples 4-6 in Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
| MittelmannDistCntrlNeumB1 | Class implementating Example 4 |
| MittelmannDistCntrlNeumB2 | Class implementating Example 5 |
| MittelmannDistCntrlNeumB3 | Class implementating Example 6 |
| MittelmannDistCntrlNeumBBase | Base class for distributed control problems with homogeneous Neumann boundary conditions, as formulated by Hans Mittelmann as Examples 4-6 in Optimization Techniques for Solving Elliptic Control Problems with Control and State Constraints |
| MittelmannParaCntrl5_1 | |
| MittelmannParaCntrl5_2_1 | |
| MittelmannParaCntrl5_2_2 | |
| MittelmannParaCntrl5_2_3 | |
| MittelmannParaCntrl5_try | |
| MittelmannParaCntrlBase< T > | Base class for parabolic and elliptic control problems, as formulated by Hans Mittelmann as problem (P) in Sufficient Optimality for Discretized Parabolic and Elliptic Control Problems |
| Ipopt::MonotoneMuUpdate | Monotone Mu Update |
| flopc::MP | |
| flopc::MP_binary_variable | Specialized subclass of MP_variable where the variable is pre-specified to be binary |
| flopc::MP_boolean | Reference counted class for all "boolean" types of data |
| flopc::MP_constraint | Semantic representation of a linear constraint |
| flopc::MP_data | Input data set |
| flopc::MP_domain | Range over which some other constuct is defined |
| flopc::MP_domain_base | Reference to a set of index values |
| flopc::MP_domain_set | Range over which some other constuct is defined |
| flopc::MP_domain_subset< nbr > | Range over which some other constuct is defined |
| flopc::MP_expression | Symbolic representation of a linear expression |
| flopc::MP_expression_base | The base class for all expressions |
| flopc::MP_index | Representation of an index |
| flopc::MP_index_base | Internal representation of a index |
| flopc::MP_index_dif | Internal representation of an index expression |
| flopc::MP_index_exp | Representation of an expression involving an index |
| flopc::MP_index_mult | Internal representation of an index expression |
| flopc::MP_index_sum | Internal representation of an index expression |
| flopc::MP_model | This is the anchor point for all constructs in a FlopC++ model |
| flopc::MP_set | Representation of a set for indexing into some other construct |
| flopc::MP_set_base | Internal representation of a "set" |
| flopc::MP_stage | |
| flopc::MP_stochastic_data | |
| flopc::MP_subset< nbr > | Internal representation of a "set" |
| flopc::MP_variable | Symantic representation of a variable |
| MPP_PARAMETERS | |
| MPP_PROBLEM | |
| Multipliers | |
| Ipopt::MultiVectorMatrix | Class for Matrices with few columns that consists of Vectors |
| Ipopt::MultiVectorMatrixSpace | This is the matrix space for MultiVectorMatrix |
| Ipopt::MumpsSolverInterface | Interface to the linear solver Mumps, derived from SparseSymLinearSolverInterface |
| Ipopt::MuOracle | Abstract Base Class for classes that are able to compute a suggested value of the barrier parameter that can be used as an oracle in the NonmontoneMuUpdate class |
| Ipopt::MuUpdate | Abstract Base Class for classes that implement methods for computing the barrier and fraction-to-the-boundary rule parameter for the current iteration |
| MY_user_data | Class taking care of interaction between user data and Bcp |
| MyEventHandler | This is so user can trap events and do useful stuff |
| MyMessageHandler | |
| MyNLP | C++ Example NLP for interfacing a problem with IPOPT |
| myPdco | This implements a simple network matrix as derived from ClpMatrixBase |
| flopc::Named | Utility interface class for adding a string name onto a structure |
| NETWORK | |
| Nl | The in-memory representation of the <nl> element |
| Ipopt::NLP | Brief Class Description |
| Ipopt::NLPScalingObject | This is the abstract base class for problem scaling |
| CglLandP::NoBasisError | |
| NODE_DESC | |
| NODE_TIMES | |
| NonlinearExpressions | The in-memory representation of the <nonlinearExpressions> element |
| Ipopt::NoNLPScalingObject | Class implementing the scaling object that doesn't to any scaling |
| flopc::NormalMessenger | Internal use: used when Normal output is selected |
| ObjCoef | The in-memory representation of the objective function <coef> element |
| Objective | The in-memory representation of the <obj> element |
| Objectives | The in-memory representation of the <objectives> element |
| ObjectiveSolution | The ObjectiveSolution Class |
| ObjectiveValues | The ObjectiveValues Class |
| ObjValue | The ObjValue Class |
| Ipopt::Observer | Slight Variation of the Observer Design Pattern |
| CbcGenCtlBlk::oddHoleCtl_struct | Control variable and prototype for odd hole cut generator |
| CppAD::ok_if_S_same_as_T< S, T > | |
| CppAD::ok_if_S_same_as_T< T, T > | |
| Ipopt::OptimalityErrorConvergenceCheck | Brief Class Description |
| OptimizationResult | The OptimizationResult Class |
| OptimizationSolution | The OptimizationSolution Class |
| OptimizationSolutionStatus | The OptimizationSolutionStatus Class |
| Options | ******** DATA to be moved into protected section of ClpInterior |
| Ipopt::OptionsList | This class stores a list of user set options |
| Ipopt::OptionsList::OptionValue | Class for storing the value and counter for each option in OptionsList |
| Ipopt::OrigIpoptNLP | This class maps the traditional NLP into something that is more useful by Ipopt |
| Ipopt::OrigIterationOutput | Class for the iteration summary output for the original NLP |
| OSExpressionTree | Used to hold the instance in memory |
| OShL | An interface that specified virtual methods to be implemented by agents. |
| OsiAuxInfo | This class allows for a more structured use of algorithmic tweaking to an OsiSolverInterface |
| OsiBabSolver | This class allows for the use of more exotic solvers e.g |
| OsiBiLinear | Define BiLinear objects |
| OsiBiLinearBranchingObject | Branching object for BiLinear objects |
| OsiBiLinearEquality | Define Continuous BiLinear objects for an == bound |
| OsiBranchingInformation | |
| OsiBranchingObject | Abstract branching object base class |
| OsiCbcSolverInterface | Cbc Solver Interface |
| OsiChooseStrong | This class chooses a variable to branch on |
| OsiChooseStrongSubset | This class chooses a variable to branch on |
| OsiChooseVariable | This class chooses a variable to branch on |
| OsiClpDisasterHandler | |
| OsiClpSolverInterface | Clp Solver Interface |
| OsiColCut | Column Cut Class |
| OsiCpxSolverInterface | CPLEX Solver Interface |
| OsiCut | |
| OsiCuts::OsiCutCompare | |
| OsiCuts | Collections of row cuts and column cuts |
| OsiDylpSolverInterface | COIN OSI layer for dylp |
| OsiDylpWarmStartBasis | The dylp warm start class |
| OsiDylpWarmStartBasisDiff | A `diff' between two OsiDylpWarmStartBasis objects |
| OsiFmpSolverInterface | OSL Solver Interface |
| OsiGlpkSolverInterface | GPLK Solver Interface |
| OsiHotInfo | This class contains the result of strong branching on a variable When created it stores enough information for strong branching |
| OsiIntegerBranchingObject | Simple branching object for an integer variable |
| OsiLink | Define Special Linked Ordered Sets |
| OsiLinkBranchingObject | Branching object for Linked ordered sets |
| OsiLinkedBound | List of bounds which depend on other bounds |
| OsiLotsize | Lotsize class |
| OsiLotsizeBranchingObject | Lotsize branching object |
| 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 |
| OsiMskSolverInterface | |
| OSInstance | The in-memory representation of an OSiL instance. |
| OsiObject | Abstract base class for `objects' |
| OsiObject2 | Define a class to add a bit of complexity to OsiObject This assumes 2 way branching |
| OsiOldLink | |
| OsiOldLinkBranchingObject | Branching object for Linked ordered sets |
| OsiOneLink | Define data for one link |
| OsiOslSolverInterface | OSL Solver Interface |
| CbcGenCtlBlk::osiParamsInfo_struct | Start and end of OsiSolverInterface parameters in parameter vector |
| OsiPresolve | OSI interface to COIN problem simplification capabilities |
| OsiPseudoCosts | This class is the placeholder for the pseudocosts used by OsiChooseStrong |
| OsiRowCut | Row Cut Class |
| OsiRowCut2 | Row Cut Class which refers back to row which created it |
| OsiRowCutDebugger | Validate Row Cut Generator |
| OsiSimpleFixedInteger | Define a single integer class - but one where you keep branching until fixed even if satisfied |
| OsiSimpleInteger | Define a single integer class |
| OsiSolverBranch | Solver Branch Class |
| OsiSolverInterface | Solver Interface Abstract Base Class |
| OsiSolverLinearizedQuadratic | This is to allow the user to replace initialSolve and resolve |
| OsiSolverLink | This is to allow the user to replace initialSolve and resolve This version changes coefficients |
| OsiSolverResult | Solver Result Class |
| OsiSOS | Define Special Ordered Sets of type 1 and 2 |
| OsiSOSBranchingObject | Branching object for Special ordered sets |
| OsiSpxSolverInterface | SOPLEX Solver Interface |
| OsiSymSolverInterface | OSI Solver Interface for SYMPHONY |
| OsiTwoWayBranchingObject | This just adds two-wayness to a branching object |
| OsiUsesBiLinear | Define a single variable class which is involved with OsiBiLinear objects |
| OsiVolSolverInterface::OsiVolMatrixOneMinusOne_ | |
| OsiVolSolverInterface | Vol(ume) Solver Interface |
| OsiXprSolverInterface | XPRESS-MP Solver Interface |
| 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 |
| 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 |
| osOptionsStruc | This structure is used to store options for the OSSolverService executable |
| OSResult | The Result Class |
| 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 |
| OtherConResult | The OtherConResult Class |
| OtherConstraintResult | The OtherConstraintResult Class |
| OtherObjectiveResult | The OtherObjectiveResult Class |
| OtherObjResult | The OtherObjResult Class |
| OtherVariableResult | The OtherVariableResult Class |
| OtherVariableResultStruct | A structure to information about an OtherVariableResult element |
| OtherVarResult | OtherVarResult Class |
| OUR_COL_SET | |
| Outfo | ******** DATA to be moved into protected section of ClpInterior |
| CglLandP::Parameters | Class storing parameters |
| PARAMS | |
| Ipopt::PardisoSolverInterface | Interface to the linear solver Pardiso, derived from SparseSymLinearSolverInterface |
| Ipopt::PDFullSpaceSolver | This is the implemetation of the Primal-Dual System, using the full space approach with a direct linear solver |
| Ipopt::PDPerturbationHandler | Class for handling the perturbation factors delta_x, delta_s, delta_c, and delta_d in the primal dual system |
| Ipopt::PDSearchDirCalculator | Implementation of the search direction calculator that computes the pure primal dual step for the current barrier parameter |
| Ipopt::PDSystemSolver | Pure Primal Dual System Solver Base Class |
| Ipopt::PenaltyLSAcceptor | Filter line search |
| Ipopt::PiecewisePenalty | Class for the Piecewise Penalty |
| Ipopt::PiecewisePenEntry | Struct for one Piecewise Penalty entry |
| PLess< T > | |
| Ipopt::PointPerturber | This class is a simple object for generating randomly perturbed points that are withing the NLP bounds |
| POOL_EDGE | |
| POOL_NET | |
| POOL_NODE | |
| POS_WEIGHT_LHS | |
| presolvehlink | Links to aid in packed matrix modification |
| Ipopt::AmplOptionsList::PrivatInfo | |
| PROB_TIMES | |
| CbcGenCtlBlk::probingCtl_struct | Control variable and prototype for probing cut generator |
| Ipopt::ProbingMuOracle | Implementation of the probing strategy for computing the barrier parameter |
| PROBLEM_STAT | |
| MittelmannParaCntrl5_try::ProblemSpecs | |
| MittelmannParaCntrl5_2_2::ProblemSpecs | |
| MittelmannParaCntrl5_2_1::ProblemSpecs | |
| MittelmannParaCntrl5_2_3::ProblemSpecs | |
| MittelmannParaCntrl5_1::ProblemSpecs | |
| PROCESS_SET | |
| QuadraticCoefficients | The in-memory representation of the <quadraticCoefficients> element |
| QuadraticTerm | The in-memory representation of the <qTerm> element |
| QuadraticTerms | Data structure for holding quadratic terms |
| Ipopt::QualityFunctionMuOracle | Implementation of the probing strategy for computing the barrier parameter |
| real_user_data | Class handling user data |
| CbcGenCtlBlk::redSplitCtl_struct | Control variable and prototype for reduce-and-split cut generator |
| Ipopt::ReferencedObject | ReferencedObject class |
| Coin::ReferencedObject | ReferencedObject class |
| Ipopt::Referencer | Psydo-class, from which everything has to inherit that wants to use be registered as a Referencer for a ReferencedObject |
| Ipopt::RegisteredOption | Base class for registered options |
| Ipopt::RegisteredOptions | Class for storing registered options |
| RegisteredTNLP | Class implemented the NLP discretization of |
| RegisteredTNLPs | |
| remove_dual_action | Attempt to fix variables by bounding reduced costs |
| remove_fixed_action | Excise fixed variables from the model |
| Ipopt::RestoFilterConvergenceCheck | Convergence check for the restoration phase as called by the filter |
| Ipopt::RestoIpoptNLP | This class maps the traditional NLP into something that is more useful by Ipopt |
| Ipopt::RestoIterateInitializer | Class implementing the default initialization procedure (based on user options) for the iterates |
| Ipopt::RestoIterationOutput | Class for the iteration summary output for the restoration phase |
| Ipopt::RestorationPhase | Base class for different restoration phases |
| Ipopt::RestoRestorationPhase | Recursive Restoration Phase for the.MinC_1NrmRestorationPhase |
| ResultData | The ResultData Class |
| ResultHeader | The ResultHeader Class |
| Rname | |
| CppAD::RombergMul< Fun, SizeVector, FloatVector, m > | |
| CppAD::RombergMul< Fun, SizeVector, FloatVector, 1 > | |
| CbcGenCtlBlk::roundingCtl_struct | Control variable and prototype for simple rounding heuristic |
| ROUTE_DATA | |
| ROW_DATA | |
| ROW_ORDERED | |
| flopc::RowMajor | Utility class to flatten multidimensional information into single dimentional offset information |
| Ipopt::ScaledMatrix | Class for a Matrix in conjunction with its scaling factors for row and column scaling |
| Ipopt::ScaledMatrixSpace | This is the matrix space for ScaledMatrix |
| Ipopt::SearchDirectionCalculator | Base class for computing the search direction for the line search |
| CglLandP::SimplexInterfaceError | |
| slack_doubleton_action | Convert an explicit bound constraint to a column bound |
| slack_singleton_action | For variables with one entry |
| CppAD::SliceLast< Fun, FloatVector > | |
| SMALL_GRAPH | |
| Coin::SmartPtr< T > | Template class for Smart Pointers |
| Ipopt::SmartPtr< T > | Template class for Smart Pointers |
| SmiCoreCombineAdd | |
| SmiCoreCombineReplace | |
| SmiCoreCombineRule | This deals with combining Core and Stochastic data |
| SmiCoreData | |
| SmiDiscreteDistribution | |
| SmiDiscreteEvent | |
| SmiDiscreteRV | |
| SmiLinearData | |
| SmiMessage | This deals with Clp messages (as against Osi messages etc) |
| SmiNodeData | |
| SmiScenarioTree< T > | |
| SmiScnModel | SmiScnModel: COIN-SMI Scenario Model Class |
| SmiScnModelAddNode | |
| SmiScnNode | |
| SmiSmpsCardReader | |
| SmiSmpsIO | |
| SmiTreeNode< T > | SmiTreeNode template class |
| SOL_POOL_PARAMS | |
| Ipopt::SolveStatistics | This class collects statistics about an optimziation run, such as iteration count, final infeasibilities etc |
| SPARSE_MATRIX | |
| SparseHessianMatrix | The in-memory representation of a SparseHessianMatrix. |
| SparseJacobianMatrix | Sparse Jacobian matrix data structure |
| SparseMatrix | Sparse matrix data structure |
| SparseMatrixStructure | |
| Ipopt::SparseSymLinearSolverInterface | Base class for interfaces to symmetric indefinite linear solvers for sparse matrices |
| SparseVector | Sparse vector data structure |
| SPP_CG_PARAMS | |
| SPP_CG_PROBLEM | |
| SPP_CG_TMP | |
| SPP_LP_PARAMS | |
| SPP_LP_PROBLEM | |
| SPP_LP_TMP | |
| SPP_PARAMETERS | |
| SPP_PROBLEM | |
| Ipopt::StandardScalingBase | This is a base class for many standard scaling techniques |
| STATISTICS | |
| Ipopt::StdAugSystemSolver | Solver for the augmented system for triple type matrices |
| Ipopt::StdInterfaceTNLP | Implementation of a TNLP for the Standard C interface |
| STR_INT | |
| Ipopt::StreamJournal | StreamJournal class |
| Ipopt::RegisteredOption::string_entry | Class to hold the valid string settings for a string option |
| Ipopt::Subject | Slight Variation of the Observer Design Pattern (Subject part) |
| flopc::SubsetRef< nbr > | Internal representation of a "set" |
| flopc::SUBSETREF | Internal representation of a "set" |
| subst_constraint_action | |
| Ipopt::SumMatrix | Class for Matrices which are sum of matrices |
| Ipopt::SumMatrixSpace | Class for matrix space for SumMatrix |
| Ipopt::SumSymMatrix | Class for Matrices which are sum of symmetric matrices |
| Ipopt::SumSymMatrixSpace | Class for matrix space for SumSymMatrix |
| SYM_ENVIRONMENT | |
| Ipopt::SymLinearSolver | Base class for all derived symmetric linear solvers |
| Ipopt::SymMatrix | This is the base class for all derived symmetric matrix types |
| Ipopt::SymMatrixSpace | SymMatrixSpace base class, corresponding to the SymMatrix base class |
| symrec | For string evaluation |
| Ipopt::SymScaledMatrix | Class for a Matrix in conjunction with its scaling factors for row and column scaling |
| Ipopt::SymScaledMatrixSpace | This is the matrix space for SymScaledMatrix |
| Ipopt::SymTMatrix | Class for symmetric matrices stored in triplet format |
| Ipopt::SymTMatrixSpace | This is the matrix space for a SymTMatrix with fixed sparsity structure |
| SymWarmStart | |
| LAP::CglLandPSimplex::TabRow | |
| Ipopt::TaggedObject | TaggedObject class |
| CppAD::TapeRec< Base > | |
| Ipopt::TDependencyDetector | Base class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian |
| TEMPORARY | |
| flopc::TerminalExpression | The base class for all expressions |
| TestBed | |
| TestItem | |
| TimeDomain | The in-memory representation of the <timeDomain> element |
| TimeDomainInterval | |
| TimeDomainStage | The in-memory representation of the <stage> element |
| TimeDomainStages | The in-memory representation of the <stages> element |
| Ipopt::TimedTask | This class is used to collect timing information for a particular task |
| Ipopt::TimingStatistics | This class collects all timing statistics for Ipopt |
| TM_PARAMS | |
| TM_PROB | |
| TM_TEMP | |
| Ipopt::TNLP | Base class for all NLP's that use standard triplet matrix form and dense vectors |
| Ipopt::TNLPAdapter | This class Adapts the TNLP interface so it looks like an NLP interface |
| TotalWorkload | A functor class used in calulating total workload in a node pool |
| CppAD::TrackElement | |
| tree | Implementation of live set as a heap |
| Ipopt::TripletToCSRConverter::TripletEntry | Class for one triplet position entry |
| Ipopt::TripletHelper | |
| tripleton_action | We are only going to do this if it does not increase number of elements? |
| Ipopt::TripletToCSRConverter | Class for converting symmetric matrices given in triplet format to matrices in compressed sparse row (CSR) format of the upper triangual part (or, equivalently, compressed sparse column (CSC) format for the lower triangular part) |
| Ipopt::TSymDependencyDetector | Base class for all derived algorithms for detecting linearly dependent rows in the constraint Jacobian |
| Ipopt::TSymLinearSolver | General driver for linear solvers for sparse indefinite symmetric matrices |
| Ipopt::TSymScalingMethod | Base class for the method for computing scaling factors for symmetric matrices in triplet format |
| CbcGenCtlBlk::twomirCtl_struct | Control variable and prototype for Two-MIR cut generator |
| UFL | |
| UFL_parms | |
| useless_constraint_action | |
| USER_initialize | This class is an abstract base class for the initializer class the user has to provide |
| USER_PARAMETERS | |
| USER_PROBLEM | |
| Ipopt::UserScaling | This class does problem scaling by getting scaling parameters from the user (through the NLP interface) |
| VAR_DESC | |
| Variable | The in-memory representation of the variable element |
| flopc::VariableRef | Semantic representation of a variable in a Math Program |
| Variables | The in-memory representation of the variables element |
| VariableSolution | The VariableSolution Class |
| VariableValues | The VariableValues Class |
| VarValue | VarValue Class |
| CppAD::VecAD< Base > | |
| CppAD::VecAD_reference< Base > | |
| CppAD::vector< Type > | |
| Ipopt::Vector | Vector Base Class |
| CppAD::vectorBool | |
| CppAD::vectorBoolElement | |
| Ipopt::VectorSpace | VectorSpace base class, corresponding to the Vector base class |
| flopc::VerboseMessenger | Internal use: used when Verbose output is selected |
| VERTEX | |
| VOL_alpha_factor | |
| VOL_dual | |
| VOL_dvector | Vector of doubles |
| VOL_indc | |
| VOL_ivector | Vector of ints |
| VOL_lp | |
| VOL_parms | This class contains the parameters controlling the Volume Algorithm |
| VOL_primal | |
| VOL_problem | This class holds every data for the Volume Algorithm and its solve method must be invoked to solve the problem |
| VOL_swing | |
| VOL_user_hooks | The user hooks should be overridden by the user to provide the problem specific routines for the volume algorithm |
| VOL_vh | |
| VRP_CG_PARAMS | |
| VRP_CG_PROBLEM | |
| VRP_CP_PROBLEM | |
| VRP_DG | |
| VRP_LP_PARAMS | |
| VRP_LP_PROBLEM | |
| VRP_PARAMS | |
| VRP_PROBLEM | |
| VrpCutGenerator | |
| VrpHeurTSP | |
| VrpModel | Model class for VRP |
| VrpNetwork | |
| VrpParams | |
| VrpSolution | This class contains a vrp solution |
| VrpVariable | Variable class for VRP |
| WAITING_ROW | |
| WARM_START_DESC | |
| Ipopt::WarmStartIterateInitializer | Class implementing an initialization procedure for warm starts |
| WINDOW | |
| WINDOW_DESCRIPTION | |
| Ipopt::WsmpSolverInterface | Interface to the linear solver Wsmp, derived from SparseSymLinearSolverInterface |
| WSUtil | Used by OSSolverAgent client for help in invoking a remote solver. |
| YYLTYPE | |
| YYSTYPE | |
| Ipopt::ZeroMatrix | Class for Matrices with only zero entries |
| Ipopt::ZeroMatrixSpace | Class for matrix space for ZeroMatrix |
