Couenne 0.5.8
Loading...
Searching...
No Matches
Classes | Typedefs | Enumerations | Functions | Variables
Couenne Namespace Reference

general include file for different compilers More...

Classes

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

Typedefs

typedef Ipopt::SmartPtr< Ipopt::JournalistJnlstPtr
 
typedef Ipopt::SmartPtr< const Ipopt::JournalistConstJnlstPtr
 
typedef double CouNumber
 main number type in Couenne
 
typedef CouNumber(* unary_function) (CouNumber)
 unary function, used in all exprUnary
 

Enumerations

enum  {
  TWO_LEFT , TWO_RIGHT , TWO_RAND , THREE_LEFT ,
  THREE_CENTER , THREE_RIGHT , THREE_RAND , BRANCH_NONE
}
 Define what kind of branching (two- or three-way) and where to start from: left, (center,) or right. More...
 
enum  { COUENNE_INFEASIBLE , COUENNE_TIGHTENED , COUENNE_FEASIBLE }
 
enum  nodeType {
  CONST =0 , VAR , UNARY , N_ARY ,
  COPY , AUX , EMPTY
}
 type of a node in an expression tree More...
 
enum  linearity_type {
  ZERO =0 , CONSTANT , LINEAR , QUADRATIC ,
  NONLINEAR
}
 linearity of an expression, as returned by the method Linearity() More...
 
enum  pos { PRE =0 , POST , INSIDE , NONE }
 position where the operator should be printed when printing the expression More...
 
enum  con_sign { COUENNE_EQ , COUENNE_LE , COUENNE_GE , COUENNE_RNG }
 sign of constraint More...
 
enum  conv_type { CURRENT_ONLY , UNIFORM_GRID , AROUND_CURPOINT }
 position and number of convexification cuts added for a lower convex (upper concave) envelope More...
 
enum  expr_type {
  COU_EXPRESSION , COU_EXPRCONST , COU_EXPRVAR , COU_EXPRLBOUND ,
  COU_EXPRUBOUND , COU_EXPROP , COU_EXPRSUB , COU_EXPRSUM ,
  COU_EXPRGROUP , COU_EXPRQUAD , COU_EXPRMIN , COU_EXPRMUL ,
  COU_EXPRTRILINEAR , COU_EXPRPOW , COU_EXPRSIGNPOW , COU_EXPRMAX ,
  COU_EXPRDIV , COU_EXPRUNARY , COU_EXPRCOS , COU_EXPRABS ,
  COU_EXPREXP , COU_EXPRINV , COU_EXPRLOG , COU_EXPROPP ,
  COU_EXPRSIN , COU_EXPRFLOOR , COU_EXPRCEIL , MAX_COU_EXPR_CODE
}
 code returned by the method expression::code() More...
 
enum  convexity {
  UNSET , NONCONVEX , CONVEX , CONCAVE ,
  AFFINE , CONV_LINEAR , CONV_CONSTANT , CONV_ZERO
}
 convexity type of an expression More...
 
enum  monotonicity {
  MON_UNSET , NONMONOTONE , NDECREAS , NINCREAS ,
  INCLIN , DECLIN , MON_CONST , MON_ZERO
}
 monotonicity type of an expression More...
 
enum  dig_type { ORIG_ONLY , STOP_AT_AUX , TAG_AND_RECURSIVE , COUNT }
 type of digging when filling the dependence list More...
 
enum  cou_trig { COU_SINE , COU_COSINE }
 specify which trigonometric function is dealt with in trigEnvelope More...
 
enum  what_to_compare {
  SUM_NINF = 0 , SUM_INF , OBJVAL , ALL_VARS ,
  INTEGER_VARS
}
 what term to compare: the sum of infeasibilities, the sum of numbers of infeasible terms, or the objective function More...
 
enum  Solver { EIpopt =0 , EFilterSQP , EAll }
 Solvers for solving nonlinear programs. More...
 
enum  TrilinDecompType { rAI , treeDecomp , bi_tri , tri_bi }
 

Functions

CouNumber minMaxDelta (funtriplet *ft, CouNumber lb, CouNumber ub)
 
CouNumber maxHeight (funtriplet *ft, CouNumber lb, CouNumber ub)
 
CouNumber project (CouNumber a, CouNumber b, CouNumber c, CouNumber x0, CouNumber y0, CouNumber lb, CouNumber ub, int sign, CouNumber *xp=NULL, CouNumber *yp=NULL)
 Compute projection of point (x0, y0) on the segment defined by line ax + by + c <>= 0 (sign provided by parameter sign) and bounds [lb, ub] on x.
 
CouNumber projectSeg (CouNumber x0, CouNumber y0, CouNumber x1, CouNumber y1, CouNumber x2, CouNumber y2, int sign, CouNumber *xp=NULL, CouNumber *yp=NULL)
 Compute projection of point (x0, y0) on the segment defined by two points (x1,y1), (x2, y2) – sign provided by parameter sign.
 
void sparse2dense (int ncols, t_chg_bounds *chg_bds, int *&changed, int &nchanged)
 translate sparse to dense vector (should be replaced)
 
bool operator< (const CouenneScalar &first, const CouenneScalar &second)
 
void CoinInvN (register const double *orig, register int n, register double *inverted)
 invert all contents
 
void CoinCopyDisp (register const int *src, register int num, register int *dst, register int displacement)
 a CoinCopyN with a += on each element
 
void draw_cuts (OsiCuts &, const CouenneCutGenerator *, int, expression *, expression *)
 allow to draw function within intervals and cuts introduced
 
bool updateBound (register int sign, register CouNumber *dst, register CouNumber src)
 updates maximum violation.
 
int compareExpr (const void *e0, const void *e1)
 independent comparison
 
bool isInteger (CouNumber x)
 is this number integer?
 
expressiongetOriginal (expression *e)
 get original expression (can't make it an expression method as I need a non-const, what "this" would return)
 
expressionSimplified (expression *complicated)
 Macro to return already simplified expression without having to do the if part every time simplify () is called.
 
CouNumber zero_fun (CouNumber x)
 zero function (used by default by exprUnary)
 
CouExpr operator+ (CouExpr &e1, CouExpr &e2)
 
CouExproperator/ (CouExpr &e1, CouExpr &e2)
 
CouExproperator% (CouExpr &e1, CouExpr &e2)
 
CouExproperator- (CouExpr &e1, CouExpr &e2)
 
CouExproperator* (CouExpr &e1, CouExpr &e2)
 
CouExproperator^ (CouExpr &e1, CouExpr &e2)
 
CouExprsin (CouExpr &e)
 
CouExprcos (CouExpr &e)
 
CouExprlog (CouExpr &e)
 
CouExprexp (CouExpr &e)
 
CouExproperator+ (CouNumber &e1, CouExpr &e2)
 
CouExproperator/ (CouNumber &e1, CouExpr &e2)
 
CouExproperator% (CouNumber &e1, CouExpr &e2)
 
CouExproperator- (CouNumber &e1, CouExpr &e2)
 
CouExproperator* (CouNumber &e1, CouExpr &e2)
 
CouExproperator^ (CouNumber &e1, CouExpr &e2)
 
CouExprsin (CouNumber &e)
 
CouExprcos (CouNumber &e)
 
CouExprlog (CouNumber &e)
 
CouExprexp (CouNumber &e)
 
CouExproperator+ (CouExpr &e1, CouNumber &e2)
 
CouExproperator/ (CouExpr &e1, CouNumber &e2)
 
CouExproperator% (CouExpr &e1, CouNumber &e2)
 
CouExproperator- (CouExpr &e1, CouNumber &e2)
 
CouExproperator* (CouExpr &e1, CouNumber &e2)
 
CouExproperator^ (CouExpr &e1, CouNumber &e2)
 
static CouNumber safeDiv (register CouNumber a, register CouNumber b, int sign)
 division that avoids NaN's and considers a sign when returning infinity
 
CouNumber safeProd (register CouNumber a, register CouNumber b)
 product that avoids NaN's
 
CouNumber trigNewton (CouNumber, CouNumber, CouNumber)
 common convexification method used by both cos and sin
 
bool is_boundbox_regular (register CouNumber b1, register CouNumber b2)
 check if bounding box is suitable for a multiplication/division convexification constraint
 
CouNumber inv (register CouNumber arg)
 the operator itself
 
CouNumber oppInvSqr (register CouNumber x)
 derivative of inv (x)
 
CouNumber inv_dblprime (register CouNumber x)
 inv_dblprime, second derivative of inv (x)
 
void unifiedProdCuts (const CouenneCutGenerator *, OsiCuts &, int, CouNumber, CouNumber, CouNumber, int, CouNumber, CouNumber, CouNumber, int, CouNumber, CouNumber, CouNumber, t_chg_bounds *, enum expression::auxSign)
 unified convexification of products and divisions
 
void upperEnvHull (const CouenneCutGenerator *cg, OsiCuts &cs, int xi, CouNumber x0, CouNumber xl, CouNumber xu, int yi, CouNumber y0, CouNumber yl, CouNumber yu, int wi, CouNumber w0, CouNumber wl, CouNumber wu)
 better cuts than those from unifiedProdCuts
 
double * computeMulBrDist (const OsiBranchingInformation *info, int xi, int yi, int wi, int brind, double *brpt, int nPts=1)
 compute distance from future convexifications in set $\{(x,y,w):
w = xy\}$ with x,y,w bounded.
 
CouNumber opp (register CouNumber arg)
 operator opp: returns the opposite of a number
 
CouNumber safe_pow (CouNumber base, CouNumber exponent, bool signpower=false)
 compute power and check for integer-and-odd inverse exponent
 
void addPowEnvelope (const CouenneCutGenerator *, OsiCuts &, int, int, CouNumber, CouNumber, CouNumber, CouNumber, CouNumber, int, bool=false)
 add upper/lower envelope to power in convex/concave areas
 
CouNumber powNewton (CouNumber, CouNumber, unary_function, unary_function, unary_function)
 find proper tangent point to add deepest tangent cut
 
CouNumber powNewton (CouNumber, CouNumber, funtriplet *)
 find proper tangent point to add deepest tangent cut
 
CouNumber modulo (register CouNumber a, register CouNumber b)
 normalize angle within [0,b] (typically, pi or 2pi)
 
CouNumber trigSelBranch (const CouenneObject *obj, const OsiBranchingInformation *info, expression *&var, double *&brpts, double *&brDist, int &way, enum cou_trig type)
 generalized procedure for both sine and cosine
 
bool trigImpliedBound (enum cou_trig, int, int, CouNumber *, CouNumber *, t_chg_bounds *)
 generalized implied bound procedure for sine/cosine
 
bool operator< (const CouenneFPsolution &one, const CouenneFPsolution &two)
 compare, base version
 
const Ipopt::EJournalCategory J_BRANCHING (Ipopt::J_USER1)
 
const Ipopt::EJournalCategory J_BOUNDTIGHTENING (Ipopt::J_USER2)
 
const Ipopt::EJournalCategory J_CONVEXIFYING (Ipopt::J_USER3)
 
const Ipopt::EJournalCategory J_PROBLEM (Ipopt::J_USER4)
 
const Ipopt::EJournalCategory J_NLPHEURISTIC (Ipopt::J_USER5)
 
const Ipopt::EJournalCategory J_DISJCUTS (Ipopt::J_USER6)
 
const Ipopt::EJournalCategory J_REFORMULATE (Ipopt::J_USER7)
 
const Ipopt::EJournalCategory J_COUENNE (Ipopt::J_USER8)
 
CouNumber rootQ (int k)
 Find roots of polynomial $Q^k(x) = $\sum_{i=1}^{2k} i x^{i-1}$.
 

Variables

const CouNumber default_alpha = 0.25
 
const CouNumber default_clamp = 0.2
 
const CouNumber max_pseudocost = 1000.
 
const double large_bound = 1e9
 if |branching point| > this, change it
 
const CouNumber closeToBounds = .05
 
const double Couenne_large_bound = 9.999e12
 used to declare LP unbounded
 
const double maxNlpInf_0 = 1e-5
 A heuristic to call an NlpSolver if all CouenneObjects are close to be satisfied (for other integer objects, rounding is performed, if SOS's are not satisfied it does not run).
 
static enum Couenne::what_to_compare comparedTerm_
 
const CouNumber feas_tolerance_default = 1e-5
 

Detailed Description

general include file for different compilers

Typedef Documentation

◆ JnlstPtr

Definition at line 34 of file CouenneExprVar.hpp.

◆ ConstJnlstPtr

Definition at line 35 of file CouenneExprVar.hpp.

◆ CouNumber

typedef double Couenne::CouNumber

main number type in Couenne

Definition at line 100 of file CouenneTypes.hpp.

◆ unary_function

typedef CouNumber(* Couenne::unary_function) (CouNumber)

unary function, used in all exprUnary

Definition at line 103 of file CouenneTypes.hpp.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Define what kind of branching (two- or three-way) and where to start from: left, (center,) or right.

The last is to help diversify branching through randomization, which may help when the same variable is branched upon in several points of the BB tree.

Enumerator
TWO_LEFT 
TWO_RIGHT 
TWO_RAND 
THREE_LEFT 
THREE_CENTER 
THREE_RIGHT 
THREE_RAND 
BRANCH_NONE 

Definition at line 40 of file CouenneObject.hpp.

◆ anonymous enum

anonymous enum
Enumerator
COUENNE_INFEASIBLE 
COUENNE_TIGHTENED 
COUENNE_FEASIBLE 

Definition at line 30 of file CouenneDisjCuts.hpp.

◆ nodeType

type of a node in an expression tree

Enumerator
CONST 
VAR 
UNARY 
N_ARY 
COPY 
AUX 
EMPTY 

Definition at line 20 of file CouenneTypes.hpp.

◆ linearity_type

linearity of an expression, as returned by the method Linearity()

Enumerator
ZERO 
CONSTANT 
LINEAR 
QUADRATIC 
NONLINEAR 

Definition at line 23 of file CouenneTypes.hpp.

◆ pos

position where the operator should be printed when printing the expression

For instance, it is INSIDE for exprSum, exprMul, exprDiv, while it is PRE for exprLog, exprSin, exprExp...

Enumerator
PRE 
POST 
INSIDE 
NONE 

Definition at line 30 of file CouenneTypes.hpp.

◆ con_sign

sign of constraint

Enumerator
COUENNE_EQ 
COUENNE_LE 
COUENNE_GE 
COUENNE_RNG 

Definition at line 33 of file CouenneTypes.hpp.

◆ conv_type

position and number of convexification cuts added for a lower convex (upper concave) envelope

Enumerator
CURRENT_ONLY 
UNIFORM_GRID 
AROUND_CURPOINT 

Definition at line 37 of file CouenneTypes.hpp.

◆ expr_type

code returned by the method expression::code()

Enumerator
COU_EXPRESSION 
COU_EXPRCONST 
COU_EXPRVAR 
COU_EXPRLBOUND 
COU_EXPRUBOUND 
COU_EXPROP 
COU_EXPRSUB 
COU_EXPRSUM 
COU_EXPRGROUP 
COU_EXPRQUAD 
COU_EXPRMIN 
COU_EXPRMUL 
COU_EXPRTRILINEAR 
COU_EXPRPOW 
COU_EXPRSIGNPOW 
COU_EXPRMAX 
COU_EXPRDIV 
COU_EXPRUNARY 
COU_EXPRCOS 
COU_EXPRABS 
COU_EXPREXP 
COU_EXPRINV 
COU_EXPRLOG 
COU_EXPROPP 
COU_EXPRSIN 
COU_EXPRFLOOR 
COU_EXPRCEIL 
MAX_COU_EXPR_CODE 

Definition at line 40 of file CouenneTypes.hpp.

◆ convexity

convexity type of an expression

Enumerator
UNSET 
NONCONVEX 
CONVEX 
CONCAVE 
AFFINE 
CONV_LINEAR 
CONV_CONSTANT 
CONV_ZERO 

Definition at line 56 of file CouenneTypes.hpp.

◆ monotonicity

monotonicity type of an expression

Enumerator
MON_UNSET 
NONMONOTONE 
NDECREAS 
NINCREAS 
INCLIN 
DECLIN 
MON_CONST 
MON_ZERO 

Definition at line 59 of file CouenneTypes.hpp.

◆ dig_type

type of digging when filling the dependence list

Enumerator
ORIG_ONLY 
STOP_AT_AUX 
TAG_AND_RECURSIVE 
COUNT 

Definition at line 62 of file CouenneTypes.hpp.

◆ cou_trig

specify which trigonometric function is dealt with in trigEnvelope

Enumerator
COU_SINE 
COU_COSINE 

Definition at line 23 of file CouenneExprSin.hpp.

◆ what_to_compare

what term to compare: the sum of infeasibilities, the sum of numbers of infeasible terms, or the objective function

Enumerator
SUM_NINF 
SUM_INF 
OBJVAL 
ALL_VARS 
INTEGER_VARS 

Definition at line 29 of file CouenneFPpool.hpp.

◆ Solver

Solvers for solving nonlinear programs.

Enumerator
EIpopt 

Ipopt interior point algorithm

EFilterSQP 

filterSQP Sequential Quadratic Programming algorithm

EAll 

Use all solvers.

Definition at line 47 of file CouenneMINLPInterface.hpp.

◆ TrilinDecompType

Enumerator
rAI 
treeDecomp 
bi_tri 
tri_bi 

Definition at line 136 of file CouenneProblem.hpp.

Function Documentation

◆ minMaxDelta()

CouNumber Couenne::minMaxDelta ( funtriplet * ft,
CouNumber lb,
CouNumber ub )

◆ maxHeight()

CouNumber Couenne::maxHeight ( funtriplet * ft,
CouNumber lb,
CouNumber ub )

◆ project()

CouNumber Couenne::project ( CouNumber a,
CouNumber b,
CouNumber c,
CouNumber x0,
CouNumber y0,
CouNumber lb,
CouNumber ub,
int sign,
CouNumber * xp = NULL,
CouNumber * yp = NULL )

Compute projection of point (x0, y0) on the segment defined by line ax + by + c <>= 0 (sign provided by parameter sign) and bounds [lb, ub] on x.

Return distance from segment, 0 if satisfied

◆ projectSeg()

CouNumber Couenne::projectSeg ( CouNumber x0,
CouNumber y0,
CouNumber x1,
CouNumber y1,
CouNumber x2,
CouNumber y2,
int sign,
CouNumber * xp = NULL,
CouNumber * yp = NULL )

Compute projection of point (x0, y0) on the segment defined by two points (x1,y1), (x2, y2) – sign provided by parameter sign.

Return distance from segment, 0 if on it.

◆ sparse2dense()

void Couenne::sparse2dense ( int ncols,
t_chg_bounds * chg_bds,
int *& changed,
int & nchanged )

translate sparse to dense vector (should be replaced)

◆ operator<() [1/2]

bool Couenne::operator< ( const CouenneScalar & first,
const CouenneScalar & second )
inline

Definition at line 62 of file CouenneMatrix.hpp.

◆ CoinInvN()

void Couenne::CoinInvN ( register const double * orig,
register int n,
register double * inverted )
inline

invert all contents

Definition at line 194 of file CouenneDisjCuts.hpp.

◆ CoinCopyDisp()

void Couenne::CoinCopyDisp ( register const int * src,
register int num,
register int * dst,
register int displacement )
inline

a CoinCopyN with a += on each element

Definition at line 203 of file CouenneDisjCuts.hpp.

◆ draw_cuts()

void Couenne::draw_cuts ( OsiCuts & ,
const CouenneCutGenerator * ,
int ,
expression * ,
expression *  )

allow to draw function within intervals and cuts introduced

◆ updateBound()

bool Couenne::updateBound ( register int sign,
register CouNumber * dst,
register CouNumber src )
inline

updates maximum violation.

Used with all impliedBound. Returns true if a bound has been modified, false otherwise

Definition at line 279 of file CouenneExpression.hpp.

◆ compareExpr()

int Couenne::compareExpr ( const void * e0,
const void * e1 )
inline

independent comparison

Definition at line 304 of file CouenneExpression.hpp.

◆ isInteger()

bool Couenne::isInteger ( CouNumber x)
inline

is this number integer?

Definition at line 309 of file CouenneExpression.hpp.

◆ getOriginal()

expression * Couenne::getOriginal ( expression * e)
inline

get original expression (can't make it an expression method as I need a non-const, what "this" would return)

Definition at line 315 of file CouenneExpression.hpp.

◆ Simplified()

expression * Couenne::Simplified ( expression * complicated)
inline

Macro to return already simplified expression without having to do the if part every time simplify () is called.

Definition at line 323 of file CouenneExpression.hpp.

◆ zero_fun()

CouNumber Couenne::zero_fun ( CouNumber x)
inline

zero function (used by default by exprUnary)

Definition at line 22 of file CouenneExprUnary.hpp.

◆ operator+() [1/3]

CouExpr Couenne::operator+ ( CouExpr & e1,
CouExpr & e2 )

◆ operator/() [1/3]

CouExpr & Couenne::operator/ ( CouExpr & e1,
CouExpr & e2 )

◆ operator%() [1/3]

CouExpr & Couenne::operator% ( CouExpr & e1,
CouExpr & e2 )

◆ operator-() [1/3]

CouExpr & Couenne::operator- ( CouExpr & e1,
CouExpr & e2 )

◆ operator*() [1/3]

CouExpr & Couenne::operator* ( CouExpr & e1,
CouExpr & e2 )

◆ operator^() [1/3]

CouExpr & Couenne::operator^ ( CouExpr & e1,
CouExpr & e2 )

◆ sin() [1/2]

CouExpr & Couenne::sin ( CouExpr & e)

◆ cos() [1/2]

CouExpr & Couenne::cos ( CouExpr & e)

◆ log() [1/2]

CouExpr & Couenne::log ( CouExpr & e)

◆ exp() [1/2]

CouExpr & Couenne::exp ( CouExpr & e)

◆ operator+() [2/3]

CouExpr & Couenne::operator+ ( CouNumber & e1,
CouExpr & e2 )

◆ operator/() [2/3]

CouExpr & Couenne::operator/ ( CouNumber & e1,
CouExpr & e2 )

◆ operator%() [2/3]

CouExpr & Couenne::operator% ( CouNumber & e1,
CouExpr & e2 )

◆ operator-() [2/3]

CouExpr & Couenne::operator- ( CouNumber & e1,
CouExpr & e2 )

◆ operator*() [2/3]

CouExpr & Couenne::operator* ( CouNumber & e1,
CouExpr & e2 )

◆ operator^() [2/3]

CouExpr & Couenne::operator^ ( CouNumber & e1,
CouExpr & e2 )

◆ sin() [2/2]

CouExpr & Couenne::sin ( CouNumber & e)

◆ cos() [2/2]

CouExpr & Couenne::cos ( CouNumber & e)

◆ log() [2/2]

CouExpr & Couenne::log ( CouNumber & e)

◆ exp() [2/2]

CouExpr & Couenne::exp ( CouNumber & e)

◆ operator+() [3/3]

CouExpr & Couenne::operator+ ( CouExpr & e1,
CouNumber & e2 )

◆ operator/() [3/3]

CouExpr & Couenne::operator/ ( CouExpr & e1,
CouNumber & e2 )

◆ operator%() [3/3]

CouExpr & Couenne::operator% ( CouExpr & e1,
CouNumber & e2 )

◆ operator-() [3/3]

CouExpr & Couenne::operator- ( CouExpr & e1,
CouNumber & e2 )

◆ operator*() [3/3]

CouExpr & Couenne::operator* ( CouExpr & e1,
CouNumber & e2 )

◆ operator^() [3/3]

CouExpr & Couenne::operator^ ( CouExpr & e1,
CouNumber & e2 )

◆ safeDiv()

static CouNumber Couenne::safeDiv ( register CouNumber a,
register CouNumber b,
int sign )
inlinestatic

division that avoids NaN's and considers a sign when returning infinity

Definition at line 19 of file CouenneExprBDiv.hpp.

◆ safeProd()

CouNumber Couenne::safeProd ( register CouNumber a,
register CouNumber b )
inline

product that avoids NaN's

Definition at line 25 of file CouenneExprBMul.hpp.

◆ trigNewton()

CouNumber Couenne::trigNewton ( CouNumber ,
CouNumber ,
CouNumber  )

common convexification method used by both cos and sin

◆ is_boundbox_regular()

bool Couenne::is_boundbox_regular ( register CouNumber b1,
register CouNumber b2 )
inline

check if bounding box is suitable for a multiplication/division convexification constraint

Definition at line 124 of file CouenneExprDiv.hpp.

◆ inv()

CouNumber Couenne::inv ( register CouNumber arg)
inline

the operator itself

Definition at line 19 of file CouenneExprInv.hpp.

◆ oppInvSqr()

CouNumber Couenne::oppInvSqr ( register CouNumber x)
inline

derivative of inv (x)

Definition at line 24 of file CouenneExprInv.hpp.

◆ inv_dblprime()

CouNumber Couenne::inv_dblprime ( register CouNumber x)
inline

inv_dblprime, second derivative of inv (x)

Definition at line 29 of file CouenneExprInv.hpp.

◆ unifiedProdCuts()

void Couenne::unifiedProdCuts ( const CouenneCutGenerator * ,
OsiCuts & ,
int ,
CouNumber ,
CouNumber ,
CouNumber ,
int ,
CouNumber ,
CouNumber ,
CouNumber ,
int ,
CouNumber ,
CouNumber ,
CouNumber ,
t_chg_bounds * ,
enum expression::auxSign  )

unified convexification of products and divisions

◆ upperEnvHull()

void Couenne::upperEnvHull ( const CouenneCutGenerator * cg,
OsiCuts & cs,
int xi,
CouNumber x0,
CouNumber xl,
CouNumber xu,
int yi,
CouNumber y0,
CouNumber yl,
CouNumber yu,
int wi,
CouNumber w0,
CouNumber wl,
CouNumber wu )

better cuts than those from unifiedProdCuts

◆ computeMulBrDist()

double * Couenne::computeMulBrDist ( const OsiBranchingInformation * info,
int xi,
int yi,
int wi,
int brind,
double * brpt,
int nPts = 1 )

compute distance from future convexifications in set $\{(x,y,w):
w = xy\}$ with x,y,w bounded.

Unified with exprDiv

◆ opp()

CouNumber Couenne::opp ( register CouNumber arg)
inline

operator opp: returns the opposite of a number

Definition at line 21 of file CouenneExprOpp.hpp.

◆ safe_pow()

CouNumber Couenne::safe_pow ( CouNumber base,
CouNumber exponent,
bool signpower = false )
inline

compute power and check for integer-and-odd inverse exponent

Definition at line 133 of file CouenneExprPow.hpp.

◆ addPowEnvelope()

void Couenne::addPowEnvelope ( const CouenneCutGenerator * ,
OsiCuts & ,
int ,
int ,
CouNumber ,
CouNumber ,
CouNumber ,
CouNumber ,
CouNumber ,
int ,
bool = false )

add upper/lower envelope to power in convex/concave areas

◆ powNewton() [1/2]

find proper tangent point to add deepest tangent cut

◆ powNewton() [2/2]

CouNumber Couenne::powNewton ( CouNumber ,
CouNumber ,
funtriplet *  )

find proper tangent point to add deepest tangent cut

◆ modulo()

CouNumber Couenne::modulo ( register CouNumber a,
register CouNumber b )
inline

normalize angle within [0,b] (typically, pi or 2pi)

Definition at line 27 of file CouenneExprSin.hpp.

◆ trigSelBranch()

CouNumber Couenne::trigSelBranch ( const CouenneObject * obj,
const OsiBranchingInformation * info,
expression *& var,
double *& brpts,
double *& brDist,
int & way,
enum cou_trig type )

generalized procedure for both sine and cosine

◆ trigImpliedBound()

bool Couenne::trigImpliedBound ( enum cou_trig,
int ,
int ,
CouNumber * ,
CouNumber * ,
t_chg_bounds *  )

generalized implied bound procedure for sine/cosine

◆ operator<() [2/2]

bool Couenne::operator< ( const CouenneFPsolution & one,
const CouenneFPsolution & two )
inline

compare, base version

Definition at line 76 of file CouenneFPpool.hpp.

◆ J_BRANCHING()

const Ipopt::EJournalCategory Couenne::J_BRANCHING ( Ipopt::J_USER1 )

◆ J_BOUNDTIGHTENING()

const Ipopt::EJournalCategory Couenne::J_BOUNDTIGHTENING ( Ipopt::J_USER2 )

◆ J_CONVEXIFYING()

const Ipopt::EJournalCategory Couenne::J_CONVEXIFYING ( Ipopt::J_USER3 )

◆ J_PROBLEM()

const Ipopt::EJournalCategory Couenne::J_PROBLEM ( Ipopt::J_USER4 )

◆ J_NLPHEURISTIC()

const Ipopt::EJournalCategory Couenne::J_NLPHEURISTIC ( Ipopt::J_USER5 )

◆ J_DISJCUTS()

const Ipopt::EJournalCategory Couenne::J_DISJCUTS ( Ipopt::J_USER6 )

◆ J_REFORMULATE()

const Ipopt::EJournalCategory Couenne::J_REFORMULATE ( Ipopt::J_USER7 )

◆ J_COUENNE()

const Ipopt::EJournalCategory Couenne::J_COUENNE ( Ipopt::J_USER8 )

◆ rootQ()

CouNumber Couenne::rootQ ( int k)

Find roots of polynomial $Q^k(x) = $\sum_{i=1}^{2k} i x^{i-1}$.

Used in convexification of powers with odd exponent

Variable Documentation

◆ default_alpha

const CouNumber Couenne::default_alpha = 0.25

Definition at line 23 of file CouenneObject.hpp.

◆ default_clamp

const CouNumber Couenne::default_clamp = 0.2

Definition at line 24 of file CouenneObject.hpp.

◆ max_pseudocost

const CouNumber Couenne::max_pseudocost = 1000.

Definition at line 25 of file CouenneObject.hpp.

◆ large_bound

const double Couenne::large_bound = 1e9

if |branching point| > this, change it

Definition at line 28 of file CouenneObject.hpp.

◆ closeToBounds

const CouNumber Couenne::closeToBounds = .05

Definition at line 33 of file CouenneObject.hpp.

◆ Couenne_large_bound

const double Couenne::Couenne_large_bound = 9.999e12

used to declare LP unbounded

Definition at line 50 of file CouennePrecisions.hpp.

◆ maxNlpInf_0

const double Couenne::maxNlpInf_0 = 1e-5

A heuristic to call an NlpSolver if all CouenneObjects are close to be satisfied (for other integer objects, rounding is performed, if SOS's are not satisfied it does not run).

Definition at line 26 of file BonNlpHeuristic.hpp.

◆ comparedTerm_

enum Couenne::what_to_compare Couenne::comparedTerm_
static

◆ feas_tolerance_default

const CouNumber Couenne::feas_tolerance_default = 1e-5

Definition at line 159 of file CouenneProblem.hpp.