# 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 | CouenneChooseStrong
class | CouenneChooseVariable
| Choose a variable for branching. More...
class | CouenneComplBranchingObject
| "Spatial" branching object for complementarity constraints. More...
class | CouenneComplObject
| OsiObject for complementarity constraints . 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 More...
class | exprBinProd
| class for with all binary More...
class | exprCeil
| class ceiling, More...
class | exprCos
| class cosine, More...
class | exprDiv
| class for divisions, More...
class | exprExp
| class for the exponential, More...
class | exprFloor
| class floor, More...
class | exprGroup
| class Group, with constant, linear and nonlinear terms: More...
class | exprIf
class | exprInv
| class inverse: More...
class | exprLog
| class logarithm, More...
class | exprMax
| class for maxima More...
class | exprMin
| class for minima More...
class | exprMultiLin
| another class for multiplications, More...
class | exprNorm
| Class for -norms, . More...
class | exprOddPow
| Power of an expression (binary operator), with constant. More...
class | exprOpp
| class opposite, More...
class | exprPow
| Power of an expression (binary operator), with constant. More...
class | exprPWLinear
class | exprQuad
| class exprQuad, with constant, linear and quadratic terms More...
class | exprSin
| class for More...
class | exprSub
| class for subtraction, More...
class | exprSum
| class sum, 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
class | CouenneSolverInterface
| Solver interface class with a pointer to a Couenne cut generator. More...
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
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?
expression * | getOriginal (expression *e)
| get original expression (can't make it an expression method as I need a non-const, what "this" would return)
CouNumber | zero_fun (CouNumber x)
| zero function (used by default by exprUnary)
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
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)
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) = .
## 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_
| what term to compare: the sum of infeasibilities, the sum of numbers of infeasible terms, or the objective function
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().

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.

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::exprUBSin::operator()(), and Couenne::exprLBSin::operator()().

CouExpr& Couenne::cos | ( | CouExpr & | e | ) |

Referenced by Couenne::exprCos::F(), Couenne::exprSin::gradientNorm(), Couenne::exprUBCos::operator()(), and Couenne::exprLBCos::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 |
| ) |  |  | `[inline, static]`

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::exprUBDiv::operator()(), and Couenne::exprLBDiv::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::exprUBMul::operator()(), and Couenne::exprLBMul::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().

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 129 of file CouenneExprPow.hpp.

References COUENNE_EPS, COUENNE_INFINITY, and COUENNE_round.

Referenced by Couenne::kpowertriplet::F(), Couenne::powertriplet::F(), Couenne::kpowertriplet::Fp(), Couenne::powertriplet::Fp(), Couenne::kpowertriplet::FpInv(), Couenne::powertriplet::FpInv(), Couenne::kpowertriplet::Fpp(), Couenne::powertriplet::Fpp(), Couenne::exprPow::operator()(), and Couenne::exprOddPow::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::exprSin::selectBranch(), and Couenne::exprCos::selectBranch().

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

generalized implied bound procedure for sine/cosine

Referenced by Couenne::exprSin::impliedBound(), and Couenne::exprCos::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) = .

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]`

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

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

const CouNumber Couenne::feas_tolerance_default = 1e-5

Definition at line 159 of file CouenneProblem.hpp.

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines