Classes | |
class | CouenneAggrProbing |
Cut Generator for aggressive BT; i.e., an aggressive probing. More... | |
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... | |
struct | threshold |
struct | indPosPair |
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 ![]() | |
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 | 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 |
lower bound 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 ![]() | |
class | exprBinProd |
class for ![]() ![]() | |
class | exprCeil |
class ceiling, ![]() | |
class | exprCos |
class cosine, ![]() | |
class | exprDiv |
class for divisions, ![]() | |
class | exprExp |
class for the exponential, ![]() | |
class | exprFloor |
class floor, ![]() | |
class | exprGroup |
class Group, with constant, linear and nonlinear terms: ![]() | |
class | exprIf |
class | exprInv |
class inverse: ![]() | |
class | exprLog |
class logarithm, ![]() | |
class | exprMax |
class for maxima More... | |
class | exprMin |
class for minima More... | |
class | exprMultiLin |
another class for multiplications, ![]() | |
class | exprNorm |
Class for ![]() ![]() | |
class | exprOddPow |
Power of an expression (binary operator), ![]() ![]() | |
class | exprOpp |
class opposite, ![]() | |
class | exprPow |
Power of an expression (binary operator), ![]() ![]() | |
class | exprPWLinear |
class | exprQuad |
class exprQuad, with constant, linear and quadratic terms More... | |
class | exprSin |
class for ![]() | |
class | exprSub |
class for subtraction, ![]() | |
class | exprSum |
class sum, ![]() | |
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 |
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 | 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 | |
typedef Ipopt::SmartPtr< Ipopt::Journalist > | JnlstPtr |
typedef Ipopt::SmartPtr< const Ipopt::Journalist > | ConstJnlstPtr |
typedef Ipopt::SmartPtr< Ipopt::Journalist > | JnlstPtr |
typedef Ipopt::SmartPtr< const Ipopt::Journalist > | ConstJnlstPtr |
Enumerations | |
enum | signum { NEG, POS, DN, UP } |
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_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 } |
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 | |
void | updateBranchInfo (const OsiSolverInterface &si, CouenneProblem *p, t_chg_bounds *chg, const CglTreeInfo &info) |
Get changed bounds due to branching. | |
int | combine (CouenneProblem *p, int n1, int n2, const int *ind1, const int *ind2, double *sa1, double *sa2, const double *a1, const double *a2, double *clb, double *cub, double l1, double l2, double u1, double u2, bool *isInteger, int sign) |
int | compthres (register const void *t1, register const void *t2) |
int | compPair (register const void *p1, register const void *p2) |
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. | |
static double | oppcos (double x) |
static double | oppsin (double x) |
static double | oppasin (double x) |
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 | |
double * | computeMulBrDist (const OsiBranchingInformation *info, int xi, int yi, int wi, int brind, double *brpt, int nPts) |
CouNumber | curvDistance (funtriplet *ft, CouNumber lb, CouNumber ub) |
void | sparse2dense (int ncols, t_chg_bounds *chg_bds, int *&changed, int &nchanged) |
Defined in Couenne/src/convex/generateCuts.cpp. | |
bool | isOptimumCut (const CouNumber *opt, OsiCuts &cs, CouenneProblem *p) |
void | fictitiousBound (OsiCuts &cs, CouenneProblem *p, bool action) |
void | addPowEnvelope (const CouenneCutGenerator *, OsiCuts &, int, int, CouNumber, CouNumber, CouNumber, CouNumber, CouNumber, int) |
add upper/lower envelope to power in convex/concave areas | |
int | trigEnvelope (const CouenneCutGenerator *, OsiCuts &, expression *, expression *, enum cou_trig) |
real linearization of sine/cosine | |
int | bayEnvelope (const CouenneCutGenerator *, OsiCuts &, int, int, CouNumber, CouNumber, CouNumber, bool &, bool &) |
restrict to quarter of the interval [0,2pi] | |
int | findIntersection (CouNumber x0, CouNumber y0, CouNumber x1, CouNumber y1, CouNumber *wl, CouNumber *wu, CouNumber *xA, CouNumber *yA, CouNumber *xB, CouNumber *yB) |
int | genMulCoeff (CouNumber x1, CouNumber y1, CouNumber x2, CouNumber y2, char whichUse, CouNumber &cX, CouNumber &cY, CouNumber &cW) |
void | invertInterval (register double &l, register double &u, register double x) |
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) |
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 | trigNewton (CouNumber, CouNumber, CouNumber) |
common convexification method used by both cos and sin | |
void | contourCut (const CouenneCutGenerator *cg, OsiCuts &cs, CouNumber xp, CouNumber yp, CouNumber wb, int sign, CouNumber x0, CouNumber y0, CouNumber x1, CouNumber y1, int xi, int yi, int wi) |
Add cut around curve x*y=k. | |
void | unifiedProdCuts (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, t_chg_bounds *chg, enum expression::auxSign sign) |
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 | |
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) |
compute power and check for integer-and-odd inverse exponent | |
CouNumber | modulo (register CouNumber a, register CouNumber b) |
normalize angle within [0,b] (typically, pi or 2pi) | |
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) = ![]() | |
CouNumber | Q (register int k, CouNumber 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 int | maxIter = 20 |
const double | Couenne_large_bound = 9.999e12 |
used to declare LP unbounded | |
static const CouNumber | pi = M_PI |
static const CouNumber | pi2 = M_PI * 2. |
static const CouNumber | pih = M_PI / 2. |
const double | maxNlpInf_0 = 1e-5 |
An heuristic to call an NlpSolver if all CouenneObjects are close to be satisfied (for other integer objects, rounding is performed, is SOS are not satisfied 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 |
typedef Ipopt::SmartPtr<Ipopt::Journalist> Couenne::JnlstPtr |
Definition at line 35 of file CouenneExprVar.hpp.
typedef Ipopt::SmartPtr<const Ipopt::Journalist> Couenne::ConstJnlstPtr |
Definition at line 36 of file CouenneExprVar.hpp.
typedef double Couenne::CouNumber |
typedef CouNumber(*) Couenne::unary_function(CouNumber) |
typedef Ipopt::SmartPtr<Ipopt::Journalist> Couenne::JnlstPtr |
Definition at line 21 of file CouenneJournalist.hpp.
typedef Ipopt::SmartPtr<const Ipopt::Journalist> Couenne::ConstJnlstPtr |
Definition at line 22 of file CouenneJournalist.hpp.
typedef Ipopt::SmartPtr<Ipopt::Journalist> Couenne::JnlstPtr |
Definition at line 131 of file CouenneProblem.hpp.
typedef Ipopt::SmartPtr<const Ipopt::Journalist> Couenne::ConstJnlstPtr |
Definition at line 134 of file CouenneProblem.hpp.
enum Couenne::signum |
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.
Definition at line 40 of file CouenneObject.hpp.
anonymous enum |
Definition at line 29 of file CouenneDisjCuts.hpp.
enum Couenne::nodeType |
linearity of an expression, as returned by the method Linearity()
Definition at line 23 of file CouenneTypes.hpp.
enum Couenne::pos |
enum Couenne::con_sign |
enum Couenne::conv_type |
position and number of convexification cuts added for a lower convex (upper concave) envelope
Definition at line 37 of file CouenneTypes.hpp.
enum Couenne::expr_type |
code returned by the method expression::code()
Definition at line 40 of file CouenneTypes.hpp.
enum Couenne::convexity |
enum Couenne::dig_type |
enum Couenne::cou_trig |
specify which trigonometric function is dealt with in trigEnvelope
Definition at line 23 of file CouenneExprSin.hpp.
what term to compare: the sum of infeasibilities, the sum of numbers of infeasible terms, or the objective function
Definition at line 28 of file CouenneFPpool.hpp.
enum Couenne::Solver |
Solvers for solving nonlinear programs.
EIpopt | Ipopt interior point algorithm |
EFilterSQP | filterSQP Sequential Quadratic Programming algorithm |
EAll | Use all solvers. |
Definition at line 47 of file CouenneMINLPInterface.hpp.
void Couenne::updateBranchInfo | ( | const OsiSolverInterface & | si, | |
CouenneProblem * | p, | |||
t_chg_bounds * | chg, | |||
const CglTreeInfo & | info | |||
) |
Get changed bounds due to branching.
Definition at line 21 of file updateBranchInfo.cpp.
References Couenne::t_chg_bounds::CHANGED, COUENNE_EPS, and DEBUG.
Referenced by Couenne::CouenneCutGenerator::generateCuts(), and Couenne::CouenneTwoImplied::generateCuts().
int Couenne::combine | ( | CouenneProblem * | p, | |
int | n1, | |||
int | n2, | |||
const int * | ind1, | |||
const int * | ind2, | |||
double * | sa1, | |||
double * | sa2, | |||
const double * | a1, | |||
const double * | a2, | |||
double * | clb, | |||
double * | cub, | |||
double | l1, | |||
double | l2, | |||
double | u1, | |||
double | u2, | |||
bool * | isInteger, | |||
int | sign | |||
) |
Definition at line 80 of file TwoImpliedIneqCombine.cpp.
References alpha, compPair(), compthres(), COUENNE_EPS, COUENNE_INFINITY, DN, e, MIN_DENOM, NEG, POS, and UP.
Referenced by Couenne::CouenneTwoImplied::generateCuts().
int Couenne::compthres | ( | register const void * | t1, | |
register const void * | t2 | |||
) |
int Couenne::compPair | ( | register const void * | p1, | |
register const void * | p2 | |||
) |
Definition at line 49 of file minMaxDelta.cpp.
References COUENNE_EPS, curvDistance(), and maxIter.
Referenced by Couenne::CouenneObject::getBrPoint().
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
Definition at line 22 of file projections.cpp.
References COUENNE_EPS.
Referenced by 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.
Definition at line 78 of file projections.cpp.
References a, c, and project().
Referenced by negPowSelectBranch(), Couenne::exprPow::selectBranch(), Couenne::exprLog::selectBranch(), and Couenne::exprExp::selectBranch().
static double Couenne::oppcos | ( | double | x | ) | [inline, static] |
Definition at line 20 of file branchExprSinCos.cpp.
References cos().
Referenced by trigSelBranch().
static double Couenne::oppsin | ( | double | x | ) | [inline, static] |
Definition at line 21 of file branchExprSinCos.cpp.
References sin().
Referenced by trigSelBranch().
static double Couenne::oppasin | ( | double | x | ) | [inline, static] |
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
Definition at line 26 of file branchExprSinCos.cpp.
References cos(), COU_SINE, oppasin(), oppcos(), oppsin(), and sin().
Referenced by Couenne::exprSin::selectBranch(), and Couenne::exprCos::selectBranch().
double* Couenne::computeMulBrDist | ( | const OsiBranchingInformation * | info, | |
int | xi, | |||
int | yi, | |||
int | wi, | |||
int | brind, | |||
double * | brpt, | |||
int | nPts | |||
) |
Definition at line 23 of file computeMulBrDist.cpp.
References COUENNE_EPS, and diff().
Referenced by Couenne::exprDiv::selectBranch().
void Couenne::sparse2dense | ( | int | ncols, | |
t_chg_bounds * | chg_bds, | |||
int *& | changed, | |||
int & | nchanged | |||
) |
Defined in Couenne/src/convex/generateCuts.cpp.
Definition at line 67 of file generateCuts.cpp.
References Couenne::t_chg_bounds::UNCHANGED.
Referenced by Couenne::CouenneComplBranchingObject::branch(), Couenne::CouenneBranchingObject::branch(), Couenne::CouenneCutGenerator::generateCuts(), Couenne::CouenneProblem::obbt(), and Couenne::CouenneDisjCuts::separateWithDisjunction().
bool Couenne::isOptimumCut | ( | const CouNumber * | opt, | |
OsiCuts & | cs, | |||
CouenneProblem * | p | |||
) |
Definition at line 21 of file isOptimumCut.cpp.
References COUENNE_EPS, n, and print().
Referenced by Couenne::CouenneCutGenerator::generateCuts().
void Couenne::fictitiousBound | ( | OsiCuts & | cs, | |
CouenneProblem * | p, | |||
bool | action | |||
) |
Definition at line 38 of file generateCuts.cpp.
References COUENNE_INFINITY, Couenne_large_bound2, and Couenne::CouenneProblem::Lb().
Referenced by Couenne::CouenneCutGenerator::generateCuts().
void Couenne::addPowEnvelope | ( | const CouenneCutGenerator * | cg, | |
OsiCuts & | cs, | |||
int | wi, | |||
int | xi, | |||
CouNumber | x, | |||
CouNumber | y, | |||
CouNumber | k, | |||
CouNumber | l, | |||
CouNumber | u, | |||
int | sign | |||
) |
add upper/lower envelope to power in convex/concave areas
Definition at line 26 of file conv-exprPow-envelope.cpp.
References COU_MAX_COEFF, and powNewton().
Referenced by Couenne::exprPow::generateCuts().
int Couenne::trigEnvelope | ( | const CouenneCutGenerator * | , | |
OsiCuts & | , | |||
expression * | , | |||
expression * | , | |||
enum | cou_trig | |||
) |
real linearization of sine/cosine
Definition at line 104 of file conv-exprSinCos.cpp.
References bayEnvelope(), cos(), COU_COSINE, COU_SINE, COUENNE_EPS, COUENNE_INFINITY, createCut(), f, M_PI_2, sin(), and w.
Referenced by Couenne::exprCos::generateCuts(), and Couenne::exprSin::generateCuts().
int Couenne::bayEnvelope | ( | const CouenneCutGenerator * | , | |
OsiCuts & | , | |||
int | , | |||
int | , | |||
CouNumber | , | |||
CouNumber | , | |||
CouNumber | , | |||
bool & | , | |||
bool & | ||||
) |
restrict to quarter of the interval [0,2pi]
Definition at line 146 of file conv-exprSinCos.cpp.
References Couenne::CouenneCutGenerator::addSegment(), cos(), M_PI, M_PI_2, modulo(), sin(), and trigNewton().
Referenced by trigEnvelope().
int Couenne::findIntersection | ( | CouNumber | x0, | |
CouNumber | y0, | |||
CouNumber | x1, | |||
CouNumber | y1, | |||
CouNumber * | wl, | |||
CouNumber * | wu, | |||
CouNumber * | xA, | |||
CouNumber * | yA, | |||
CouNumber * | xB, | |||
CouNumber * | yB | |||
) |
Definition at line 309 of file exprMul-upperHull.cpp.
References a, c, and COUENNE_EPS.
Referenced by upperEnvHull().
int Couenne::genMulCoeff | ( | CouNumber | x1, | |
CouNumber | y1, | |||
CouNumber | x2, | |||
CouNumber | y2, | |||
char | whichUse, | |||
CouNumber & | cX, | |||
CouNumber & | cY, | |||
CouNumber & | cW | |||
) |
Definition at line 369 of file exprMul-upperHull.cpp.
References COUENNE_EPS.
Referenced by upperEnvHull().
void Couenne::invertInterval | ( | register double & | l, | |
register double & | u, | |||
register double | x | |||
) | [inline] |
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 | |||
) |
Definition at line 42 of file exprMul-upperHull.cpp.
References COUENNE_EPS, createCut(), findIntersection(), genMulCoeff(), and invertInterval().
Referenced by unifiedProdCuts().
CouNumber Couenne::powNewton | ( | CouNumber | xc, | |
CouNumber | yc, | |||
unary_function | f, | |||
unary_function | fp, | |||
unary_function | fpp | |||
) |
find proper tangent point to add deepest tangent cut
Definition at line 29 of file powNewton.cpp.
References COU_POW_TOLERANCE, f, k, and MAX_ITER.
Referenced by addPowEnvelope(), contourCut(), Couenne::exprLog::generateCuts(), Couenne::exprInv::generateCuts(), Couenne::exprExp::generateCuts(), linQuadCutGen(), negPowSelectBranch(), Couenne::exprPow::selectBranch(), Couenne::exprLog::selectBranch(), and Couenne::exprExp::selectBranch().
find proper tangent point to add deepest tangent cut
Definition at line 75 of file powNewton.cpp.
References COU_POW_TOLERANCE, k, and MAX_ITER.
common convexification method used by both cos and sin
Definition at line 21 of file trigNewton.cpp.
References cos(), COU_TRIG_TOLERANCE, k, MAX_ITER, and sin().
Referenced by bayEnvelope().
void Couenne::contourCut | ( | const CouenneCutGenerator * | cg, | |
OsiCuts & | cs, | |||
CouNumber | xp, | |||
CouNumber | yp, | |||
CouNumber | wb, | |||
int | sign, | |||
CouNumber | x0, | |||
CouNumber | y0, | |||
CouNumber | x1, | |||
CouNumber | y1, | |||
int | xi, | |||
int | yi, | |||
int | wi | |||
) |
Add cut around curve x*y=k.
Definition at line 25 of file unifiedProdCuts.cpp.
References alpha, COUENNE_EPS, COUENNE_INFINITY, createCut(), and powNewton().
Referenced by unifiedProdCuts().
void Couenne::unifiedProdCuts | ( | 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, | |||
t_chg_bounds * | chg, | |||
enum expression::auxSign | sign | |||
) |
Definition at line 96 of file unifiedProdCuts.cpp.
References Couenne::expression::AUX_GEQ, Couenne::expression::AUX_LEQ, contourCut(), COUENNE_EPS, createCut(), is_boundbox_regular(), Couenne::t_chg_bounds::lower(), Couenne::CouenneProblem::MulSepSimple, Couenne::CouenneProblem::MulSepTight, Couenne::t_chg_bounds::UNCHANGED, Couenne::t_chg_bounds::upper(), and upperEnvHull().
Referenced by Couenne::exprDiv::generateCuts().
void Couenne::CoinInvN | ( | register const double * | orig, | |
register int | n, | |||
register double * | inverted | |||
) | [inline] |
invert all contents
Definition at line 189 of file CouenneDisjCuts.hpp.
Referenced by Couenne::CouenneDisjCuts::OsiCuts2MatrVec(), and Couenne::CouenneDisjCuts::OsiSI2MatrVec().
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 198 of file CouenneDisjCuts.hpp.
Referenced by Couenne::CouenneDisjCuts::generateDisjCuts(), and Couenne::CouenneDisjCuts::OsiCuts2MatrVec().
void Couenne::draw_cuts | ( | OsiCuts & | , | |
const CouenneCutGenerator * | , | |||
int | , | |||
expression * | , | |||
expression * | ||||
) |
allow to draw function within intervals and cuts introduced
Definition at line 21 of file drawCuts.cpp.
References COU_EXPRCOS, COU_EXPREXP, COU_EXPRLOG, COU_EXPRPOW, COU_EXPRSIN, COUENNE_EPS, COUENNE_INFINITY, N_STEPS, and x.
Referenced by Couenne::exprAux::generateCuts().
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.
Referenced by Couenne::exprSub::impliedBound(), Couenne::exprOpp::impliedBound(), Couenne::exprLog::impliedBound(), Couenne::exprExp::impliedBound(), Couenne::exprAbs::impliedBound(), Couenne::exprVar::impliedBound(), Couenne::exprSum::impliedBound(), Couenne::exprQuad::impliedBound(), Couenne::exprDiv::impliedBound(), invPowImplBounds(), and trigImpliedBound().
int Couenne::compareExpr | ( | const void * | e0, | |
const void * | e1 | |||
) | [inline] |
independent comparison
Definition at line 304 of file CouenneExpression.hpp.
References compare().
Referenced by Couenne::exprSum::exprSum(), and Couenne::exprTrilinear::exprTrilinear().
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 addDistanceConstraints(), Couenne::CouenneCutGenerator::addEnvelope(), Couenne::CouenneThreeWayBranchObj::branch(), Couenne::CouenneBranchingObject::branch(), Couenne::CouenneObject::checkInfeasibility(), compDistSingle(), Couenne::CouenneFPsolution::CouenneFPsolution(), createCloneMILP(), Couenne::CouenneInterface::extractLinearRelaxation(), Couenne::CouenneProblem::fake_tighten(), Couenne::CouenneProblem::findSOS(), Couenne::CouenneFeasPump::fixIntVariables(), Couenne::CouenneCutGenerator::genColCuts(), Couenne::CouenneTwoImplied::generateCuts(), Bonmin::OaDecompositionBase::generateCuts(), Couenne::CouenneProblem::getIntegerCandidate(), Couenne::CouenneVTObject::infeasibility(), Couenne::CouenneVarObject::infeasibility(), Couenne::CouenneObject::infeasibility(), Couenne::CouenneSetup::InitializeCouenne(), Couenne::CouenneProblem::installCutOff(), Couenne::CouenneVarObject::isCuttable(), Couenne::CouenneObject::isCuttable(), Couenne::exprConst::isInteger(), Couenne::CouenneProblem::obbt_iter(), Bonmin::OaFeasibilityChecker::performOa(), Bonmin::OACutGenerator2::performOa(), Couenne::CouenneProblem::print(), Couenne::CouenneProblem::redCostBT(), Couenne::CouenneProblem::reformulate(), replace(), Couenne::CouenneProblem::resetCutOff(), Couenne::CouenneProblem::setCutOff(), Couenne::CouenneFeasPump::solution(), Couenne::CouenneFeasPump::solveMILP(), Couenne::CouenneProblem::splitAux(), Couenne::CouenneProblem::standardize(), Couenne::CouenneConstraint::standardize(), Couenne::CouenneProblem::tightenBounds(), Couenne::CouenneSolverInterface< T >::tightenBoundsCLP(), Couenne::CouenneSolverInterface< T >::tightenBoundsCLP_Light(), Couenne::CouenneFeasPump::updateNLPObj(), Couenne::CouenneProblem::writeAMPL(), and Couenne::CouenneProblem::writeGAMS().
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.
References e.
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::sin | ( | CouExpr & | e | ) |
CouExpr& Couenne::cos | ( | CouExpr & | e | ) |
CouExpr& Couenne::log | ( | CouExpr & | e | ) |
Referenced by Couenne::exprPow::differentiate(), Couenne::exprLog::F(), Couenne::CouenneProblem::fake_tighten(), Couenne::exprLog::generateCuts(), Couenne::exprExp::generateCuts(), Couenne::exprLog::getBounds(), Couenne::exprExp::impliedBound(), Couenne::exprExp::inverse(), Couenne::exprLog::isCuttable(), Couenne::CouenneAmplInterface::nl2e(), Couenne::exprLog::selectBranch(), Couenne::exprExp::selectBranch(), and Couenne::exprPow::standardize().
CouExpr& Couenne::exp | ( | CouExpr & | e | ) |
Referenced by Couenne::exprExp::F(), Couenne::CouenneProblem::fake_tighten(), Couenne::exprExp::generateCuts(), Couenne::exprExp::getBounds(), Couenne::exprExp::gradientNorm(), Couenne::exprLog::impliedBound(), Couenne::exprLog::inverse(), Couenne::exprExp::isCuttable(), Couenne::exprLog::selectBranch(), and Couenne::exprExp::selectBranch().
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::exprDiv::getBounds(), Couenne::exprUBDiv::operator()(), and Couenne::exprLBDiv::operator()().
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()().
check if bounding box is suitable for a multiplication/division convexification constraint
Definition at line 124 of file CouenneExprDiv.hpp.
References SAFE_COEFFICIENT.
Referenced by unifiedProdCuts().
the operator itself
Definition at line 19 of file CouenneExprInv.hpp.
Referenced by Couenne::exprSin::closestFeasible(), Couenne::exprCos::closestFeasible(), Couenne::expression::closestFeasible(), Couenne::exprInv::F(), Couenne::exprLog::generateCuts(), Couenne::exprInv::generateCuts(), inv_dblprime(), oppInvSqr(), and Couenne::exprLog::selectBranch().
derivative of inv (x)
Definition at line 24 of file CouenneExprInv.hpp.
References inv().
Referenced by Couenne::exprLog::generateCuts(), Couenne::exprInv::generateCuts(), and Couenne::exprLog::selectBranch().
inv_dblprime, second derivative of inv (x)
Definition at line 29 of file CouenneExprInv.hpp.
References inv().
Referenced by Couenne::exprInv::generateCuts().
operator opp: returns the opposite of a number
Definition at line 21 of file CouenneExprOpp.hpp.
Referenced by Couenne::exprOpp::F().
compute power and check for integer-and-odd inverse exponent
Definition at line 120 of file CouenneExprPow.hpp.
References COUENNE_EPS, COUENNE_INFINITY, and COUENNE_round.
Referenced by Couenne::exprPow::closestFeasible(), 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::generateCuts(), Couenne::exprPow::getBounds(), Couenne::exprPow::gradientNorm(), Couenne::exprPow::isCuttable(), negPowSelectBranch(), Couenne::exprPow::operator()(), Couenne::exprOddPow::operator()(), and Couenne::exprPow::selectBranch().
normalize angle within [0,b] (typically, pi or 2pi)
Definition at line 27 of file CouenneExprSin.hpp.
Referenced by bayEnvelope().
bool Couenne::trigImpliedBound | ( | enum | cou_trig, | |
int | , | |||
int | , | |||
CouNumber * | , | |||
CouNumber * | , | |||
t_chg_bounds * | ||||
) |
generalized implied bound procedure for sine/cosine
Definition at line 66 of file exprSin.cpp.
References Couenne::t_chg_bounds::CHANGED, cos(), COU_SINE, COUENNE_EPS, pi, pi2, pih, sin(), and updateBound().
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 81 of file CouenneFPpool.hpp.
References Couenne::CouenneFPsolution::compare(), and comparedTerm_.
const Ipopt::EJournalCategory Couenne::J_BRANCHING | ( | Ipopt::J_USER1 | ) |
Referenced by Couenne::CouenneThreeWayBranchObj::branch(), Couenne::CouenneComplBranchingObject::branch(), Couenne::CouenneBranchingObject::branch(), Couenne::CouenneBranchingObject::branchCore(), Couenne::CouenneObject::checkInfeasibility(), Couenne::CouenneVarObject::computeBranchingPoint(), Couenne::CouenneBranchingObject::CouenneBranchingObject(), Couenne::CouenneComplBranchingObject::CouenneComplBranchingObject(), Couenne::CouenneComplObject::CouenneComplObject(), Couenne::CouenneObject::CouenneObject(), Couenne::CouenneVarObject::CouenneVarObject(), Couenne::CouenneVarObject::createBranch(), Couenne::CouenneObject::createBranch(), Couenne::CouenneChooseStrong::doStrongBranching(), Couenne::CouenneVTObject::infeasibility(), Couenne::CouenneVarObject::infeasibility(), Couenne::CouenneSetup::InitializeCouenne(), Couenne::CouenneChooseVariable::setupList(), Couenne::CouenneChooseStrong::setupList(), and Couenne::CouenneChooseStrong::~CouenneChooseStrong().
const Ipopt::EJournalCategory Couenne::J_BOUNDTIGHTENING | ( | Ipopt::J_USER2 | ) |
Referenced by Couenne::CouenneProblem::aggressiveBT(), Couenne::CouenneProblem::boundTightening(), Couenne::CouenneProblem::btCore(), Couenne::CouenneFixPoint::createRow(), Couenne::CouenneProblem::fake_tighten(), Couenne::CouenneCutGenerator::generateCuts(), Couenne::CouenneFixPoint::generateCuts(), Couenne::CouenneProblem::impliedBounds(), Couenne::CouenneSetup::InitializeCouenne(), Couenne::CouenneProblem::obbt(), Couenne::CouenneProblem::obbt_iter(), Couenne::CouenneProblem::redCostBT(), and Couenne::CouenneProblem::tightenBounds().
const Ipopt::EJournalCategory Couenne::J_CONVEXIFYING | ( | Ipopt::J_USER3 | ) |
const Ipopt::EJournalCategory Couenne::J_PROBLEM | ( | Ipopt::J_USER4 | ) |
Referenced by Couenne::CouenneProblem::checkAux(), Couenne::CouenneProblem::checkBounds(), Couenne::CouenneProblem::checkCons(), Couenne::CouenneProblem::checkInt(), Couenne::CouenneProblem::checkNLP(), Couenne::CouenneProblem::checkNLP2(), Couenne::CouenneProblem::checkObj(), Couenne::CouenneProblem::CouenneProblem(), Couenne::CouenneProblem::fillIntegerRank(), Couenne::CouenneProblem::fillObjCoeff(), Couenne::CouenneProblem::initAuxs(), Couenne::CouenneSetup::InitializeCouenne(), main(), Couenne::CouenneProblem::reformulate(), Couenne::CouenneProblem::setCutOff(), and Couenne::CouenneProblem::standardize().
const Ipopt::EJournalCategory Couenne::J_NLPHEURISTIC | ( | Ipopt::J_USER5 | ) |
Referenced by ComputeSquareRoot(), Couenne::CouenneFeasPump::findSolution(), Couenne::CouenneProblem::getIntegerCandidate(), Couenne::CouenneSetup::InitializeCouenne(), Couenne::CouenneFeasPump::initIpoptApp(), Couenne::CouenneFeasPump::solution(), Couenne::CouenneFeasPump::solveMILP(), Couenne::CouenneFeasPump::solveNLP(), and Couenne::CouenneProblem::testIntFix().
const Ipopt::EJournalCategory Couenne::J_DISJCUTS | ( | Ipopt::J_USER6 | ) |
Referenced by Couenne::CouenneDisjCuts::applyColCuts(), Couenne::CouenneDisjCuts::generateCuts(), Couenne::CouenneDisjCuts::generateDisjCuts(), Couenne::CouenneDisjCuts::getDisjunctions(), Couenne::CouenneSetup::InitializeCouenne(), Couenne::CouenneDisjCuts::OsiCuts2MatrVec(), Couenne::CouenneDisjCuts::OsiSI2MatrVec(), Couenne::CouenneDisjCuts::separateWithDisjunction(), and Couenne::CouenneDisjCuts::~CouenneDisjCuts().
const Ipopt::EJournalCategory Couenne::J_REFORMULATE | ( | Ipopt::J_USER7 | ) |
Referenced by Couenne::CouenneProblem::analyzeSparsity(), Couenne::CouenneProblem::auxiliarize(), Couenne::CouenneProblem::decomposeTerm(), Couenne::CouenneProblem::flattenMul(), Couenne::CouenneSetup::InitializeCouenne(), Couenne::CouenneProblem::linStandardize(), Couenne::CouenneProblem::print(), Couenne::CouenneProblem::splitAux(), Couenne::exprSum::standardize(), Couenne::CouenneProblem::standardize(), and Couenne::CouenneConstraint::standardize().
const Ipopt::EJournalCategory Couenne::J_COUENNE | ( | Ipopt::J_USER8 | ) |
Referenced by Couenne::CouenneProblem::aggressiveBT(), Couenne::CouenneFeasPump::CouenneFeasPump(), Couenne::CouenneProblem::findSOS(), Couenne::CouenneDisjCuts::generateCuts(), Couenne::CouenneTwoImplied::generateCuts(), Couenne::CouenneFixPoint::generateCuts(), Couenne::CouenneSetup::InitializeCouenne(), main(), Couenne::CouenneProblem::obbt(), Couenne::CouenneProblem::reformulate(), Couenne::NlpSolveHeuristic::solution(), and Couenne::CouenneTwoImplied::~CouenneTwoImplied().
CouNumber Couenne::rootQ | ( | int | k | ) |
Find roots of polynomial $Q^k(x) = .
Used in convexification of powers with odd exponent
Definition at line 42 of file rootQ.cpp.
Referenced by Couenne::Qroot::operator()().
const CouNumber Couenne::default_alpha = 0.25 |
Definition at line 23 of file CouenneObject.hpp.
Referenced by Couenne::CouenneBranchingObject::branch(), Couenne::CouenneChooseVariable::registerOptions(), and Couenne::CouenneObject::setParameters().
const CouNumber Couenne::default_clamp = 0.2 |
Definition at line 24 of file CouenneObject.hpp.
Referenced by Couenne::CouenneObject::setParameters().
const CouNumber Couenne::max_pseudocost = 1000. |
Definition at line 25 of file CouenneObject.hpp.
Referenced by Couenne::CouenneObject::setEstimates().
const double Couenne::large_bound = 1e9 |
if |branching point| > this, change it
Definition at line 28 of file CouenneObject.hpp.
Referenced by Couenne::CouenneBranchingObject::branch(), Couenne::CouenneVarObject::computeBranchingPoint(), Couenne::CouenneBranchingObject::CouenneBranchingObject(), and Couenne::CouenneObject::midInterval().
const CouNumber Couenne::closeToBounds = .05 |
Definition at line 33 of file CouenneObject.hpp.
Referenced by Couenne::CouenneBranchingObject::branch(), Couenne::CouenneBranchingObject::CouenneBranchingObject(), Couenne::CouenneObject::midInterval(), and Couenne::CouenneObject::setEstimates().
const int Couenne::maxIter = 20 |
const double Couenne::Couenne_large_bound = 9.999e12 |
used to declare LP unbounded
Definition at line 45 of file CouennePrecisions.hpp.
Referenced by Couenne::CouenneChooseStrong::chooseVariable(), Couenne::CouenneSolverInterface< T >::initialSolve(), Couenne::CouenneObject::midInterval(), Couenne::CouenneSolverInterface< T >::resolve(), and Couenne::CouenneSolverInterface< T >::solveFromHotStart().
const CouNumber Couenne::pi = M_PI [static] |
const CouNumber Couenne::pi2 = M_PI * 2. [static] |
Definition at line 23 of file exprSin.cpp.
Referenced by Couenne::exprSin::closestFeasible(), Couenne::exprCos::closestFeasible(), Couenne::exprSin::getBounds(), Couenne::exprCos::getBounds(), Couenne::exprUBSin::operator()(), Couenne::exprLBSin::operator()(), Couenne::exprUBCos::operator()(), Couenne::exprLBCos::operator()(), and trigImpliedBound().
const CouNumber Couenne::pih = M_PI / 2. [static] |
Definition at line 24 of file exprSin.cpp.
Referenced by Couenne::exprSin::closestFeasible(), and trigImpliedBound().
const double Couenne::maxNlpInf_0 = 1e-5 |
An heuristic to call an NlpSolver if all CouenneObjects are close to be satisfied (for other integer objects, rounding is performed, is SOS are not satisfied does not run).
Definition at line 26 of file BonNlpHeuristic.hpp.
Referenced by Couenne::CouenneSetup::InitializeCouenne().
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 139 of file CouenneProblem.hpp.
Referenced by Couenne::CouenneSetup::registerAllOptions().