This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

AmplInterface
Couenne::CouenneInterface
Couenne::AuxRelation	Base class definition for relations between auxiliaries
Couenne::BiProdDivRel	Identifies 5-tuple of the form
Couenne::MultiProdRel	Identifies 5-ples of variables of the form
Couenne::PowRel	Identifies 5-tuple of the form
Couenne::SumLogAuxRel	Identifies 5-ples of variables of the form
Bab
Couenne::CouenneBab
BabInfo
Couenne::CouenneInfo	Bonmin class for passing info between components of branch-and-cuts
BonChooseVariable
Couenne::CouenneChooseStrong
BonminSetup
Couenne::CouenneSetup
CbcHeuristic
Couenne::CouenneFeasPump	An implementation of the Feasibility pump that uses linearization and Ipopt to find the two sequences of points
Couenne::CouenneIterativeRounding	An iterative rounding heuristic, tailored for nonconvex MINLPs
Couenne::InitHeuristic	A heuristic that stores the initial solution of the NLP
Couenne::NlpSolveHeuristic
CglCutGenerator
Couenne::CouenneAggrProbing	Cut Generator for aggressive BT; i.e., an aggressive probing
Couenne::CouenneCrossConv	Cut Generator that uses relationships between auxiliaries
Couenne::CouenneCutGenerator	Cut Generator for linear convexifications
Couenne::CouenneDisjCuts	Cut Generator for linear convexifications
Couenne::CouenneFixPoint	Cut Generator for FBBT fixpoint
Couenne::CouenneMultiVarProbe
Couenne::CouenneSdpCuts	These are cuts of the form
Couenne::CouenneTwoImplied	Cut Generator for implied bounds derived from pairs of linear (in)equalities
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::CouenneBTPerfIndicator
Couenne::CouenneConstraint	Class to represent nonlinear constraints
Couenne::CouennePSDcon	Class to represent positive semidefinite constraints //////////////////
Couenne::CouenneExprMatrix
Couenne::CouenneFPpool	Pool of solutions
Couenne::CouenneFPsolution	Class containing a solution with infeasibility evaluation
Couenne::CouenneObjective	Objective function
Couenne::CouenneProblem	Class for MINLP problems with symbolic information
Couenne::CouenneRecordBestSol
Couenne::CouenneScalar
Couenne::CouenneSparseBndVec< T >
Couenne::CouenneSparseMatrix	Class for sparse Matrixs (used in modifying distances in FP)
Couenne::CouenneSparseVector
Couenne::CouenneUserInterface
Couenne::CouenneAmplInterface
Couenne::CouenneOSInterface
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::expression	Expression base class
Couenne::exprConst	Constant-type operator
Couenne::exprCopy
Couenne::exprClone	Expression clone (points to another expression)
Couenne::exprStore	Storage class for previously evaluated expressions
Couenne::exprLBQuad	Class to compute lower bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprOp	General n-ary operator-type expression: requires argument list
Couenne::exprDiv	Class for divisions, $\frac{f(x)}{g(x)}$
Couenne::exprIf
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::exprLBSin	Class to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprMax
Couenne::exprMin
Couenne::exprMul	Class for multiplications, $\prod_{i=1}^n f_i(x)$
Couenne::exprBinProd	Class for $\prod_{i=1}^n f_i(x)$ with all binary
Couenne::exprMultiLin	Another class for multiplications, $\prod_{i=1}^n f_i(x)$
Couenne::exprTrilinear	Class for multiplications
Couenne::exprNorm	Class for -norms, $\|\| f(x)\|\|_p = \left(\sum_{i=1}^n f_i(x)^p\right)^{\frac{1}{p}}$
Couenne::exprPow	Power of an expression (binary operator), with constant
Couenne::exprEvenPow	Power of an expression (binary operator) with even exponent, with $k\in \mathbb Z$ constant even
Couenne::exprOddPow	Power of an expression (binary operator), with constant
Couenne::exprPWLinear
Couenne::exprSub	Class for subtraction,
Couenne::exprSum	Class sum, $\sum_{i=1}^n f_i(x)$
Couenne::exprGroup	Class Group, with constant, linear and nonlinear terms: $a_0 + \sum_{i=1}^n a_i x_i$
Couenne::exprQuad	Class exprQuad, with constant, linear and quadratic terms
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::exprUBSin	Class to compute lower bound of a sine based on the bounds on its arguments
Couenne::exprUBQuad	Class to compute upper bound of a fraction based on the bounds of both numerator and denominator
Couenne::exprUnary	Expression class for unary functions (sin, log, etc.)
Couenne::exprAbs	Class for
Couenne::exprCeil	Class ceiling, $\lceil f(x) \rceil$
Couenne::exprCos	Class cosine, $\cos f(x)$
Couenne::exprExp	Class for the exponential, $e^{f(x)}$
Couenne::exprFloor	Class floor, $\lfloor f(x) \rfloor$
Couenne::exprInv	Class inverse:
Couenne::exprLog	Class logarithm, $\log f(x)$
Couenne::exprOpp	Class opposite,
Couenne::exprSin	Class for $\sin f(x)$
Couenne::exprVar	Variable-type operator
Couenne::exprAux	Auxiliary variable
Couenne::exprIVar	Variable-type operator
Couenne::exprLowerBound	These are bound expression classes
Couenne::exprUpperBound	Upper bound
Couenne::ExprHess	Expression matrices
Couenne::ExprJac	Jacobian of the problem (computed through Couenne expression classes)
Couenne::exprSignPow	Power of an expression (binary operator), $f(x)\|f(x)\|^{k-1}$ with $k \in \mathbb R$ constant
Couenne::funtriplet
Couenne::powertriplet
Couenne::kpowertriplet
Couenne::simpletriplet
Couenne::GlobalCutOff
less_than_str
Couenne::LinMap
myclass
myclass0
Nauty
Node
OsiBranchingObject
Couenne::CouenneThreeWayBranchObj	Spatial, three-way branching object
OsiChooseVariable
Couenne::CouenneChooseVariable	Choose a variable for branching
OsiObject
Couenne::CouenneObject	OsiObject for auxiliary variables $w=f(x)$
Couenne::CouenneComplObject	OsiObject for complementarity constraints $x_1 x_2 \ge,\le,= 0$
Couenne::CouenneVarObject	OsiObject for variables in a MINLP
Couenne::CouenneVTObject	OsiObject for violation transfer on variables in a MINLP
OsiSolverInterface
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)
OsiSOS
Couenne::CouenneSOSObject
OsiSOSBranchingObject
Couenne::CouenneSOSBranchingObject
OsiTwoWayBranchingObject
Couenne::CouenneBranchingObject	"Spatial" branching object
Couenne::CouenneComplBranchingObject	"Spatial" branching object for complementarity constraints
Couenne::CouenneOrbitBranchingObj	"Spatial" branching object
Couenne::Qroot	Class that stores result of previous calls to rootQ into a map for faster access
Couenne::quadElem
Couenne::QuadMap
ReferencedObject
Couenne::CouenneInfo::NlpSolution	Class for storing an Nlp Solution
Couenne::SmartAsl
Ipopt::SmartPtr< T >
Ipopt::SmartPtr< Bonmin::RegisteredOptions >
Ipopt::SmartPtr< Bonmin::TMINLP >
Ipopt::SmartPtr< Couenne::SmartAsl >
Ipopt::SmartPtr< Ipopt::Journalist >
Ipopt::SmartPtr< Ipopt::OptionsList >
T
Couenne::CouenneSolverInterface< T >	Solver interface class with a pointer to a Couenne cut generator
Couenne::t_chg_bounds	Status of lower/upper bound of a variable, to be checked/modified in bound tightening
TNLP
Couenne::CouenneTNLP	Class for handling NLPs using CouenneProblem