Prev

Next

Index-> contents reference index search external

Up-> CppAD ADFun Forward forward_order

CppAD-> Install Introduction AD ADFun preprocessor multi_thread utility ipopt_solve Example speed Appendix

ADFun-> record_adfun drivers Forward Reverse sparsity_pattern sparse_derivative optimize abs_normal FunCheck check_for_nan

Forward-> forward_zero forward_one forward_two forward_order forward_dir size_order compare_change capacity_order number_skip

forward_order-> forward.cpp forward_order.cpp

Headings-> Syntax Purpose ---..Function Values ---..Derivative Values Notation ---..n ---..m f One Order q xq ---..One Order ---..Multiple Orders ---..Restrictions s X(t) Y(t) yq ---..One Order ---..Multiple Orders Vector Zero Order First Order Second Order Example

@(@\newcommand{\W}[1]{ \; #1 \; } \newcommand{\R}[1]{ {\rm #1} } \newcommand{\B}[1]{ {\bf #1} } \newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} } \newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} } \newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} } \newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }@)@ Multiple Order Forward Mode
Syntax
yq = f.Forward(q, xq )
yq = f.Forward(q, xq, s)

Purpose
We use @(@ F : B^n \rightarrow B^m @)@ to denote the AD function corresponding to f . Given a function @(@ X : B \rightarrow B^n @)@, defined by its Taylor coefficients , forward mode computes the Taylor coefficients for the function @[@ Y (t) = F [ X(t) ] @]@

Function Values
If you are using forward mode to compute values for @(@ F(x) @)@, forward_zero is simpler to understand than this explanation of the general case.

Derivative Values
If you are using forward mode to compute values for @(@ F^{(1)} (x) * dx @)@, forward_one is simpler to understand than this explanation of the general case.

Notation

n
We use n to denote the dimension of the domain space for f .

m
We use m to denote the dimension of the range space for f .

f
The ADFun object f has prototype
     ADFun<Base> f
Note that the ADFun object f is not const. After this call we will have
     f.size_order()     == q + 1
     f.size_direction() == 1

One Order
If xq.size() == n , then we are only computing one order. In this case, before this call we must have
     f.size_order()     >= q
     f.size_direction() == 1

q
The argument q has prototype
     size_t q
and specifies the highest order of the Taylor coefficients to be calculated.

xq
The argument xq has prototype
     const Vector& xq
(see Vector below). As above, we use n to denote the dimension of the domain space for f . The size of xq must be either n or n*(q+1) . After this call we will have
     f.size_order()     == q + 1

One Order
If xq.size() == n , the q-th order Taylor coefficient for @(@ X(t) @)@ is defined by
      @(@ x^{(q)} = @)@ xq . For @(@ k = 0 , \ldots , q-1 @)@, the Taylor coefficient @(@ x^{(k)} @)@ is defined by xk in the previous call to
     f.Forward(k, xk)

Multiple Orders
If xq.size() == n*(q+1) , For @(@ k = 0 , \ldots , q @)@, @(@ j = 0 , \ldots , n-1 @)@, the j-th component of the k-th order Taylor coefficient for @(@ X(t) @)@ is defined by
      @(@ x_j^{(k)} = @)@ xq[ (q+1) * j + k ]

Restrictions
Note if f uses old_atomic functions, the size of xq must be n .

s
If the argument s is not present, std::cout is used in its place. Otherwise, this argument has prototype
     std::ostream& s
If order zero is begin calculated, s specifies where the output corresponding to PrintFor will be written. If order zero is not being calculated, s is not used

X(t)
The function @(@ X : B \rightarrow B^n @)@ is defined using the Taylor coefficients @(@ x^{(k)} \in B^n @)@: @[@ X(t) = x^{(0)} * t^0 + x^{(1)} * t^1 + \cdots + x^{(q)} * t^q @]@ Note that for @(@ k = 0 , \ldots , q @)@, the k-th derivative of @(@ X(t) @)@ is related to the Taylor coefficients by the equation @[@ x^{(k)} = \frac{1}{k !} X^{(k)} (0) @]@

Y(t)
The function @(@ Y : B \rightarrow B^m @)@ is defined by @(@ Y(t) = F[ X(t) ] @)@. We use @(@ y^{(k)} \in B^m @)@ to denote the k-th order Taylor coefficient of @(@ Y(t) @)@; i.e., @[@ Y(t) = y^{(0)} * t^0 + y^{(1)} * t^1 + \cdots + y^{(q)} * t^q + o( t^q ) @]@ where @(@ o( t^q ) * t^{-q} \rightarrow 0 @)@ as @(@ t \rightarrow 0 @)@. Note that @(@ y^{(k)} @)@ is related to the k-th derivative of @(@ Y(t) @)@ by the equation @[@ y^{(k)} = \frac{1}{k !} Y^{(k)} (0) @]@

yq
The return value yq has prototype
     Vector yq
(see Vector below).

One Order
If xq.size() == n , the vector yq has size m . The q-th order Taylor coefficient for @(@ Y(t) @)@ is returned as
     yq @(@ = y^{(q)} @)@.

Multiple Orders
If xq.size() == n*(q+1) , the vector yq has size m*(q+1) . For @(@ k = 0 , \ldots , q @)@, for @(@ i = 0 , \ldots , m-1 @)@, the i-th component of the k-th order Taylor coefficient for @(@ Y(t) @)@ is returned as
     yq[ (q+1) * i + k ] @(@ = y_i^{(k)} @)@

Vector
The type Vector must be a SimpleVector class with elements of type Base . The routine CheckSimpleVector will generate an error message if this is not the case.

Zero Order
The case where @(@ q = 0 @)@ and xq.size() == n , corresponds to the zero order special case .

First Order
The case where @(@ q = 1 @)@ and xq.size() == n , corresponds to the first order special case .

Second Order
The case where @(@ q = 2 @)@ and xq.size() == n , corresponds to the second order special case .

Example
The file forward.cpp ( forward_order.cpp ) contains an example and test using one order (multiple orders). They return true if they succeed and false otherwise.

---

Input File: omh/forward/forward_order.omh