Prev

Next

Index-> contents reference index search external

Up-> CppAD Appendix glossary

glossary

Headings-> AD Function AD of Base AD Type Above Base Base Function Base Type Elementary Vector Operation ---..Atomic ---..Sequence ---..Dependent ---..Independent Parameter ---..Constant ---..Dynamic Row-major Representation Sparsity Pattern ---..Row and Column Index Vectors ---..Boolean Vector ---..Vector of Sets Tape ---..Active ---..Inactive ---..Independent Variable ---..Variables Taylor Coefficient Variable

@(@\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}} }@)@This is cppad-20221105 documentation. Here is a link to its current documentation . Glossary
AD Function
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.)

AD of Base
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.

AD Type Above Base
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> > > , ...

Base Function
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 .

Base Type
If x is an AD<Base> object, Base is referred to as the base type for x .

Elementary Vector
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. @]@

Operation

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 .

Parameter

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.

Row-major Representation
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 ] @]@

Sparsity Pattern
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 @)@.

Tape

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 .

Taylor Coefficient
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.

Variable
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