Prev

Next

Index-> contents reference index search external

Up-> CppAD library BenderQuad

CppAD-> Install Introduction AD ADFun multi_thread library cppad_ipopt_nlp Example preprocessor Appendix

library-> ErrorHandler NearEqual speed_test SpeedTest time_test NumericType CheckNumericType SimpleVector CheckSimpleVector nan pow_int Poly LuDetAndSolve RombergOne RombergMul Runge45 Rosen34 OdeErrControl OdeGear OdeGearControl BenderQuad opt_val_hes LuRatio CppAD_vector thread_alloc memory_leak

BenderQuad-> BenderQuad.cpp

Headings-> Syntax See Also Problem Purpose x y fun ---..fun.f ---..fun.h ---..fun.dy g gx gxx BAvector ADvector Example

Computing Jacobian and Hessian of Bender's Reduced Objective
Syntax
# include <cppad/cppad.hpp>
BenderQuad(x, y, fun, g, gx, gxx)

See Also
opt_val_hes

Problem
The type ADvector cannot be determined form the arguments above (currently the type ADvector must be CPPAD_TEST_VECTOR<Base>.) This will be corrected in the future by requiring Fun to define Fun::vector_type which will specify the type ADvector.

Purpose
We are given the optimization problem $$\begin{array}{ccc}\hfill \mathrm{minimize}& \hfill \mathit{F}(\mathit{x},\mathit{y})\hfill & \mathrm{w}.\mathrm{r}.\mathrm{t}.(\mathit{x},\mathit{y})\in {\mathbf{R}}^{\mathit{n}}\times {\mathbf{R}}^{\mathit{m}}\hfill \end{array}$$ that is convex with respect to $\mathit{y}$ . In addition, we are given a set of equations $\mathit{H}(\mathit{x},\mathit{y})$ such that $$\mathit{H}[\mathit{x},\mathit{Y}(\mathit{x})]=0\Rightarrow {\mathit{F}}_{\mathit{y}}[\mathit{x},\mathit{Y}(\mathit{x})]=0$$ (In fact, it is often the case that $\mathit{H}(\mathit{x},\mathit{y})={\mathit{F}}_{\mathit{y}}(\mathit{x},\mathit{y})$ .) Furthermore, it is easy to calculate a Newton step for these equations; i.e., $$\mathit{dy}=-[{\partial }_{\mathit{y}}\mathit{H}(\mathit{x},\mathit{y}){]}^{-1}\mathit{H}(\mathit{x},\mathit{y})$$ The purpose of this routine is to compute the value, Jacobian, and Hessian of the reduced objective function $$\mathit{G}(\mathit{x})=\mathit{F}[\mathit{x},\mathit{Y}(\mathit{x})]$$ Note that if only the value and Jacobian are needed, they can be computed more quickly using the relations $${\mathit{G}}^{(1)}(\mathit{x})={\partial }_{\mathit{x}}\mathit{F}[\mathit{x},\mathit{Y}(\mathit{x})]$$
x
The BenderQuad argument x has prototype
     const BAvector &x
(see BAvector below) and its size must be equal to n. It specifies the point at which we evaluating the reduced objective function and its derivatives.

y
The BenderQuad argument y has prototype
     const BAvector &y
and its size must be equal to m. It must be equal to $\mathit{Y}(\mathit{x})$ ; i.e., it must solve the problem in $\mathit{y}$ for this given value of $\mathit{x}$ $$\begin{array}{ccc}\hfill \mathrm{minimize}& \hfill \mathit{F}(\mathit{x},\mathit{y})\hfill & \mathrm{w}.\mathrm{r}.\mathrm{t}.\mathit{y}\in {\mathbf{R}}^{\mathit{m}}\hfill \end{array}$$
fun
The BenderQuad object fun must support the member functions listed below. The AD<Base> arguments will be variables for a tape created by a call to Independent from BenderQuad (hence they can not be combined with variables corresponding to a different tape).

fun.f
The BenderQuad argument fun supports the syntax
     f = fun.f(x, y)
The fun.f argument x has prototype
     const ADvector &x
(see ADvector below) and its size must be equal to n. The fun.f argument y has prototype
     const ADvector &y
and its size must be equal to m. The fun.f result f has prototype
     ADvector f
and its size must be equal to one. The value of f is $$\mathit{f}=\mathit{F}(\mathit{x},\mathit{y})$$ .

fun.h
The BenderQuad argument fun supports the syntax
     h = fun.h(x, y)
The fun.h argument x has prototype
     const ADvector &x
and its size must be equal to n. The fun.h argument y has prototype
     const BAvector &y
and its size must be equal to m. The fun.h result h has prototype
     ADvector h
and its size must be equal to m. The value of h is $$\mathit{h}=\mathit{H}(\mathit{x},\mathit{y})$$ .

fun.dy
The BenderQuad argument fun supports the syntax
     dy = fun.dy(x, y, h)

x
The fun.dy argument x has prototype
     const BAvector &x
and its size must be equal to n. Its value will be exactly equal to the BenderQuad argument x and values depending on it can be stored as private objects in f and need not be recalculated.

y
The fun.dy argument y has prototype
     const BAvector &y
and its size must be equal to m. Its value will be exactly equal to the BenderQuad argument y and values depending on it can be stored as private objects in f and need not be recalculated.

h
The fun.dy argument h has prototype
     const ADvector &h
and its size must be equal to m.

dy
The fun.dy result dy has prototype
     ADvector dy
and its size must be equal to m. The return value dy is given by $$\mathit{dy}=-[{\partial }_{\mathit{y}}\mathit{H}(\mathit{x},\mathit{y}){]}^{-1}\mathit{h}$$ Note that if h is equal to $\mathit{H}(\mathit{x},\mathit{y})$ , $\mathit{dy}$ is the Newton step for finding a zero of $\mathit{H}(\mathit{x},\mathit{y})$ with respect to $\mathit{y}$ ; i.e., $\mathit{y}+\mathit{dy}$ is an approximate solution for the equation $\mathit{H}(\mathit{x},\mathit{y}+\mathit{dy})=0$ .

g
The argument g has prototype
     BAvector &g
and has size one. The input value of its element does not matter. On output, it contains the value of $\mathit{G}(\mathit{x})$ ; i.e., $$\mathit{g}[0]=\mathit{G}(\mathit{x})$$
gx
The argument gx has prototype
     BAvector &gx
and has size $\mathit{n}$ . The input values of its elements do not matter. On output, it contains the Jacobian of $\mathit{G}(\mathit{x})$ ; i.e., for $\mathit{j}=0,\dots ,\mathit{n}-1$ , $$\mathit{gx}[\mathit{j}]={\mathit{G}}^{(1)}(\mathit{x}{)}_{\mathit{j}}$$
gxx
The argument gx has prototype
     BAvector &gxx
and has size $\mathit{n}\times \mathit{n}$ . The input values of its elements do not matter. On output, it contains the Hessian of $\mathit{G}(\mathit{x})$ ; i.e., for $\mathit{i}=0,\dots ,\mathit{n}-1$ , and $\mathit{j}=0,\dots ,\mathit{n}-1$ , $$\mathit{gxx}[\mathit{i}*\mathit{n}+\mathit{j}]={\mathit{G}}^{(2)}(\mathit{x}{)}_{\mathit{i},\mathit{j}}$$
BAvector
The type BAvector must be a SimpleVector class. We use Base to refer to the type of the elements of BAvector; i.e.,
     BAvector::value_type

ADvector
The type ADvector must be a SimpleVector class with elements of type AD<Base>; i.e.,
     ADvector::value_type
must be the same type as
     AD< BAvector::value_type >
.

Example
The file BenderQuad.cpp contains an example and test of this operation. It returns true if it succeeds and false otherwise.

---

Input File: cppad/local/bender_quad.hpp