Prev

Next

Index-> contents reference index search external

Up-> CppAD ADFun record_adfun Independent

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

record_adfun-> Independent FunConstruct Dependent abort_recording seq_property

Independent-> independent.cpp

Headings-> Syntax Purpose Start Recording Stop Recording x abort_op_index VectorAD Parallel Mode 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}} }@)@Declare Independent Variables and Start Recording
Syntax
Independent(x)
Independent(x, abort_op_index)

Purpose
Start recording AD of Base operations with x as the independent variable vector. Once the operation sequence is completed, it must be transferred to a function object; see below.

Start Recording
An operation sequence recording is started by the commands
     Independent(x)
     Independent(x, abort_op_index)

Stop Recording
The recording is stopped, and the operation sequence is transferred to the AD function object f , using either the function constructor
     ADFun<Base> f(x, y)
or the dependent variable specifier
     f.Dependent(x, y)
The only other way to stop a recording is using abort_recording . Between when the recording is started and when it stopped, we refer to the elements of x , and the values that depend on the elements of x , as AD<Base> variables.

x
The vector x has prototype
     VectorAD &x
(see VectorAD below). The size of the vector x , must be greater than zero, and is the number of independent variables for this AD operation sequence.

abort_op_index
It specifies the operator index at which the execution is be aborted by calling the CppAD error handler . When this error handler leads to an assert, the user can inspect the call stack to see the source code corresponding to this operator index; see purpose . No abort will occur if abort_op_index is zero, of if NDEBUG is defined.

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

Parallel Mode
Each thread can have one, and only one, active recording. A call to Independent starts the recording for the current thread. The recording must be stopped by a corresponding call to
     ADFun<Base> f( x, y)
or
     f.Dependent( x, y)
or abort_recording preformed by the same thread; i.e., thread_alloc::thread_num must be the same.

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

---

Input File: cppad/core/independent.hpp