Prev | Next | glossary |

@(@\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}} }@)@

Given an ADFun object

*f*

there is a corresponding
AD of
*Base*

operation sequence
.
This operation sequence
defines a function
@(@
F : \B{R}^n \rightarrow \B{R}^m
@)@
where @(@
\B{R}
@)@ is the space corresponding to objects of type
*Base*

(usually the real numbers),
*n*

is the size of the domain
space, and
*m*

is the size of the range
space.
We refer to @(@
F
@)@ as the AD function corresponding to
the operation sequence stored in the object
*f*

.
(See the FunCheck discussion
for
possible differences between @(@
F(x)
@)@ and the algorithm that defined
the operation sequence.)
An object is called an AD of

*Base*

object its type is
either
`AD<`*Base*>

(see the default and copy constructors
or
`VecAD<`*Base*>::reference

(see VecAD
)
for some
*Base*

type.
If

*Base*

is a type,
an AD type above
*Base*

is the following sequence of types:

AD<*Base*> *,* AD< AD<*Base*> > *,* AD< AD< AD<*Base*> > > *,* *...*

A function @(@ f : \B{R} \rightarrow \B{R} @)@ is referred to as a

*Base*

function,
if
*Base*

is a C++ type that represent elements of
the domain and range space of
*f*

.
If

*x*

is an
`AD<`*Base*>

object,
*Base*

is referred to as the base type for
*x*

.
The

*j*

-th elementary vector @(@
e^j \in \B{R}^m
@)@ is defined by
@[@
e_i^j = \left\{ \begin{array}{ll}
1 & {\rm if} \; i = j \\
0 & {\rm otherwise}
\end{array} \right.
@]@
Atomic

An atomic

*Type*

operation is an operation that
has a
*Type*

result and is not made up of other
more basic operations.
Sequence

A sequence of atomic

*Type*

operations
is called a
*Type*

operation sequence.
A sequence of atomic AD of Base
operations
is referred to as an AD of
*Base*

operation sequence.
The abbreviated notation operation sequence is often used
when it is not necessary to specify the type.
Dependent

Suppose that

*x*

and
*y*

are
*Type*

objects and
the result of

*x* < *y*

has type `bool`

(where
*Type*

is not the same as `bool`

).
If one executes the following code

if( *x* < *y* )

*y* = cos(*x*);

else

*y* = sin(*x*);

the choice above depends on the value of
*x*

and
*y*

and the two choices result in a different
*Type*

operation sequence.
In this case, we say that the
*Type*

operation sequence depends
on
*x*

and
*y*

.
Independent

Suppose that

*i*

and
*n*

are `size_t`

objects,
and
*x*[*i*]

,
*y*

are
*Type*

objects,
where
*Type*

is different from `size_t`

.
The
*Type*

sequence of operations corresponding to

*y* = *Type*(0);

for(*i* = 0; *i* < *n*; *i*++)

*y* += *x*[*i*];

does not depend on the value of
*x*

or
*y*

.
In this case, we say that the
*Type*

operation sequence
is independent of
*y*

and the elements of
*x*

.
Constant

An

`AD<`*Base*>

object
*u*

is a constant parameter if
its value does not depend on the value of
the Independent
variable vector
or the dynamic
parameter vector
for an active tape
.
If
*u*

is a constant parameter,
Constant(u)
returns true,
Parameter(u)
returns true,
Dynamic(u)
returns false, and
Variable(u)
returns false.
Dynamic

An

`AD<`*Base*>

object
*u*

is a dynamic parameter if
its value does not depend on the value of
the Independent
variable vector, but its value does depend
on the dynamic
parameter vector,
for an active tape
.
If
*u*

is a dynamic parameter, the function
Dynamic(u)
returns true
Parameter(u)
returns true,
Constant(u)
returns false, and
Variable(u)
returns false.
A SimpleVector

*v*

is a row-major representation of a matrix
@(@
M \in \B{R}^{m \times n}
@)@ if
*v*.size() == *m* * *n*

and
for @(@
i = 0 , \ldots , m-1
@)@, @(@
j = 0 , \ldots , n-1
@)@
@[@
M_{i,j} = v[ i \times n + j ]
@]@
Suppose that @(@ A \in \B{R}^{m \times n} @)@ is a sparse matrix. CppAD has several ways to specify the elements of @(@ A @)@ that are possible non-zero.

Row and Column Index Vectors

A pair of non-negative integer vectors @(@ r @)@, @(@ c @)@ are a sparsity pattern for @(@ A @)@ if for every non-zero element @(@ A_{i,j} @)@, there is a @(@ k @)@ such that @(@ i = r_k @)@ and @(@ j = c_k @)@. Furthermore, for every @(@ \ell \neq k @)@, either @(@ r_\ell \neq r_k @)@ or @(@ c_\ell \neq c_k @)@.

Boolean Vector

A boolean vector @(@ b @)@, of length @(@ m \times n @)@, is a sparsity pattern for @(@ A @)@ if for every non-zero element @(@ A_{i,j} @)@, @(@ b_{i \times n + j} @)@ is true.

Vector of Sets

A vector of sets @(@ s @)@ of positive integers, of length @(@ m @)@, is a sparsity pattern for @(@ A @)@ if for every non-zero element @(@ A_{i,j} @)@, @(@ j \in s_i @)@.

Active

A new tape is created and becomes active after each call of the form (see Independent )

Independent(*x*)

All operations that depend on the elements of
*x*

are
recorded on this active tape.
Inactive

The operation sequence stored in a tape can be transferred to a function object using the syntax

ADFun<*Base*> *f*( *x*, *y*)

*f*.Dependent( *x*, *y*)

see FunConstruct
.
After such a transfer, the tape becomes inactive.
The tape becomes inactive, without storing the operation sequence,
after a call to abort_recording
.
Independent Variable

While the tape is active, we refer to the elements of

*x*

as the independent variables for the tape.
When the tape becomes inactive,
the corresponding objects become
constants
.
Variables

While the tape is active, we use the term variables for any scalar whose value depends on the independent variables for the tape. When the tape becomes inactive, the corresponding objects become constants .

Suppose @(@ X : \B{R} \rightarrow \B{R}^n @)@ is a is @(@ p @)@ times continuously differentiable function in some neighborhood of zero. For @(@ k = 0 , \ldots , p @)@, we use the column vector @(@ x^{(k)} \in \B{R}^n @)@ for the

*k*

-th order
Taylor coefficient corresponding to @(@
X
@)@
which is defined by
@[@
x^{(k)} = \frac{1}{k !} \Dpow{k}{t} X(0)
@]@
It follows that
@[@
X(t) = x^{(0)} + x^{(1)} t + \cdots + x^{(p)} t^p + R(t)
@]@
where the remainder @(@
R(t)
@)@ divided by @(@
t^p
@)@
converges to zero and @(@
t
@)@ goes to zero.
An

`AD<`*Base*>

object
*u*

is a variable if
its value depends on an independent variable vector for
a currently active tape
.
If
*u*

is a variable,
Variable(u)
returns true,
Constant(u)
returns false,
Dynamic(u)
returns false, and
Parameter(u)
returns false.
For example,
directly after the code sequence

Independent(*x*);

AD<double> *u* = *x*[0];

the
`AD<double>`

object
*u*

is currently a variable.
Directly after the code sequence

Independent(*x*);

AD<double> *u* = *x*[0];

*u* = 5;

*u*

is currently a
constant
parameter,
not a dynamic parameter or a variable.

Note that we often drop the word currently and
just refer to an
`AD<`*Base*>

object as a variable
or parameter.
Input File: omh/appendix/glossary.omh