Examples of usage:

See below for a comprehensive example of all the methods relative to `FlatExpression`.

### A.6.2.4 Usage of FlatExpression interface

The procedure to gather symbolic expression information from a `FlatExpression` is as follows.

1. Find out the `FlatExpression` type; there are three possible types: `Constant`, `Variable` and `Operator`.

```c
int fetype = fe->GetKind();
```

2. Depending on the type, cast the `FlatExpression` object dynamically to one of the following objects: `FlatConstantExpression`, `FlatVariableExpression` and `FlatOperatorExpression`.

```c
FlatConstantExpression* fke;
FlatVariableExpression* fve;
FlatOperatorExpression* foe;
switch (fetype) {
    case Constant:
        fke = dynamicCast<FlatConstantExpression*> (fe);
        break;
    case Variable:
        fve = dynamicCast<FlatVariableExpression*> (fe);
        break;
    case Operator:
        foe = dynamicCast<FlatOperatorExpression*> (fe);
        break;
}
```

3. Now find out the actual information.

* The `FlatConstantExpression` interface has only one method:
  ```c
  double GetValue(void);
  ```
  which returns the actual value of the constant.

* The `FlatVariableExpression` interface has only one method:
  ```c
  long int GetVarIndex(void);
  ```
  which returns the flat variable index of the variable.

* The `FlatOperatorExpression` interface has two methods: the first,
  ```c
  int GetOpType(void);
  ```
  returns the type of operator of the expression (possible values are as on page 146); the second method,
  ```c
  FlatExpression* GetFlatExpression(int index);
  ```

returns an operand of the operator given by `GetOpType()`. In the case of binary operators `index` can be 0 (for the left operand) or 1 (for the right operand). In the case of unary operators `index` can only be zero.

4. The symbolic analysis of the expression can go on in a recursive fashion until no more `FlatOperator-Expressions` are found.

5. It is important to notice that the deallocation of all the `FlatExpression` objects is left to the client.

The following is the actual coded example:
```c
string          cname   ;
si*             index   ;
double          LB      ;
double          UB      ;
si*             varList ;
sd*             coefList;
FlatExpression* fe;

NetOpt->GetFlatMINLPConstraintInfo(532, cname, index, LB, UB,
                                  varList, coefList, fe)

FlatConstantExpression* fke;
FlatVariableExpression* fve;
FlatOperatorExpression* foe;
switch fe->GetKind() {
  case Constant:
    fke = dynamicCast<FlatConstantExpression*> (fe);
    cout << "Constraint Nonlinear Part is a Constant" << endl;
    cout << "Value = " << fke->GetValue() << endl;
    break;
  case Variable:
    fve = dynamicCast<FlatVariableExpression*> (fe);
    cout << "Constraint Nonlinear Part is a Variable" << endl;
    cout << "VarIndex = " << fve->GetVarIndex() << endl;
    break;
  case Operator:
    foe = dynamicCast<FlatOperatorExpression*> (fe);
    cout << "Constraint Nonlinear Part is an Operator" << endl;
    cout << "Operator Type = " << foe->GetOpType() << endl;
    break;
}
delete fe;
```

## A.7 Implementation restrictions

The following restrictions of the current implementation in comparison to the functionality described in this document are known:

1. *Limited number of arguments to IntSeq function*
   The `IntSeq` auxiliary function can have a maximum of 8 integer arguments.

2. *Currently available MINLP Managers*
   The following MINLP solvers have been interfaced to date to *ooOPS* and can be used in conjunction with the function `NewMINLPSolverManager` (see section A.5.3):

*   SNOPT v. 5.3 (Systems Optimization Laboratory, Stanford University.)
    Accessed by specifying `sname = "snopt"`

## A.8 An Example of the use of *ooOPS*

The example is based on a slightly simplified form of the Resource Task Network (RTN) formulation proposed by C. Pantelides for process scheduling, plus a few spurious nonlinear terms which mess up the model hopelessly and
completely, but help show how to use the methods which deal with nonlinearity. The formulation seeks to optimise a process involving *NR* resources *r* = 1, .., *NR* and *NK* tasks *k* = 1, .., *NK* over a time horizon discretised into *NT* time intervals *t* = 1, .., *NT*. It involves the objective function:

$$ \max \sum_{r} (C_{r}^{F} (R_{r,NT} - R_{r0}) + \sum_{t} R_{rt}^{2}) \qquad (A.7) $$

subject to the constraints:

$$ R_{rt} = R_{r,t-1} + \sum_{k} \sum_{\theta=0}^{\tau_k} (\mu_{kr\theta} N_{k,t-\theta} + \nu_{kr\theta} \xi_{k,t-\theta}) + \Pi_{rt} + \frac{R_{rt} R_{r,t-1}}{\Pi_{rt}} \quad \forall r, t \qquad (A.8) $$

$$ 0 \le R_{rt} \le R_{rt}^{\max} \quad \forall r, t \qquad (A.9) $$

$$ V_k^{\min} N_{kt} \le \xi_{kt} \le V_k^{\max} N_{kt} \quad \forall k, t \qquad (A.10) $$

The variables in the above formulation are the following:

<table><caption>Table A.1: Variable sets</caption><thead><tr><th>Variable</th><th>Type</th><th>Range</th><th>Description</th></tr></thead><tbody><tr><td>R<sub>rt</sub></td><td>Continuous</td><td>r = 1, .., NR<br>t = 0, .., NT</td><td>Amount of resource r at time t</td></tr><tr><td>N<sub>kt</sub></td><td>Integer</td><td>k = 1, .., NK</td><td>Number of units used for task k at time t</td></tr><tr><td>ξ<sub>kt</sub></td><td>Continuous</td><td>t = 1, .., NR<br>k = 1, .., NK<br>t = 1, .., NT</td><td>Size of task k at time t</td></tr></tbody></table>

A number of parameters and coefficients also appear in the formulation. These are listed in Table A.2. The initial values of the resource levels, $R_{r0}$, are also fixed at given values $R_{r}^{*}$.

<table><caption>Table A.2: Parameters appearing in the RTN formulation</caption><thead><tr><th>Parameter</th><th>Type</th><th>Description</th></tr></thead><tbody><tr><td>C<sub>r</sub><sup>F</sup></td><td>Constant</td><td>Unit cost of resource r</td></tr><tr><td>μ<sub>rt</sub></td><td>Constant</td><td>Production or consumption coefficient referring to integer variable N<sub>kt</sub></td></tr><tr><td>ν<sub>kt</sub></td><td>Constant</td><td>Production or consumption coefficient referring to continuous variable ξ<sub>kt</sub></td></tr><tr><td>Π<sub>rt</sub></td><td>Constant</td><td>Amount of resource r made available from/to external sources at time t</td></tr><tr><td>τ<sub>k</sub></td><td>Constant</td><td>Duration of task k</td></tr><tr><td>R<sub>rt</sub><sup>max</sup></td><td>Constant</td><td>Maximum amount of resource r that can be stored at time t</td></tr><tr><td>V<sub>k</sub><sup>min</sup></td><td>Constant</td><td>Minimum useful capacity of unit suitable for task k</td></tr><tr><td>V<sub>k</sub><sup>max</sup></td><td>Constant</td><td>Maximum useful capacity of unit suitable for task k</td></tr></tbody></table>
## A.8.1 Creating the MINLP

The first step is to create (an empty) ops object:

ops* RTNops(NewMINLP();

Now we have to add to this object (RTNops) the information that defines it. This is done below using the methods described in section A.4.

### A.8.1.1 Creating variables

Variables are added to the ops object using the variable construction methods described in section A.4.2.

Continuous variables are created using the method NewContinuousVariable in the way specified in section A.4.2.1:

RTNops->NewContinuousVariable("Xi", IntSeq(1,1), IntSeq(NK,NT),
                             0.0, ooOPSPlusInfinity, 0.0);

RTNops->NewContinuousVariable("R", IntSeq(1,0), IntSeq(NR,NT),
                             0.0, ooOPSPlusInfinity, 0.0);

while integer variables are created using the method NewIntegerVariable described in section A.4.2.2:

RTNops->NewIntegerVariable("N", IntSeq(1,1), IntSeq(NK,NT),
                             0, ooOPSPlusInfinity, 0);

All variables are two-dimensional, their lower bounds are initialised to zero and so are their default values. No upper bounds are imposed at this stage.

### A.8.1.2 Creating constraints

We now use the construction method presented in section A.4.2.3 to create constraints (A.8) and (A.10):

RTNops->NewConstraint("ResourceBalance", IntSeq(1,1),
                       IntSeq(NR,NT), 0.0, 0.0);

RTNops->NewConstraint("EquipmentCapacityLB", IntSeq(1,1),
                       IntSeq(NK,NT), 0.0, ooOPSPlusInfinity);

RTNops->NewConstraint("EquipmentCapacityUB", IntSeq(1,1),
                       IntSeq(NK,NT), ooOPSMinusInfinity, 0.0);

We note that constraint A.8 has been rearranged to the form:

$$ -R_{rt} + R_{r,t-1} + \sum_k \sum_{\theta=0}^{T_k} (\mu_{kr\theta} N_{k,t-\theta} + \nu_{kr\theta} \xi_{k,t-\theta}) + \Pi_{rt} + \frac{R_{r,t} R_{r,t-1}}{\Pi_{rt}} = 0 \quad \forall r, t \quad (A.8') $$
while A.10 has been split into two separate constraints of the form:

$$ \xi_{kt} - V_{k}^{\min} N_{kt} \geq 0 \quad \forall k, t \qquad (A.10') $$

and

$$ \xi_{kt} - V_{k}^{\max} N_{kt} \leq 0 \quad \forall k, t \qquad (A.10'') $$

On the other hand, no constraint corresponding to (A.9) is introduced since this can be dealt with via upper bounds imposed on the $R_{rt}$ variables (see section A.8.1.6).

### A.8.1.3 Adding variables to constraints

The constraints created in section A.8.1.2 do not yet contain any variables. We now have to create appropriate variable occurrences in them by applying the method `AddVariableSliceToConstraintSlice` as described in section A.4.2.4⁵:

*   **Constraint (A.8')**

```c
for (int r = 1; r <= NR; r++) {
    for (int t = 1; t <= NT; t++) {
        RTNops->AddVariableSliceToConstraintSlice("R",
                                                IntSeq(r,t), IntSeq(r,t), "ResourceBalance",
                                                IntSeq(r,t), IntSeq(r,t), -1.0);
        RTNops->AddVariableSliceToConstraintSlice("R",
                                                IntSeq(r,t-1), IntSeq(r,t-1), "ResourceBalance",
                                                IntSeq(r,t), IntSeq(r,t), 1.0);
        for (int k = 1; k <= NK; k++) {
            for (int theta = 0;
                 theta <= min(tau(k), (double) t - 1);
                 theta++) {
                RTNops->AddVariableSliceToConstraintSlice("N",
                                                IntSeq(k,t-theta), IntSeq(k,t-theta),
                                                "ResourceBalance", IntSeq(r,t), IntSeq(r,t),
                                                mu(k,r,theta));
                RTNops->AddVariableSliceToConstraintSlice("Xi",
                                                IntSeq(r,t-theta), IntSeq(r,t-theta),
                                                "ResourceBalance", IntSeq(r,t), IntSeq(r,t),
                                                nu(k,r,theta));
            }
        }
    }
}
```

*   **Constraint (A.10')**

```c
for (int k = 1; k <= NK; k++) {
    for (int t = 1; t <= NT; t++) {
        RTNops->AddVariableSliceToConstraintSlice("Xi",
                                                IntSeq(k,t), IntSeq(k,t),
                                                "EquipmentCapacityLB",
                                                IntSeq(k,t-1), IntSeq(k,t-1),
                                                "EquipmentCapacityLB");
    }
}
```

<footnote n="5">⁵Here we assume that appropriate sets holding data components to the parameters of table A.2 are already available.</footnote>
IntSeq(k,t), IntSeq(k,t), 1.0);
RTNops->AddVariableSliceToConstraintSlice("N",
    IntSeq(k,t), IntSeq(k,t),
    "EquipmentCapacityLB",
    IntSeq(k,t), IntSeq(k,t),
    -Vmin(k,t));
}
}

* Constraint (A.10')

for (int k=1; k<=NK; k++) {
    for (int t=1; t<=NT; t++) {
        RTNops->AddVariableSliceToConstraintSlice("Xi",
                IntSeq(k,t), IntSeq(k,t),
                "EquipmentCapacityUB",
                IntSeq(k,t), IntSeq(k,t), 1.0);
        RTNops->AddVariableSliceToConstraintSlice("N",
                IntSeq(k,t), IntSeq(k,t),
                "EquipmentCapacityUB",
                IntSeq(k,t), IntSeq(k,t),
                -Vmax(k,t));
    }
}

### A.8.1.4 Objective function

The creation of the objective function is effected using the method `NewObjectiveFunction` (cf. section A.4.2.11):

RTNops->NewObjectiveFunction("TotalProfit", "max");

For this example, the name of the objective function to be maximized is `"TotalProfit"`.

### A.8.1.5 Objective function coefficients

The creation of the objective function is followed by the declaration of the coefficients of the variable instances appearing in it. The appropriate method is `AddVariableSliceToObjectiveFunction` described in section A.4.2.12:

for (int r=1; r<=NR; r++) {
    RTNops->AddVariableSliceToObjectiveFunction("R", IntSeq(r,NT),
        IntSeq(r,NT), CFR(r), "TotalResources");
    RTNops->AddVariableSliceToObjectiveFunction("R", IntSeq(r,0),
        IntSeq(r,0), -CFR(r), "TotalResources");
}

Again, we assume the coefficients $C_r^F$ that appear in the objective function are stored in set CFR.
### A.8.1.6 Modifying the variable bounds

Variable $R_{rt}$ is bounded as shown in eqn. (A.9). Method `SetVariableBounds` can be used to impose these bounds which may be different for different elements of the $R_{rt}$ set:

```c
for (int r = 1; r <= NR; r++) {
    for (int t = 1; t <= NT; t++) {
        RTNops->SetVariableBounds("R", IntSeq(r,t), IntSeq(r,t),
                                 0.0, R_max[r][t]);
    }
}
```

Moreover, the initial resource levels $R_{r0}$ are fixed at given values $R_r^*$. This is achieved by setting both lower and upper bounds to $R_r^*$:

```c
for (int r = 1; r <= NR; r++) {
    RTNops->SetVariableBounds("R", IntSeq(r,0), IntSeq(r,0),
                             R_star[r], R_star[r]);
}
```

### A.8.1.7 Modifying the constraint bounds

Constraint (A.8) has a right hand coefficient which is not constant so we use the function `SetConstraintBounds` to obligate this restriction.

```c
for (int r = 1; r <= NR; r++) {
    for (int t = 1; t <= NT; t++) {
        RTNops->SetConstraintBounds("ResourceBalance",
                                   IntSeq(r,t), IntSeq(r,t),
                                   -Pi[r][t], -Pi[r][t]);
    }
}
```

### A.8.1.8 Creating the nonlinear parts

We create nonlinear parts of constraints and objective function by employing the methods described in section A.4.2.6.

```c
// make nonlinear part of constraints
RTNops->NewVariableExpression("Leaf1", "R",
                             IntSeq(1,1), IntSeq(NR, NT));
RTNops->NewVariableExpression("Leaf2", "R",
                             IntSeq(1,1), IntSeq(NR, NT));
RTNops->BinaryExpression("Expr1",
                         "Leaf1", IntSeq(1,1), IntSeq(NR, NT),
                         "Leaf2", IntSeq(1,1), IntSeq(NR, NT),
                         "product");
RTNops->NewConstant("Const1", IntSeq(1,1), IntSeq(NR, NT), 1.0);
for (int r = 1; r <= NR; r++) {
    for (int t = 1; t <= NT; t++) {
```
```c
RTNops->SetConstantValue("Const1", IntSeq(r,t), 1/Pi[r][t]);
}
}
RTNops->NewConstantExpression("Leaf3", "Const1",
                             IntSeq(1,1), IntSeq(NR, NT));
RTNops->BinaryExpression("Expr1",
                        "Expr1", IntSeq(1,1), IntSeq(NR,NT),
                        "Leaf3", IntSeq(1,1), IntSeq(NR,NT),
                        "ratio");

// make nonlinear part of objective function
RTNops->NewConstant("Const2", IntSeq(1,1), IntSeq(1,1), 2.0);
RTNops->NewConstantExpression("Power2", "Const2",
                             IntSeq(1,1), IntSeq(1,1));
RTNops->BinaryExpression("Expr2",
                        "Leaf1", IntSeq(1,1), IntSeq(NR,NT),
                        "Const2", IntSeq(1,1), IntSeq(1,1),
                        "power");
RTNops->NewConstant("Zero", IntSeq(1), IntSeq(1), 0);
RTNops->NewConstantExpression("Expr3", "Zero",
                             IntSeq(1), IntSeq(1));

for(int r=1; r<=NR; r++) {
    for(int t=1; t<=NT; t++) {
        RTNops->BinaryExpression("Expr3",
                                 "Expr3", IntSeq(1), IntSeq(1),
                                 "Expr2", IntSeq(r,t), IntSeq(r,t),
                                 "sum");
    }
}
```

### A.8.1.9 Assigning expressions to constraints and objective function

After having created the expressions representing the nonlinear parts, we assign them to the existing constraints and objective function by using the methods described in section A.4.2.7.

```c
// assign expressions to constraints
RTNops->AssignExpressionSliceToConstraintSlice
    ("Expr1", IntSeq(1,1), IntSeq(NR, NT),
     "ResourceBalance", IntSeq(1,1), IntSeq(NR, NT));

// assign expression to objective function
RTNops->AssignExpressionToObjectiveFunction
    ("Expr3", "TotalProfit");
```

## A.8.2 MINLP solution

Having created the `ops` object `RTNops`, we now have to combine it with an appropriate MINLP solver to create an `opssystem` that can be solved.
### A.8.2.1 Creating an MINLP solver manager object

We start by creating an appropriate `opssolvermanager` object. The usage of this method is described in section A.5.3. Here, we create a MINLP solver manager based on the SNOPT solver:

```cpp
opssolvermanager* SnoptManager = NewMINLPSolverManager("snopt");
```

### A.8.2.2 Creating an MINLP system

Using the MINLP solver manager object created above, a `opssystem` is created from the `ops` object:

```cpp
opssystem* RTNsystem = SnoptManager->NewMINLPSystem(RTNops);
```

### A.8.2.3 Solving the MINLP

At last, the above `MINLPSystem` can be solved by invoking its `Solve` method as described in section A.5.5.4:

```cpp
RTNsystem->Solve();
```

## A.8.3 Accessing the Solution of the MINLP

Various aspects of the MINLP solution can be accessed using methods described in section A.4.4.

### A.8.3.1 Obtaining information on the variables

The optimal values of the variables can be obtained using method A.4.4.1. In this example we have three types of variables:

* $R_{rt}$
  ```cpp
double* R_value;
double* R_LB;
double* R_UB;
RTNops->GetVariableInfo("R", IntSeq(1,1), IntSeq(NR,NT),
                       R_value, R_LB, R_UB);
```

* $N_{kt}$
  ```cpp
int* N_value;
int* N_LB;
int* N_UB;
RTNops->GetVariableInfo("N", IntSeq(1,1), IntSeq(NK,NT),
                       N_value, N_LB, N_UB);
```

* $\xi_{kt}$
double* Xi_value;
double* Xi_LB;
double* Xi_UB;

RTNops->GetVariableInfo("Xi",IntSeq(1,1),IntSeq(NK,NT),
Xi_value, Xi_LB, Xi_UB);

### A.8.3.2 Obtaining information on the objective function

The value of the objective function can be accessed using the method of section A.4.4.3:

char* obj_type;
double* obj_value;

RTNops->GetObjectiveFunctionInfo("TotalProfit",
objt_type, obj_value);

The value of the objective function returned is based on the current (hopefully optimal) values of the variables.
# Index

* $\alpha$ parameter, 100

* $\alpha$BB, 45

* ooOPS, 101, 120

* NewMINLPSolverManager, 120

* convexifiermanager, 118, 121, 122

* opssolvermanager, 118, 120

* opssystem, 118, 120

* ops, 118, 122

* acceleration device, 24, 26

* affine function, 44

* algorithm, 19, 25, 103

* algorithmic property, 43

* automatic procedure, 43

* BARON, 53, 55

* barrier function, 33

* bilinear, 45, 50, 99, 102

* bilinear form, 35, 38

* generalized, 36

* separation, 35

* bilinear problem, 56

* binary, 37

* binary problem, 39

* binary variable, 40, 56

* bivariate, 53

* black box procedure, 24

* bound, 36

* lower, 26, 106, 113, 121

* tightening, 111

* upper, 26, 107, 113, 121

* bound factor, 56

* box-constrained, 32

* branch, 21, 107, 110

* point, 111

* rule, 25

* Branch-and-Bound, 21, 26, 35, 37, 40, 46, 49, 97, 101

* $\alpha$BB, 22

* convergence, 27

* sBB, 22, 121

* Branch-and-Select, 24

* branching, 55

* C++, 116

* Cantor, 47

* cardinality, 47

* Cauchy, 35

* chord, 52

* code

* optimization, 116

* portability, 116

* combinatorial optimization, 24

* combinatorial problem, 56

* complementarity problem, 42

* complexity, 23, 41

* concave

* optimization, 19

* univariate, 52

* concave envelope, 18

* concave function, 17
concave problem, 41

concave relaxation, 18, 40

concavoconvex, 54

constrained optimization, 18

constraint, 20, 50–52

bounds, 113

equality, 113

inequality, 113

structured, 116

constraint factor, 56

continuity, 43

continuous, 96

everywhere, 47

continuous method, 40

continuous optimization, 18

continuous variable, 40

continuum, 47

convenient, 36, 41, 47

convergence, 25, 111, 112

finite, 26

proof, 24

convex, 20, 52

envelope, 50, 109

locally, 34

convex envelope, 18, 49

convex function, 17

convex hull, 17

convex inequality, 18

convex optimization, 19

convex problem, 38

convex relaxation, 18, 38, 40, 45, 49, 52, 54, 56

Smith, 53

convex set, 17, 53

convexification, 109, 118, 122

convexity, 56

convexity gap, 40, 56

cut, 23

d.c. function, 18, 35

d.c. optimization, 19

d.c. problem, 43

d.c. set, 18

Dantzig, 37

deallocation, 122

decomposition, 35, 36

dense, 43

derivative

left, 44

right, 44

deterministic, 19, 23, 49

method, 32

diagonal shift matrix, 52

diagonalization, 35

differentiable, 96

nowhere, 47

dimensionality reduction, 47

discrete problem, 39

disjunction, 42

disjunctive constraint, 58

divide-and-conquer, 20, 24

dual bound, 34

duality, 34

duality gap, 34

ECP method, 23

eigenvalue, 52

envelope, 53, 91, 96

concave, 18, 91

convex, 18, 91

nonlinear, 91, 97

standard linear, 99

Euclidean space, 18, 38, 48, 123
evaluation, 26
exact, 36, 37, 39, 41–44, 46, 48, 50
expression, 109

factorable, 44, 45
factorable problem, 45, 54, 56
feasibility bounds tightening, 55
feasibility problem, 42
feasible region, 17
filter, 24
fixed-point, 42
flat form, 123
Floudas, 49
formulation, 18, 24, 41
formulation of problem, 20, 106
fractional, 51, 54
  trilinear, 51
fractional term, 54

function
  affine, 44
  barrier, 33
  concave, 17
  convex, 17
  d.c., 18
  penalty, 33

Galois, 93
Galois group, 93
Gauss, 35
  global minimality, 38
  global optimality, 47, 101
  global optimality conditions, 43
  global optimization, 19
  global optimum, 41
  global solution, 49
  Gröbner bases, 23
  gradient, 92

Hessian, 34, 52
Hilbert, 47
hypercube, 123
implementation, 55
incumbent, 25, 26
inequality
  convex, 18
infeasible, 25
infeasible point, 33
integer optimization, 18
integrality enforcing constraint, 40
interval, 21
  matrix, 52
  open, 97
interval analysis, 35, 36
interval arithmetic, 57

Jacobi, 35
Karush-Kuhn-Tucker (KKT), 21
KKT conditions, 34

Lagrange, 20
  multipliers, 21
Lagrange coefficients, 34
Lagrange multipliers, 34
Lagrangian, 34
lattice, 48
lifting, 38, 40, 47
linear
  problem, 37
  linear optimization, 19
  linear relaxation, 56, 57
  linearization, 57
linking
  run-time, 120
Lipschitz, 33, 41
local convexity, 34
local optimization, 19, 41, 49, 113
local optimum, 34
local solution, 26
lower bound, 56
valid, 49
via duality, 34
lower semicontinuous, 43

matrix theory, 36
max clique problem, 58
max-min problem, 42
maximization, 20
memory, 123
MILP, 58
minimization, 20
minimizer, 48
mixed integer optimization, 18
monomial, 53, 95, 98, 102
monotonic, 95
multi-extremal, 41

neighbourhood, 97
net, 24
refinement, 24
NLP, 19–22, 106, 111
node, 39, 97
non-convex function, 100
non-singular, 36
non-smooth, 33
non-soluble group, 93
nonconvex, 52
nonconvex optimization, 19
nonlinear optimization, 19
nonseparable, 45
normal subgroup, 93
NP-hard, 23

numerical results, 101
objective function, 17
definition of, 20
lower bound, 108
odd power, 91
optimality
tolerance, 26
optimality bounds tightening, 55
optimization
combinatorial, 24
concave, 19
constrained, 18
continuous, 18
convex, 19
d.c., 19
global, 19, 20
history of, 20
integer, 18
interval, 21
introduction to, 17
linear, 19
local, 19, 23, 113
mixed integer, 18
nonconvex, 19
nonlinear, 19
unconstrained, 19
overestimator, 108
concave, 91
partition, 24, 36, 43
Peano, 47
penalty function, 33
phase
global, 23
local, 23
piecewise convex, 102
point
  infeasible, 33
polyhedral set, 41
polynomial, 92
polynomial problem, 56, 57
polytope, 35
pooling problem, 58
positive
  semi-definite, 52
positive definite, 35, 38
problem
  factorable, 45
  formulation, 20, 106
pseudo-convex, 18, 23
quadratic form, 35
quasi-convex, 18
radical, 93
range, 93
  including zero, 98
  unbounded, 96
range reduction, 55
re-entrancy, 116
refinement, 24
reformulation, 31, 99
  n-dimensional to 1-dimensional, 48
  bilinear to concave, 41
  binary to concave, 41
  binary to continuous, 40
  complementarity to concave, 42
  convenient, 31
  discrete to binary, 39
  equality to inequality, 47
  exact, 31
  exact convex, 38
  factorable to separable, 45

heuristic, 32
inequality to equality, 47
linear, 37
max-min to concave, 42
quadratic to linear, 37
Smith, 53
symbolic, 46
to box-constrained, 33
to unconstrained, 33
useful, 31
Reformulation-Linearization Technique, 45, 56
region, 123
relaxation, 31
  alternative, 98, 102
  concave, 18, 98
  continuous, 31
  convex, 18, 31, 44, 49, 98, 111, 118, 121, 122
  linear, 40, 56, 91, 98, 121
  novel, 102
  tight, 58, 91, 100
  update, 123
RLT, 45, 56
robustness, 58
root, 92
  negative, 95
  real, 94
  unique, 95
Sahinidis, 53, 58
search space, 23
second derivative, 100
segment, 97
selection rule, 24
  exact, 25
semi-definite, 52
semi-separable, 36
semicontinuous
  lower, 43
  upper, 43
semidefinite, 35
separability, 35
separable, 35
separable function, 35, 43
separable problem, 35
set
  d.c., 18
Sherali, 56
simplex, 58
simplex method, 37
slack variable, 47
slope, 92, 97
Smith, 40, 53
  standard form, 46
solution, 47
solver
  global, 121
  module, 120
space-filling curve, 48
square matrix, 35
standard form, 32, 46, 49, 108, 109, 113
  Smith, 46, 53
stationary point, 58
stochastic, 19, 23, 32
Sylvester, 35
symbolic, 109
symmetric group, 93
tangent, 91, 97
termination, 25
  finite, 26

tight relaxation, 58
tolerance, 26
tree, 97
trilinear, 50
TSP, 24
unconstrained, 32, 37
unconstrained optimization, 19
underestimation, 100
underestimator, 52, 108
  convex, 91
  integer exponent, 110
uniform convergence, 43
univariate, 53, 99
univariate function, 45
upper semicontinuous, 43
usual topology, 47
valid cut, 56
variable, 20, 111
  added, 114
  binary, 40, 42
  branch, 114, 123
  change of, 38
  continuous, 40
  intermediate, 113
  new, 38, 50–52, 113
  original, 114
  range, 118, 122, 123
  slack, 47, 113
  structured, 116
variable bound, 57
vertex, 41