Couenne  0.2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Classes | Typedefs | Enumerations | Functions | Variables
Couenne Namespace Reference

general include file for different compilers More...

Classes

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

Typedefs

typedef Ipopt::SmartPtr
< Ipopt::Journalist > 		JnlstPtr
 
typedef Ipopt::SmartPtr< const
Ipopt::Journalist > 		ConstJnlstPtr
 
typedef double CouNumber
 main number type in Couenne More...
 
typedef CouNumber(* unary_function )(CouNumber)
 unary function, used in all exprUnary More...
 

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. More...
 
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. More...
 
void sparse2dense (int ncols, t_chg_bounds *chg_bds, int *&changed, int &nchanged)
 translate sparse to dense vector (should be replaced) More...
 
bool operator< (const CouenneScalar &first, const CouenneScalar &second)
 
void CoinInvN (register const double *orig, register int n, register double *inverted)
 invert all contents More...
 
void CoinCopyDisp (register const int *src, register int num, register int *dst, register int displacement)
 a CoinCopyN with a += on each element More...
 
void draw_cuts (OsiCuts &, const CouenneCutGenerator *, int, expression *, expression *)
 allow to draw function within intervals and cuts introduced More...
 
bool updateBound (register int sign, register CouNumber *dst, register CouNumber src)
 updates maximum violation. More...
 
int compareExpr (const void *e0, const void *e1)
 independent comparison More...
 
bool isInteger (CouNumber x)
 is this number integer? More...
 
expression * getOriginal (expression *e)
 get original expression (can't make it an expression method as I need a non-const, what "this" would return) More...
 
expression * Simplified (expression *complicated)
 Macro to return already simplified expression without having to do the if part every time simplify () is called. More...
 
CouNumber zero_fun (CouNumber x)
 zero function (used by default by exprUnary) More...
 
CouExpr operator+ (CouExpr &e1, CouExpr &e2)
 
CouExpr & operator/ (CouExpr &e1, CouExpr &e2)
 
CouExpr & operator% (CouExpr &e1, CouExpr &e2)
 
CouExpr & operator- (CouExpr &e1, CouExpr &e2)
 
CouExpr & operator* (CouExpr &e1, CouExpr &e2)
 
CouExpr & operator^ (CouExpr &e1, CouExpr &e2)
 
CouExpr & sin (CouExpr &e)
 
CouExpr & cos (CouExpr &e)
 
CouExpr & log (CouExpr &e)
 
CouExpr & exp (CouExpr &e)
 
CouExpr & operator+ (CouNumber &e1, CouExpr &e2)
 
CouExpr & operator/ (CouNumber &e1, CouExpr &e2)
 
CouExpr & operator% (CouNumber &e1, CouExpr &e2)
 
CouExpr & operator- (CouNumber &e1, CouExpr &e2)
 
CouExpr & operator* (CouNumber &e1, CouExpr &e2)
 
CouExpr & operator^ (CouNumber &e1, CouExpr &e2)
 
CouExpr & sin (CouNumber &e)
 
CouExpr & cos (CouNumber &e)
 
CouExpr & log (CouNumber &e)
 
CouExpr & exp (CouNumber &e)
 
CouExpr & operator+ (CouExpr &e1, CouNumber &e2)
 
CouExpr & operator/ (CouExpr &e1, CouNumber &e2)
 
CouExpr & operator% (CouExpr &e1, CouNumber &e2)
 
CouExpr & operator- (CouExpr &e1, CouNumber &e2)
 
CouExpr & operator* (CouExpr &e1, CouNumber &e2)
 
CouExpr & operator^ (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 More...
 
CouNumber safeProd (register CouNumber a, register CouNumber b)
 product that avoids NaN's More...
 
CouNumber trigNewton (CouNumber, CouNumber, CouNumber)
 common convexification method used by both cos and sin More...
 
bool is_boundbox_regular (register CouNumber b1, register CouNumber b2)
 check if bounding box is suitable for a multiplication/division convexification constraint More...
 
CouNumber inv (register CouNumber arg)
 the operator itself More...
 
CouNumber oppInvSqr (register CouNumber x)
 derivative of inv (x) More...
 
CouNumber inv_dblprime (register CouNumber x)
 inv_dblprime, second derivative of inv (x) More...
 
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 More...
 
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 More...
 
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. More...
 
CouNumber opp (register CouNumber arg)
 operator opp: returns the opposite of a number More...
 
CouNumber safe_pow (CouNumber base, CouNumber exponent, bool signpower=false)
 compute power and check for integer-and-odd inverse exponent More...
 
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 More...
 
CouNumber powNewton (CouNumber, CouNumber, unary_function, unary_function, unary_function)
 find proper tangent point to add deepest tangent cut More...
 
CouNumber powNewton (CouNumber, CouNumber, funtriplet *)
 find proper tangent point to add deepest tangent cut More...
 
CouNumber modulo (register CouNumber a, register CouNumber b)
 normalize angle within [0,b] (typically, pi or 2pi) More...
 
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 More...
 
bool trigImpliedBound (enum cou_trig, int, int, CouNumber *, CouNumber *, t_chg_bounds *)
 generalized implied bound procedure for sine/cosine More...
 
bool operator< (const CouenneFPsolution &one, const CouenneFPsolution &two)
 compare, base version More...
 
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}$. More...
 

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 More...
 
const CouNumber closeToBounds = .05
 
const double Couenne_large_bound = 9.999e12
 used to declare LP unbounded More...
 
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). More...
 
static enum
Couenne::what_to_compare 		comparedTerm_
 
const CouNumber feas_tolerance_default = 1e-5
 

Detailed Description

general include file for different compilers

Typedef Documentation

typedef Ipopt::SmartPtr< Ipopt::Journalist > Couenne::JnlstPtr

Definition at line 34 of file CouenneExprVar.hpp.

typedef Ipopt::SmartPtr< const Ipopt::Journalist > Couenne::ConstJnlstPtr

Definition at line 35 of file CouenneExprVar.hpp.

typedef double Couenne::CouNumber

main number type in Couenne

Definition at line 100 of file CouenneTypes.hpp.

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

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
Enumerator
COUENNE_INFEASIBLE 
COUENNE_TIGHTENED 
COUENNE_FEASIBLE 

Definition at line 30 of file CouenneDisjCuts.hpp.

enum Couenne::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.

enum Couenne::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.

enum Couenne::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.

enum Couenne::con_sign

sign of constraint

Enumerator
COUENNE_EQ 
COUENNE_LE 
COUENNE_GE 
COUENNE_RNG 

Definition at line 33 of file CouenneTypes.hpp.

enum Couenne::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.

enum Couenne::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.

enum Couenne::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.

enum Couenne::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.

enum Couenne::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.

enum Couenne::cou_trig

specify which trigonometric function is dealt with in trigEnvelope

Enumerator
COU_SINE 
COU_COSINE 

Definition at line 23 of file CouenneExprSin.hpp.

enum Couenne::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.

enum Couenne::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.

enum Couenne::TrilinDecompType
Enumerator
rAI 
treeDecomp 
bi_tri 
tri_bi 

Definition at line 136 of file CouenneProblem.hpp.

Function Documentation

CouNumber Couenne::minMaxDelta ( funtriplet *  ft,
CouNumber  lb,
CouNumber  ub 
)
CouNumber Couenne::maxHeight ( funtriplet *  ft,
CouNumber  lb,
CouNumber  ub 
)
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

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.

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

translate sparse to dense vector (should be replaced)

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

Definition at line 62 of file CouenneMatrix.hpp.

References Couenne::CouenneScalar::index_.

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.

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.

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

allow to draw function within intervals and cuts introduced

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.

References COUENNE_EPS.

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

independent comparison

Definition at line 304 of file CouenneExpression.hpp.

bool Couenne::isInteger ( CouNumber  x)
inline

is this number integer?

Definition at line 309 of file CouenneExpression.hpp.

References COUENNE_EPS_INT, and COUENNE_round.

Referenced by Couenne::CouenneObject::isCuttable(), and Couenne::exprConst::isInteger().

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.

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.

CouNumber Couenne::zero_fun ( CouNumber  x)
inline

zero function (used by default by exprUnary)

Definition at line 22 of file CouenneExprUnary.hpp.

Referenced by Couenne::exprUnary::F().

CouExpr Couenne::operator+ ( CouExpr &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator/ ( CouExpr &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator% ( CouExpr &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator- ( CouExpr &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator* ( CouExpr &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator^ ( CouExpr &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::sin ( CouExpr &  e)

Referenced by Couenne::exprSin::F(), Couenne::exprCos::gradientNorm(), Couenne::exprLBSin::operator()(), and Couenne::exprUBSin::operator()().

CouExpr& Couenne::cos ( CouExpr &  e)

Referenced by Couenne::exprCos::F(), Couenne::exprSin::gradientNorm(), Couenne::exprLBCos::operator()(), and Couenne::exprUBCos::operator()().

CouExpr& Couenne::log ( CouExpr &  e)

Referenced by Couenne::exprLog::F(), and Couenne::exprExp::inverse().

CouExpr& Couenne::exp ( CouExpr &  e)

Referenced by Couenne::exprExp::F(), Couenne::exprExp::gradientNorm(), and Couenne::exprLog::inverse().

CouExpr& Couenne::operator+ ( CouNumber &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator/ ( CouNumber &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator% ( CouNumber &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator- ( CouNumber &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator* ( CouNumber &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::operator^ ( CouNumber &  e1,
CouExpr &  e2 
)
CouExpr& Couenne::sin ( CouNumber &  e)
CouExpr& Couenne::cos ( CouNumber &  e)
CouExpr& Couenne::log ( CouNumber &  e)
CouExpr& Couenne::exp ( CouNumber &  e)
CouExpr& Couenne::operator+ ( CouExpr &  e1,
CouNumber &  e2 
)
CouExpr& Couenne::operator/ ( CouExpr &  e1,
CouNumber &  e2 
)
CouExpr& Couenne::operator% ( CouExpr &  e1,
CouNumber &  e2 
)
CouExpr& Couenne::operator- ( CouExpr &  e1,
CouNumber &  e2 
)
CouExpr& Couenne::operator* ( CouExpr &  e1,
CouNumber &  e2 
)
CouExpr& Couenne::operator^ ( CouExpr &  e1,
CouNumber &  e2 
)
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.

References COUENNE_EPS, and COUENNE_INFINITY.

Referenced by Couenne::exprLBDiv::operator()(), and Couenne::exprUBDiv::operator()().

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

product that avoids NaN's

Definition at line 25 of file CouenneExprBMul.hpp.

References MUL_INF, and MUL_ZERO.

Referenced by Couenne::exprLBMul::operator()(), and Couenne::exprUBMul::operator()().

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

common convexification method used by both cos and sin

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.

References SAFE_COEFFICIENT.

CouNumber Couenne::inv ( register CouNumber  arg)
inline

the operator itself

Definition at line 19 of file CouenneExprInv.hpp.

Referenced by Couenne::exprInv::F(), inv_dblprime(), and oppInvSqr().

CouNumber Couenne::oppInvSqr ( register CouNumber  x)
inline

derivative of inv (x)

Definition at line 24 of file CouenneExprInv.hpp.

References inv().

CouNumber Couenne::inv_dblprime ( register CouNumber  x)
inline

inv_dblprime, second derivative of inv (x)

Definition at line 29 of file CouenneExprInv.hpp.

References inv().

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

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

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

CouNumber Couenne::opp ( register CouNumber  arg)
inline

operator opp: returns the opposite of a number

Definition at line 21 of file CouenneExprOpp.hpp.

Referenced by Couenne::exprOpp::F().

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.

References COUENNE_EPS, COUENNE_INFINITY, and COUENNE_round.

Referenced by Couenne::powertriplet::F(), Couenne::kpowertriplet::F(), Couenne::powertriplet::Fp(), Couenne::kpowertriplet::Fp(), Couenne::powertriplet::FpInv(), Couenne::kpowertriplet::FpInv(), Couenne::powertriplet::Fpp(), Couenne::kpowertriplet::Fpp(), Couenne::exprSignPow::operator()(), Couenne::exprEvenPow::operator()(), Couenne::exprOddPow::operator()(), and Couenne::exprPow::operator()().

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

CouNumber Couenne::powNewton ( CouNumber  ,
CouNumber  ,
unary_function  ,
unary_function  ,
unary_function   
)

find proper tangent point to add deepest tangent cut

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

find proper tangent point to add deepest tangent cut

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.

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

Referenced by Couenne::exprCos::selectBranch(), and Couenne::exprSin::selectBranch().

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

generalized implied bound procedure for sine/cosine

Referenced by Couenne::exprCos::impliedBound(), and Couenne::exprSin::impliedBound().

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

compare, base version

Definition at line 76 of file CouenneFPpool.hpp.

References Couenne::CouenneFPsolution::compare(), and comparedTerm_.

const Ipopt::EJournalCategory Couenne::J_BRANCHING ( Ipopt::J_USER1  )
const Ipopt::EJournalCategory Couenne::J_BOUNDTIGHTENING ( Ipopt::J_USER2  )
const Ipopt::EJournalCategory Couenne::J_CONVEXIFYING ( Ipopt::J_USER3  )
const Ipopt::EJournalCategory Couenne::J_PROBLEM ( Ipopt::J_USER4  )
const Ipopt::EJournalCategory Couenne::J_NLPHEURISTIC ( Ipopt::J_USER5  )
const Ipopt::EJournalCategory Couenne::J_DISJCUTS ( Ipopt::J_USER6  )
const Ipopt::EJournalCategory Couenne::J_REFORMULATE ( Ipopt::J_USER7  )
const Ipopt::EJournalCategory Couenne::J_COUENNE ( Ipopt::J_USER8  )
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

Referenced by Couenne::Qroot::operator()().

Variable Documentation

const CouNumber Couenne::default_alpha = 0.25

Definition at line 23 of file CouenneObject.hpp.

const CouNumber Couenne::default_clamp = 0.2

Definition at line 24 of file CouenneObject.hpp.

const CouNumber Couenne::max_pseudocost = 1000.

Definition at line 25 of file CouenneObject.hpp.

const double Couenne::large_bound = 1e9

if |branching point| > this, change it

Definition at line 28 of file CouenneObject.hpp.

const CouNumber Couenne::closeToBounds = .05

Definition at line 33 of file CouenneObject.hpp.

const double Couenne::Couenne_large_bound = 9.999e12

used to declare LP unbounded

Definition at line 50 of file CouennePrecisions.hpp.

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.

enum Couenne::what_to_compare Couenne::comparedTerm_
static

Referenced by Couenne::CouenneFPpool::CouenneFPpool(), and operator<().

const CouNumber Couenne::feas_tolerance_default = 1e-5

Definition at line 159 of file CouenneProblem.hpp.

Generated by   doxygen 1.8.5