Prev  Next  cppad_ipopt_nlp 
# include "cppad_ipopt_nlp.hpp"
cppad_ipopt_solution solution;
cppad_ipopt_nlp cppad_nlp(
n, m, x_i, x_l, x_u, g_l, g_u, &fg_info, &solution
)
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:ipopt_library_paths
cppad_ipopt_nlp
is used to solve nonlinear programming
problems of the form
@[@
\begin{array}{rll}
{\rm minimize} & f(x)
\\
{\rm subject \; to} & g^l \leq g(x) \leq g^u
\\
& x^l \leq x \leq x^u
\end{array}
@]@
This is done using
Ipopt
optimizer and
CppAD
Algorithmic Differentiation package.
cppad_ipopt
namespace
(not the CppAD
namespace).
For example; SizeVector
below
actually denotes the type cppad_ipopt::SizeVector
.
LD_LIBRARY_PATH
.
You can determine the directory you need to add using the command
pkgconfig ipopt libs
%
The output will have the following form
Ldir lipopt
You may need to add the directory %dir% to LD_LIBRARY_PATH%
; e.g.,
export LD_LIBRARY_PATH="dir:$LD_LIBRARY_PATH"
index vector
as a vector of nonnegative integers
for which none of the values are equal; i.e.,
it is both a vector and a set.
If @(@
I
@)@ is an index vector @(@
I
@)@ is used to denote the
number of elements in @(@
I
@)@ and @(@
\ I \
@)@ is used
to denote the value of the maximum element in @(@
I
@)@.
We use the functions
@(@
r_k : \B{R}^{q(k)} \rightarrow \B{R}^{p(k)}
@)@
for @(@
k = 0 , \ldots , K
@)@ to express our
representation of @(@
fg(x)
@)@ in terms of simpler functions
as follows
@[@
fg(x) = \sum_{k=0}^{K1} \; \sum_{\ell=0}^{L(k)  1}
[ (m+1) \otimes I_{k,\ell} ] \; \circ
\; r_k \; \circ \; [ J_{k,\ell} \otimes n ] \; (x)
@]@
where @(@
\circ
@)@ represents function composition,
for @(@
k = 0 , \ldots , K  1
@)@, and @(@
\ell = 0 , \ldots , L(k)
@)@,
@(@
I_{k,\ell}
@)@ and @(@
J_{k,\ell}
@)@ are index vectors with
@(@
 J_{k,\ell}  = q(k)
@)@,
@(@
\ J_{k,\ell} \ < n
@)@,
@(@
 I_{k,\ell}  = p(k)
@)@, and
@(@
\ I_{k,\ell} \ \leq m
@)@.
SizeVector
is defined by the
cppad_ipopt_nlp.hpp
include file to be a
SimpleVector
class with elements of type
size_t
.
NumberVector
is defined by the
cppad_ipopt_nlp.hpp
include file to be a
SimpleVector
class with elements of type
Ipopt::Number
.
ADNumber
is defined by the
cppad_ipopt_nlp.hpp
include file to be a
an AD type that can be used to compute derivatives.
ADVector
is defined by the
cppad_ipopt_nlp.hpp
include file to be a
SimpleVector
class with elements of type
ADNumber
.
n
has prototype
size_t n
It specifies the dimension of the argument space;
i.e., @(@
x \in \B{R}^n
@)@.
m
has prototype
size_t m
It specifies the dimension of the range space for @(@
g
@)@;
i.e., @(@
g : \B{R}^n \rightarrow \B{R}^m
@)@.
x_i
has prototype
const NumberVector& x_i
and its size is equal to @(@
n
@)@.
It specifies the initial point where Ipopt starts the optimization process.
x_l
has prototype
const NumberVector& x_l
and its size is equal to @(@
n
@)@.
It specifies the lower limits for the argument in the optimization problem;
i.e., @(@
x^l
@)@.
x_u
has prototype
const NumberVector& x_u
and its size is equal to @(@
n
@)@.
It specifies the upper limits for the argument in the optimization problem;
i.e., @(@
x^u
@)@.
g_l
has prototype
const NumberVector& g_l
and its size is equal to @(@
m
@)@.
It specifies the lower limits for the constraints in the optimization problem;
i.e., @(@
g^l
@)@.
g_u
has prototype
const NumberVector& g_u
and its size is equal to @(@
n
@)@.
It specifies the upper limits for the constraints in the optimization problem;
i.e., @(@
g^u
@)@.
fg_info
has prototype
FG_info fg_info
where the class
FG_info
is derived from the
base class cppad_ipopt_fg_info
.
Certain virtual member functions of
fg_info
are used to
compute the value of @(@
fg(x)
@)@.
The specifications for these member functions are given below:
virtual size_t cppad_ipopt_fg_info::number_functions(void)
If
K
has type size_t
, the syntax
K = fg_info.number_functions()
sets
K
to the number of functions used in the
representation of @(@
fg(x)
@)@; i.e., @(@
K
@)@ in
the representation
above.
The cppad_ipopt_fg_info
implementation of this function
corresponds to the simple representation mentioned above; i.e.
K = 1
.
virtual ADVector cppad_ipopt_fg_info::eval_r(size_t k, const ADVector& u) = 0;
Thus it is a pure virtual function and must be defined in the
derived class
FG_info
.
This function computes the value of @(@
r_k (u)
@)@
used in the representation
for @(@
fg(x)
@)@.
If
k
in @(@
\{0 , \ldots , K1 \}
@)@ has type size_t
,
u
is an ADVector
of size
q(k)
and
r
is an ADVector
of size
p(k)
the syntax
r = fg_info.eval_r(k, u)
set
r
to the vector @(@
r_k (u)
@)@.
virtual bool cppad_ipopt_fg_info::retape(size_t k)
If
k
in @(@
\{0 , \ldots , K1 \}
@)@ has type size_t
,
and
retape
has type bool
,
the syntax
retape = fg_info.retape(k)
sets
retape
to true or false.
If
retape
is true,
cppad_ipopt_nlp
will retape the operation sequence
corresponding to @(@
r_k (u)
@)@ for
every value of
u
.
An cppad_ipopt_nlp
object
should use much less memory and run faster if
retape
is false.
You can test both the true and false cases to make sure
the operation sequence does not depend on
u
.
The cppad_ipopt_fg_info
implementation of this function
sets
retape
to true
(while slower it is also safer to always retape).
virtual size_t cppad_ipopt_fg_info::domain_size(size_t k)
If
k
in @(@
\{0 , \ldots , K1 \}
@)@ has type size_t
,
and
q
has type size_t
, the syntax
q = fg_info.domain_size(k)
sets
q
to the dimension of the domain space for @(@
r_k (u)
@)@;
i.e., @(@
q(k)
@)@ in
the representation
above.
The cppad_ipopt_h_base
implementation of this function
corresponds to the simple representation mentioned above; i.e.,
@(@
q = n
@)@.
virtual size_t cppad_ipopt_fg_info::range_size(size_t k)
If
k
in @(@
\{0 , \ldots , K1 \}
@)@ has type size_t
,
and
p
has type size_t
, the syntax
p = fg_info.range_size(k)
sets
p
to the dimension of the range space for @(@
r_k (u)
@)@;
i.e., @(@
p(k)
@)@ in
the representation
above.
The cppad_ipopt_h_base
implementation of this function
corresponds to the simple representation mentioned above; i.e.,
@(@
p = m+1
@)@.
virtual size_t cppad_ipopt_fg_info::number_terms(size_t k)
If
k
in @(@
\{0 , \ldots , K1 \}
@)@ has type size_t
,
and
L
has type size_t
, the syntax
L = fg_info.number_terms(k)
sets
L
to the number of terms in representation
for this value of
k
;
i.e., @(@
L(k)
@)@ in
the representation
above.
The cppad_ipopt_h_base
implementation of this function
corresponds to the simple representation mentioned above; i.e.,
@(@
L = 1
@)@.
virtual void cppad_ipopt_fg_info::index(
size_t k, size_t ell, SizeVector& I, SizeVector& J
)
The argument
k
has type
size_t
and is a value between zero and @(@
K1
@)@ inclusive.
The argument
ell
has type
size_t
and is a value between zero and @(@
L(k)1
@)@ inclusive.
The argument
I
is a SimpleVector
with elements
of type size_t
and size greater than or equal to @(@
p(k)
@)@.
The input value of the elements of
I
does not matter.
The output value of
the first @(@
p(k)
@)@ elements of
I
must be the corresponding elements of @(@
I_{k,ell}
@)@
in the representation
above.
The argument
J
is a SimpleVector
with elements
of type size_t
and size greater than or equal to @(@
q(k)
@)@.
The input value of the elements of
J
does not matter.
The output value of
the first @(@
q(k)
@)@ elements of
J
must be the corresponding elements of @(@
J_{k,ell}
@)@
in the representation
above.
The cppad_ipopt_h_base
implementation of this function
corresponds to the simple representation mentioned above; i.e.,
for @(@
i = 0 , \ldots , m
@)@,
I[i] = i
,
and for @(@
j = 0 , \ldots , n1
@)@,
J[j] = j
.
solution
contains
the following information:
status
field of
solution
has prototype
cppad_ipopt_solution::solution_status solution.status
It is the final Ipopt status for the optimizer.
Here is a list of the possible values for the status:
status
 Meaning 
not_defined 
The optimizer did not return a final status to this cppad_ipopt_nlp
object.

unknown 
The status returned by the optimizer is not defined in the Ipopt
documentation for finalize_solution .

success  Algorithm terminated successfully at a point satisfying the convergence tolerances (see Ipopt options). 
maxiter_exceeded  The maximum number of iterations was exceeded (see Ipopt options). 
stop_at_tiny_step  Algorithm terminated because progress was very slow. 
stop_at_acceptable_point  Algorithm stopped at a point that was converged, not to the 'desired' tolerances, but to 'acceptable' tolerances (see Ipopt options). 
local_infeasibility  Algorithm converged to a nonfeasible point (problem may have no solution). 
user_requested_stop  This return value should not happen. 
diverging_iterates  It the iterates are diverging. 
restoration_failure  Restoration phase failed, algorithm doesn't know how to proceed. 
error_in_step_computation  An unrecoverable error occurred while Ipopt tried to compute the search direction. 
invalid_number_detected 
Algorithm received an invalid number (such as nan or inf )
from the users function
fg_info.eval
or from the CppAD evaluations
of its derivatives
(see the Ipopt option check_derivatives_for_naninf ).

internal_error  An unknown Ipopt internal error occurred. Contact the Ipopt authors through the mailing list. 
x
field of
solution
has prototype
NumberVector solution.x
and its size is equal to @(@
n
@)@.
It is the final @(@
x
@)@ value for the optimizer.
z_l
field of
solution
has prototype
NumberVector solution.z_l
and its size is equal to @(@
n
@)@.
It is the final Lagrange multipliers for the
lower bounds on @(@
x
@)@.
z_u
field of
solution
has prototype
NumberVector solution.z_u
and its size is equal to @(@
n
@)@.
It is the final Lagrange multipliers for the
upper bounds on @(@
x
@)@.
g
field of
solution
has prototype
NumberVector solution.g
and its size is equal to @(@
m
@)@.
It is the final value for the constraint function @(@
g(x)
@)@.
lambda
field of
solution
has prototype
NumberVector solution.lambda
and its size is equal to @(@
m
@)@.
It is the final value for the
Lagrange multipliers corresponding to the constraint function.
obj_value
field of
solution
has prototype
Number solution.obj_value
It is the final value of the objective function @(@
f(x)
@)@.