# Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

Couenne::AuxRelation | Base class definition for relations between auxiliaries
Couenne::BiProdDivRel | Identifies 5-tuple of the form
Couenne::CouenneExprMatrix::compare_pair_ind |
Couenne::CouenneSparseVector::compare_scalars |
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
Couenne::CouenneAggrProbing | Cut Generator for aggressive BT; i.e., an aggressive probing
Couenne::CouenneAmplInterface |
Couenne::CouenneBab |
Couenne::CouenneBranchingObject | "Spatial" branching object
Couenne::CouenneBTPerfIndicator |
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::CouenneExprMatrix |
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 | An iterative rounding heuristic, tailored for nonconvex MINLPs
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::CouennePSDcon | Class to represent positive semidefinite constraints //////////////////
Couenne::CouenneRecordBestSol |
Couenne::CouenneScalar |
Couenne::CouenneSdpCuts | These are cuts of the form
Couenne::CouenneSetup |
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::CouenneSparseVector |
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 |
Couenne::DepGraph | Dependence graph
Couenne::DepNode | Vertex of a dependence graph
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
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
Couenne::funtriplet |
Couenne::GlobalCutOff |
Couenne::InitHeuristic | A heuristic that stores the initial solution of the NLP
Couenne::kpowertriplet |
less_than_str |
Couenne::LinMap |
Couenne::MultiProdRel | Identifies 5-ples of variables of the form
myclass |
myclass0 |
Nauty |
Couenne::CouenneInfo::NlpSolution | Class for storing an Nlp Solution
Couenne::NlpSolveHeuristic |
Node |
Couenne::powertriplet |
Couenne::PowRel | Identifies 5-tuple of the form
Couenne::Qroot | Class that stores result of previous calls to rootQ into a map for faster access
Couenne::quadElem |
Couenne::QuadMap |
Couenne::simpletriplet |
Couenne::SmartAsl |
Couenne::SumLogAuxRel | Identifies 5-ples of variables of the form
Couenne::t_chg_bounds | Status of lower/upper bound of a variable, to be checked/modified in bound tightening

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines