# Introduction

### Version 3.0067

The COCONUT environment is a modular solver environment for nonlinear continuous global optimization problems with an open-source kernel, which can be expanded by commercial and open-source solver components (inference modules).

The application programmer's interface (API) is designed to make the development of the various module types independent of each other and independent of the internal model representation. It is be a collection of open-source C++ classes protected by the LGPL and GPL license models, so that most of it could be used as part of commercial software (special license regulations are contained in the distribution). It uses the `FILIB++`

library for interval computations and the matrix template library (`MTL`

) for the internal representation of various matrix classes. The graphs are implemented using the `VGTL`

(Vienna Graph Template Library), and the search database is based on the `VDBL`

(Vienna DataBase Library). Support for dynamic linking relieves the user from recompilation when modules are added or removed. In addition, it is designed for distributed computing, and will probably be developed further (in the upcoming years) to support parallel computing as well.

The solution algorithm is an advanced branch-and-bound scheme which proceeds by working on the

**search graph**, a

**directed acyclic graph** (DAG) of search nodes, each representing an optimization problem, a

**model**. The

**search nodes** come in two flavors:

**full nodes** which record the complete description of a model, and

**delta nodes** which only contain the difference between the model represented by the node and its (then only) parent.

The optimization problems (models) stored in the

**work nodes**, which are passed to the various inference engines, are kept as directed acyclic graphs (DAG), as well. This representation has big advantages. Hereby, a complete optimization problem is always represented by a single DAG. The vertices of the graph represent operators similar to computational trees. Constants and variables are sources, objective and constraints are sinks of the DAG.

Every vertex represents a real valued function of n variables. Predefined functions include sum, product, max, min, elementary real functions (exp, log, pow, sqrt, ...), and also some discrete operators like `all_diff`

and count.

For expression graphs (DAG or tree), special

**forward** and

**backward evaluators** are provided. Currently implemented are real function values, function ranges, gradients (real, interval), and slopes. In the near future evaluators for Hessians (real, interval) and second order slopes will be provided, as well.

The strategy calls the various model classes to perform clearly distinguished tasks. The

**management modules** and the

**initializers** change the internal structure, the

**report modules** produce output, and the

**inference modules** (

**inference engines**,

**graph analyzers**) calculate information about the models and the search graph.