| ampl | Class for the AMPL-Interface |
| amplCon | Class for an AMPL-constraints-function |
| amplObj | Class for an AMPL-objective-function |
| BlockMatrix | |
| MINLP::BlockView | |
| MINLPView::BlockView | Defines a view on a block (of variables) of a MINLP |
| BoundsFinder | Finds bounds for variables |
| BoundsFinderLinear | Computes missing bounds or reduces existing bounds by minimizing/maximizing a variable over some linear constraints |
| BoxLocOpt | |
| BoxMinimizer | Abstract class for a solver, which minimize a function over a box |
| MIPSolver::ColItem | Used to identify a column in the LP |
| OSISolver::ColItem | |
| ColumnGenerator | Class for generating and solving a restricted master problem |
| MINLPData::Constraint | Storage for the data of a constraint |
| IntervalGradientCut::ConstraintInfo | |
| MINLP::ConstraintView | |
| MINLPView::ConstraintView | Defines a view on a constraint of a MINLP |
| Convexify | Class to convexify a (decomposed) function |
| Cut< CutType > | Represents a Cut in the CutPool |
| CutPool::CutInfo | Class for communication between CutPool and LinearRelax |
| CutPool | A Cut management system |
| DecompGraph | |
| Decomposition | Decompose a function or problem |
| DenseMatrix | A wrapper class for a dense TNT-matrix |
| DenseVector< Type > | Wrapper-class for a dense TNT-Vector |
| DiagMatrix | A diagonal matrix |
| DualBounds | Computes dual bounds |
| DualFunc | A abstract base class for a dual function of a MinlpReform |
| DualSolver | Abstract base class for an optimizer for solving a dual problem of the form: max { obj(x) | x_i>=lower_bound_i } |
| DecompGraph::Edge | |
| Edge< NodeDataType, EdgeDataType, false > | |
| Edge< NodeDataType, EdgeDataType, true > | |
| IntervalReduction::EdgeData | |
| ExtremePoint | |
| ExtUserMatrix | A UserMatrix with an (int,int)-operator to read elements of the matrix |
| Func | The abstract base class for a function |
| gams | Gams interface |
| gamsFunc | |
| gamsLocOpt | Calls a GAMS-solver to solve the original problem with different bounds, fixed variables or another starting point |
| gamsNLData | |
| Graph< NodeDataType, EdgeDataType, directed, multi_edges > | |
| HessMatrix | Represantation of a Hessian Matrix for a function |
| IntervalCompliantMatrix | |
| IntervalGradientCut | A class for storing the information that is neccessary to generate an interval gradient cut |
| IntervalGradientCutGenerator | Constructs a interval gradient cut |
| IntervalReduction | |
| IntervalVector | |
| IpOpt | |
| IpOptProblem | |
| LagHeu | Base class for Lagrangian Heuristics |
| LagHeu1 | |
| LagHeu2 | Another lagrange heuristic |
| LagHeu2b | Modification of LagHeu2 |
| LagHeu_SimAnnealing | Lagrangian Heuristic using Simulated Annealing |
| MinlpBCP::LagSolveStatus_s | |
| LevelCutHandler | Updates level cuts |
| LinearRelax::LinConstraint | Class to represent a linear (block) constraint |
| LinearizationCut | |
| LinearizedConCutGenerator | |
| LinearRelax | A linear relaxation |
| LinearRelaxSolver | An abstract solver for the linear relaxation |
| LinearRelaxSolverGeneral | A general solver for the LinearRelaxation, which constructs a MinlpProblem and uses LocOpt::get_lp_solver to solve it |
| LinearRelaxSolverMIP | |
| SparsityInfo::LinearVariable | To represent a linear variable |
| LocOpt | Abstract class for a local optimizer |
| LocOptPreprocessing | Class for preprocessing a point before a LaGO local optimization is called |
| LPSolver | Wrapper class to use a MIPSolver to solve LP's, which are given as MINLP's |
| MINLP | Default view on a MINLP |
| MinlpBCP | A branch-cut-and-price algorithm for solving a nonconvex MINLP problem |
| MINLPData | Storage for the data of a MINLP |
| MinlpNode | A class containing methods needed for partitioning algorithms |
| MinlpOpt | Main class to solve a MINLP |
| MinlpPenaltyFunc | A Penalty Function for a MinlpProblem |
| MinlpProblem | Class for defining a mixed-integer nonlinear minimization problem |
| MINLPView | Defines a view on a MINLP |
| MinusFunc | A wrapper class to multiply a function with -1 |
| MinusMatrix | Wrapper class to multiply a matrix with -1 |
| MipProblem | Container for a MIP problem |
| MIPSolver | A general solver for mixed-integer linear programs (MIPs) |
| Monom | Class to represent a Monom |
| MultiIndex | Class to represent a MultiIndex |
| DecompGraph::Node | |
| Node< NodeDataType, EdgeDataType, multi_edges > | |
| NodeAdj< NodeDataType, EdgeDataType, false > | |
| NodeAdj< NodeDataType, EdgeDataType, true > | |
| IntervalReduction::NodeData | |
| Cut< CutType >::NodeInfo | |
| SparsityInfo::NonlinearConnection | To represent a connection (entry in hessian) between two nonlinear variables |
| SparsityInfo::NonlinearVariable | To represent a nonlinear variable |
| MINLPData::ObjCon | Storage for the data of an objective function or constraint |
| MINLP::ObjConView< ObjOrCon > | |
| MINLPView::ObjConView | Defines a view on a objective or constraint of a MINLP |
| MINLPData::Objective | Storage for the data of an objective function |
| MINLP::ObjectiveView | |
| MINLPView::ObjectiveView | Defines a view on a objective of a MINLP |
| OSISolver | Interface to COIN OSI |
| Param | Class for reading parameter-files and storing them in a tree (ParamTree) |
| ParamTree | Classes to read parameters |
| Pointer< Type > | A Smartpointer with reference counter |
| PolynomialUnderestimator2 | Class to compute Polynomial underestimators of nonconvex functions |
| Project | Class to project a point onto a box |
| QqpDualFunc | A base class for evaluating the dual function |
| QqpExtMatrix | One extended block of the block matrix of the modified QQP-Lagrangian |
| QqpMatrix | A class for evaluating the dual function as in QqpDualFunc where the Lagrange multipliers of the quadratic box-constraints are eliminated by  |
| QuadraticUnderestimator | Class to compute a quadratic underestimators of nonconvex functions |
| SparsityInfo::QuadraticVariable | To represent a quadratic variable |
| Random | |
| Reformulation | A container for storing several reformulations |
| RelaxationSolver | A base class for defining a relaxation-based solver |
| RMPManager | Class to manage the RMP |
| Round | Class to round the discrete variables of a point to integer values |
| MIPSolver::RowItem | Used to identify a row in the LP |
| OSISolver::RowItem | |
| Sampling | Class to generate a sample set |
| Sampling_check | Class to check an existing sample set, if a constraint is fullfilled |
| Sampling_Minimizer | Computing sample point by minimizing a given function, starting from the point from a sample set with the lowest sample function value |
| Sampling_Vertices | Sampling technique to generate points at vertices |
| SepFunc | Abstract base class for a separable function |
| SepQcFunc | A class for a separable QC-function |
| ShiftMatrix | Wrapper class to shift a matrix |
| SimpleCut | |
| SimpleEquationSolver | Simple algorithm to solve the equation f==0 over a box |
| SolCandidate | A solution candidate |
| Solver | Abstract base class for solving an optimization problem |
| SparseMatrix | |
| SparseMatrix2 | |
| SparseVector< Type > | Class for a sparse vector |
| SparsityInfo | A class to represent the sparsity structure of a function |
| SplitFunc | Represents a function, which relates only to a subset of the variables of another function |
| SplittingScheme2 | |
| SubGradOpt | Subgradient algorithm |
| SumFunc | A function to represent the sum of two functions with optional multiplicators |
| SumMatrix | A class to represent the sum of two matrices with optional scaling |
| Timer | Initialize the random-number-generator, using srand(time(NULL)) |
| UserMatrix | Abstract class for a user defined quadratic matrix |
| UserVector< Type > | Abstract class for a UserVector |
| MINLPData::Variable | Storage for the data of a variable |
| SepQcFunc::VariableIterator | |
| VariableIterator | |
| VariableIterator_Type | Abstract class for an iterator, which iterates over the variables of a function |
| MINLP::VariableView | |
| MINLPView::VariableView | Defines a view on a variable of a MINLP |
| SparseVector< Type >::VectorElement | The structure of one element form my vector in my list of elements |
