Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
Couenne::AuxRelationBase class definition for relations between auxiliaries
Couenne::BiProdDivRelIdentifies 5-tuple of the form
Couenne::CouenneExprMatrix::compare_pair_ind
Couenne::CouenneSparseVector::compare_scalars
Couenne::compareSolClass for comparing solutions (used in tabu list)
Couenne::compExprStructure for comparing expressions
Couenne::compNodeStructure for comparing nodes in the dependence graph
Couenne::CouenneAggrProbingCut Generator for aggressive BT; i.e., an aggressive probing
Couenne::CouenneAmplInterface
Couenne::CouenneBab
Couenne::CouenneBranchingObject"Spatial" branching object
Couenne::CouenneBTPerfIndicator
Couenne::CouenneChooseStrong
Couenne::CouenneChooseVariableChoose a variable for branching
Couenne::CouenneComplBranchingObject"Spatial" branching object for complementarity constraints
Couenne::CouenneComplObjectOsiObject for complementarity constraints $ x_1 x_2 \ge,\le,= 0 $
Couenne::CouenneConstraintClass to represent nonlinear constraints
Couenne::CouenneCrossConvCut Generator that uses relationships between auxiliaries
Couenne::CouenneCutGeneratorCut Generator for linear convexifications
Couenne::CouenneDisjCutsCut Generator for linear convexifications
Couenne::CouenneExprMatrix
Couenne::CouenneFeasPumpAn implementation of the Feasibility pump that uses linearization and Ipopt to find the two sequences of points
Couenne::CouenneFixPointCut Generator for FBBT fixpoint
Couenne::CouenneFPpoolPool of solutions
Couenne::CouenneFPsolutionClass containing a solution with infeasibility evaluation
Couenne::CouenneInfoBonmin class for passing info between components of branch-and-cuts
Couenne::CouenneInterface
Couenne::CouenneIterativeRoundingAn iterative rounding heuristic, tailored for nonconvex MINLPs
Couenne::CouenneMINLPInterfaceThis 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::CouenneObjectOsiObject for auxiliary variables $w=f(x)$
Couenne::CouenneObjectiveObjective function
Couenne::CouenneOrbitBranchingObj"Spatial" branching object
Couenne::CouenneOSInterface
Couenne::CouenneProblemClass for MINLP problems with symbolic information
Couenne::CouennePSDconClass to represent positive semidefinite constraints //////////////////
Couenne::CouenneRecordBestSol
Couenne::CouenneScalar
Couenne::CouenneSdpCutsThese 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::CouenneSparseMatrixClass for sparse Matrixs (used in modifying distances in FP)
Couenne::CouenneSparseVector
Couenne::CouenneThreeWayBranchObjSpatial, three-way branching object
Couenne::CouenneTNLPClass for handling NLPs using CouenneProblem
Couenne::CouenneTwoImpliedCut Generator for implied bounds derived from pairs of linear (in)equalities
Couenne::CouenneUserInterface
Couenne::CouenneVarObjectOsiObject for variables in a MINLP
Couenne::CouenneVTObjectOsiObject for violation transfer on variables in a MINLP
Couenne::CouExpr
Couenne::DepGraphDependence graph
Couenne::DepNodeVertex of a dependence graph
Couenne::DomainDefine a dynamic point+bounds, with a way to save and restore previous points+bounds through a LIFO structure
Couenne::DomainPointDefine a point in the solution space and the bounds around it
Couenne::exprAbsClass for $ |f(x)| $
Couenne::exprAuxAuxiliary variable
Couenne::exprBinProdClass for $ \prod_{i=1}^n f_i(x) $ with $ f_i(x) $ all binary
Couenne::exprCeilClass ceiling, $ \lceil f(x) \rceil $
Couenne::exprCloneExpression clone (points to another expression)
Couenne::exprConstConstant-type operator
Couenne::exprCopy
Couenne::exprCosClass cosine, $ \cos f(x) $
Couenne::exprDivClass for divisions, $ \frac{f(x)}{g(x)} $
Couenne::expressionExpression base class
Couenne::exprExpClass for the exponential, $ e^{f(x)} $
Couenne::exprFloorClass floor, $ \lfloor f(x) \rfloor $
Couenne::exprGroupClass Group, with constant, linear and nonlinear terms: $ a_0 + \sum_{i=1}^n a_i x_i $
Couenne::ExprHessExpression matrices
Couenne::exprIf
Couenne::exprInvClass inverse: $ 1/f(x) $
Couenne::exprIVarVariable-type operator
Couenne::ExprJacJacobian of the problem (computed through Couenne expression classes)
Couenne::exprLBCosClass to compute lower bound of a cosine based on the bounds of its arguments
Couenne::exprLBDivClass to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprLBMulClass to compute lower bound of a product based on the bounds of both factors
Couenne::exprLBQuadClass to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprLBSinClass to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprLogClass logarithm, $ \log f(x)$
Couenne::exprLowerBoundThese are bound expression classes
Couenne::exprMaxClass for maxima
Couenne::exprMinClass for minima
Couenne::exprMultiLinAnother class for multiplications, $ \prod_{i=1}^n f_i(x) $
Couenne::exprNormClass for $ p $-norms, $ || f(x)||_p = \left(\sum_{i=1}^n f_i(x)^p\right)^{\frac{1}{p}} $
Couenne::exprOddPowPower of an expression (binary operator), $ f(x)^k$ with $ k$ constant
Couenne::exprOpGeneral n-ary operator-type expression: requires argument list
Couenne::exprOppClass opposite, $ -f(x) $
Couenne::exprPowPower of an expression (binary operator), $ f(x)^k$ with $ k$ constant
Couenne::exprPWLinear
Couenne::exprQuadClass exprQuad, with constant, linear and quadratic terms
Couenne::exprSinClass for $ \sin f(x)$
Couenne::exprStoreStorage class for previously evaluated expressions
Couenne::exprSubClass for subtraction, $ f(x) - g(x) $
Couenne::exprSumClass sum, $ \sum_{i=1}^n f_i(x) $
Couenne::exprTrilinearClass for multiplications
Couenne::exprUBCosClass to compute lower bound of a cosine based on the bounds of its arguments
Couenne::exprUBDivClass to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUBMulClass to compute upper bound of a product based on the bounds of both factors
Couenne::exprUBQuadClass to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUBSinClass to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprUnaryExpression class for unary functions (sin, log, etc
Couenne::exprUpperBoundUpper bound
Couenne::exprVarVariable-type operator
Couenne::funtriplet
Couenne::GlobalCutOff
Couenne::InitHeuristicA heuristic that stores the initial solution of the NLP
Couenne::kpowertriplet
less_than_str
Couenne::LinMap
Couenne::MultiProdRelIdentifies 5-ples of variables of the form
myclass
myclass0
Nauty
Couenne::CouenneInfo::NlpSolutionClass for storing an Nlp Solution
Couenne::NlpSolveHeuristic
Node
Couenne::powertriplet
Couenne::PowRelIdentifies 5-tuple of the form
Couenne::QrootClass that stores result of previous calls to rootQ into a map for faster access
Couenne::quadElem
Couenne::QuadMap
Couenne::simpletriplet
Couenne::SmartAsl
Couenne::SumLogAuxRelIdentifies 5-ples of variables of the form
Couenne::t_chg_boundsStatus 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

Generated on 13 May 2015 for Couenne by  doxygen 1.6.1