Nonlinear Programming Using the CppAD Interface to Ipopt
Keywords: nonlinear programming using the cppad interface to ipopt Ad deprecated 2012-11-28 syntax purpose cppad_ipopt namespace ipopt_library_paths fg(x) index vector projection injection representation simple sizevector numbervector adnumber advector n m x_i x_l x_u g_l g_u fg_info fg_info.number_functions fg_info.eval_r fg_info.retape fg_info.domain_size fg_info.range_size fg_info.number_terms fg_info.index solution status x z_l z_u g lambda obj_value example wish list

| Prev | Next |  |  |  |  |  |  |

Nonlinear Programming Using the CppAD Interface to Ipopt
Deprecated 2012-11-28
This interface to Ipopt is deprecated, use ipopt_solve instead.
Syntax
`# 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`
Purpose
The class `cppad_ipopt_nlp` is used to solve nonlinear programming problems of the form minimize f ( x ) subject to g l ≤ g ( x ) ≤ g u x l ≤ x ≤ x u This is done using Ipopt optimizer and CppAD Algorithmic Differentiation package.
cppad_ipopt namespace
All of the declarations for these routines are in the `cppad_ipopt` namespace (not the `CppAD` namespace). For example; SizeVector below actually denotes the type `cppad_ipopt::SizeVector`.
ipopt_library_paths
If you are linking to a shared version of the Ipopt library, you may have to add some paths the `LD_LIBRARY_PATH` shell variable using the `export` command in the syntax above. For example, if the file the ipopt library is `
ipopt_prefix/lib64/libipopt.a
` you will need to add the corresponding directory; e.g., `
export LD_LIBRARY_PATH="ipopt_prefix/lib64:$LD_LIBRARY_PATH"
` see ipopt_prefix .
fg(x)
The function fg : R n → R m + 1 is defined by fg 0 ( x ) = f ( x ) fg 1 ( x ) = g 0 ( x ) ⋮ fg m ( x ) = g m -1 ( x )
Index Vector
We define an `index vector` as a vector of non-negative 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 .
Projection
Given an index vector J and a positive integer n where n > ‖ J ‖ , we use J ⊗ n for the mapping ( J ⊗ n ) : R n → R | J | defined by [ J ⊗ n ] ( x ) j = x J ( j ) for j = 0 , … | J | - 1 .
Injection
Given an index vector I and a positive integer m where m > ‖ I ‖ , we use m ⊗ I for the mapping ( m ⊗ I ) : R | I | → R m defined by [ m ⊗ I ] ( y ) i = { y k if i = I ( k ) for some k ∈ { 0 , ⋯ , | I | -1 } 0 otherwise
Representation
In many applications, each of the component functions of fg ( x ) only depend on a few of the components of x . In this case, expressing fg ( x ) in terms of simpler functions with fewer arguments can greatly reduce the amount of work required to compute its derivatives. `
` We use the functions r k : R q ( k ) → R p ( k ) for k = 0 , … , K to express our representation of fg ( x ) in terms of simpler functions as follows fg ( x ) = ∑ k = 0 K -1 ∑ ℓ = 0 L ( k ) - 1 [ ( m + 1 ) ⊗ I k , ℓ ] ∘ r k ∘ [ J k , ℓ ⊗ n ] ( x ) where ∘ represents function composition, for k = 0 , … , K - 1 , and ℓ = 0 , … , L ( k ) , I k , ℓ and J k , ℓ are index vectors with | J k , ℓ | = q ( k ) , ‖ J k , ℓ ‖ < n , | I k , ℓ | = p ( k ) , and ‖ I k , ℓ ‖ ≤ m .
Simple Representation
In the simple representation, r 0 ( x ) = fg ( x ) , K = 1 , q ( 0 ) = n , p ( 0 ) = m + 1 , L ( 0 ) = 1 , I 0 , 0 = ( 0 , … , m ) , and J 0 , 0 = ( 0 , … , n -1 ) .
SizeVector
The type `SizeVector` is defined by the `cppad_ipopt_nlp.hpp` include file to be a SimpleVector class with elements of type `size_t`.
NumberVector
The type `NumberVector` is defined by the `cppad_ipopt_nlp.hpp` include file to be a SimpleVector class with elements of type `Ipopt::Number`.
ADNumber
The type `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
The type `ADVector` is defined by the `cppad_ipopt_nlp.hpp` include file to be a SimpleVector class with elements of type `ADNumber`.
n
The argument `n` has prototype `
size_t n
` It specifies the dimension of the argument space; i.e., x ∈ R n .
m
The argument `m` has prototype `
size_t m
` It specifies the dimension of the range space for g ; i.e., g : R n → R m .
x_i
The argument `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
The argument `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
The argument `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
The argument `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
The argument `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
The argument `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:
fg_info.number_functions
This member function has prototype `
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` .
fg_info.eval_r
This member function has the prototype `
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 , … , K -1 } 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 ) .
fg_info.retape
This member function has the prototype `
virtual bool cppad_ipopt_fg_info::retape(size_t k)
` If `k` in { 0 , … , K -1 } 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).
fg_info.domain_size
This member function has prototype `
virtual size_t cppad_ipopt_fg_info::domain_size(size_t k)
` If `k` in { 0 , … , K -1 } 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 .
fg_info.range_size
This member function has prototype `
virtual size_t cppad_ipopt_fg_info::range_size(size_t k)
` If `k` in { 0 , … , K -1 } 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 .
fg_info.number_terms
This member function has prototype `
virtual size_t cppad_ipopt_fg_info::number_terms(size_t k)
` If `k` in { 0 , … , K -1 } 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 .
fg_info.index
This member function has prototype `
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 K -1 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 , … , m , `I[i] = i` , and for j = 0 , … , n -1 , `J[j] = j` .
solution
After the optimization process is completed, `solution` contains the following information:
status
The `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 non-feasible 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
The `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
The `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
The `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
The `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
The `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
The `obj_value` field of `solution` has prototype `
Number solution.obj_value
` It is the final value of the objective function f ( x ) .
Example
The file ipopt_nlp_get_started.cpp is an example and test of `cppad_ipopt_nlp` that uses the simple representation . It returns true if it succeeds and false otherwise. The section ipopt_nlp_ode discusses an example that uses a more complex representation.
Wish List
This is a list of possible future improvements to `cppad_ipopt_nlp` that would require changed to the user interface:

1. The routine `fg_info.eval_r(k, u)` should also support `NumberVector` for the type of the argument `u` (this would certainly be more efficient when `fg_info.retape(k)` is true and L ( k ) > 1 ). It could be an option for the user to provide this as well as the necessary `ADVector` definition.
2. There should a Discrete routine that the user can call to determine the value of ℓ during the evaluation of `fg_info.eval_r(k, u)` . This way data, which does not affect the derivative values, can be included in the function recording and evaluation.

Input File: cppad_ipopt/src/cppad_ipopt_nlp.hpp