# Introduction¶

Ibex is a C++ numerical library based on **interval arithmetic** and **constraint programming**.

It can be used to solve a variety of problems that can roughly be formulated as:

Find a reliable characterization with boxes (Cartesian product of intervals) of sets implicitely defined by constraints

*Reliable* means that all sources of uncertainty should be taken into account, including:

- approximation of real numbers by floating-point numbers
- round-off errors
- linearization truncatures
- model parameter uncertainty
- measurement noise

**Example of problem**: Given a set of nonlinear inequalities \(f_1\leq0,\ldots,f_n\leq0\), find two sets of boxes S_{1} and S_{2} such that

## The API¶

The API of Ibex can be broken into three layers:

- An extended (symbolic-numeric) interval calculator
- A contractor programming library
- A system solver / global optimizer (supplied as plugins since Release 2.2)

Each usage corresponds to a different layer and each layer is built on top of the previous one.

Ibex does not include low-level interval arithmetic but uses a third library (Ibex is currently automatically compiled either with Gaol or Filib , depending on your platform).

## An extended interval calculator¶

Ibex allows you to declare symbolically a mathematical function and to perform interval computations with it. For example:

```
Variable x;
Function f(x,sin(x)+1);
```

defines the “mathematical” object \(x \mapsto sin(x)+1\).

**Note:** *Functions* (as well as equalities or inequalities) can either be entered programmatically (using C++ operator overloading) or using a parser of an AMPL-like language called Minibex. Functions accept vector or matrix variables or values; similarities with Matlab are shared on purpose. See the modeling guide.

Now that functions are built, you can use them to perform interval or symbolic operations. Example:

```
Interval x(0,1);
Interval y=f.eval(x); // calculate the image of x by f
Function df(f,Function::DIFF); // derivate f
Interval z=df.eval_affine(x); // calculate the image of x by df using affine forms
```

All the classical operations with intervals can be performed with the previously defined functions, including relational (backward) operators, inner arithmetics, automatic differentiation, affine arithmetic, etc.

## Contractor programming¶

Ibex gives you the ability to build high-level interval-based algorithms declaratively through the *contractor programming* paradigm [Chabert & Jaulin, 2009].

A contractor is basically an operator that transforms a box to a smaller (included) box, by safely removing points with respect to some mathematical property.

The first property one usually wants to enforce is a numerical constraint, like an equation or inequality:

```
Variable x,y,z;
Function f(x,y,z,...);
NumConstraint c(x,y,z,f(x,y,z)=0);
CtcFwdBwd ctc(c); // build the contractor w.r.t f(x,y,z)=0
```

Contraction is performed with a call to the function `contract(...)`

:

```
IntervalVector box(3); // build a box for x, y and z
box[0]=...;
box[1]=...;
box[2]=...;
ctc.contract(box); // contract the box
```

**Note**: A *contractor* is the equivalent of a propagator in finite domain solvers except that it is a pure numerical function (no state).

More complex properties are obtained by combining contractors. For instance:

```
Ctc& c1=... ;
Ctc& c2=... ;
Ctc& c3=... ;
CtcUnion u(CtcInter(c1,c2),c3);
```

will define the contractor \(((C_1 \cap C_2) \cup C_3))\).

Ibex contains a variety of built-in operators (HC4, Shaving, ACID, X-newton, q-intersection, etc.).

## System solving and global optimization¶

Finally, Ibex proposes various plugins. In particular, the IbexSolve and IbexOpt plugins are dedicated to system solving and optimization, and come both with a default black-box solver and global optimizer for immediate usage. See the IbexSolve and IbexOpt documentations.