ADFun Function Properties

@(@\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 . ADFun Function Properties
Syntax

n = f.Domain()

m = f.Range()

p = f.Parameter(i)

s = f.size_var()

s = f.size_par()

s = f.size_op()

s = f.size_op_arg()

s = f.size_text()

s = f.size_VecAD()

s = f.size_random()

s = f.size_dyn_ind()

s = f.size_dyn_par()

s = f.size_dyn_arg()

s = f.size_op_seq()

See Also
function_name , size_order , capacity_order , number_skip .

Purpose
The operations above return properties of the AD of Base operation sequence stored in the ADFun object f . (If there is no operation sequence stored in f , size_var returns zero.)

f
The object f has prototype



    const ADFun<Base> f

(see ADFun<Base> constructor ).

Domain
The result n has prototype



    size_t n

and is the dimension of the domain space corresponding to f . This is equal to the size of the vector x in the call



    Independent(x)

that starting recording the operation sequence currently stored in f (see FunConstruct and Dependent ).

Range
The result m has prototype



    size_t m

and is the dimension of the range space corresponding to f . This is equal to the size of the vector y in syntax



    ADFun<Base> f(x, y)



    f.Dependent(y)

depending on which stored the operation sequence currently in f (see FunConstruct and Dependent ).

Parameter
The argument i has prototype



    size_t i

and @(@ 0 \leq i < m @)@. The result p has prototype



    bool p

It is true if the i-th component of range space for @(@ F @)@ corresponds to a parameter in the operation sequence. In this case, the i-th component of @(@ F @)@ is constant and @[@ \D{F_i}{x_j} (x) = 0 @]@ for @(@ j = 0 , \ldots , n-1 @)@ and all @(@ x \in \B{R}^n @)@.

size_var
The result s has prototype



    size_t s

and is the number of variables in the operation sequence plus the following: one for a phantom variable with tape address zero, one for each component of the range that is a parameter. The amount of work and memory necessary for computing function values and derivatives using f is roughly proportional to s . (The function call f.size_order() returns the number of Taylor coefficient orders, per variable,direction, currently stored in f .)

If there is no operation sequence stored in f , size_var returns zero (see default constructor ).

size_par
The result s has prototype



    size_t s

and is the number of parameters in the operation sequence (include a phantom parameter at index zero that is not used). Parameters differ from variables in that only values (and not derivatives) need to be stored for each parameter. These parameters are considered part of the operation sequence, as opposed to the Taylor coefficients which are considered extra data in the function object f . Note that one Base value is required for each parameter.

size_op
The result s has prototype



    size_t s

and is the number of operations in the operation sequence. Some operators, like comparison operators, do not correspond to a variable. Other operators, like the sine operator, correspond to two variables. Thus, this value will be different from size_var . Note that one enum value is required for each operator.

size_op_arg
The result s has prototype



    size_t s

and is the total number of operator arguments in the operation sequence. For example, Binary operators (e.g. addition) have two arguments. Note that one integer index is stored in the operation sequence for each argument. Also note that, as of 2013-10-20, there is an extra phantom argument with index 0 that is not used.

size_text
The result s has prototype



    size_t s

and is the total characters used in the PrintFor commands in this operation sequence.

size_VecAD
The result s has prototype



    size_t s

and is the number of VecAD vectors, plus the number of elements in the vectors. Only VecAD vectors that depend on the independent variables are stored in the operation sequence.

size_random
The result s has prototype



    size_t s

and is the amount of memory currently holding information for randomly access the operator sequence. Random access is only used by the following routines subgraph_sparsity , subgraph_reverse , and optimize . The optimize routine replaces the operation sequence, so the extra memory is automatically dropped. The subgraph routines hold onto this information so that it does not need to be recalculated between calls. The routine clear_subgraph will free this extra memory.

size_dyn_ind
The result s has prototype



    size_t s

and is the number of independent dynamic parameters in the operation sequence. This is the size of the dynamic parameter in the corresponding call to Independent.

size_dyn_par
The result s has prototype



    size_t s

and is the number of dynamic parameters. The dynamic parameters depend on the value of the independent dynamic parameters but not on the value of the variables. This includes the independent dynamic parameters.

size_dyn_arg
The result s has prototype



    size_t s

and is the total number of dynamic parameter operator arguments in the operation sequence. For example, Binary operators (e.g. addition) have two arguments. Note that one integer index is stored in the operation sequence for each argument.

size_op_seq
The result s has prototype



    size_t s

and is the amount of memory required to store the operation sequence (not counting a small amount of memory required for every operation sequence). For the current version of CppAD, this is given by



    s = f.size_op()      * sizeof(CPPAD_VEC_ENUM_TYPE)

        + f.size_op_arg()  * sizeof(tape_addr_type)

        + f.size_par()     * sizeof(Base)

        + f.size_par()     * sizeof(bool)

        + f.size_dyn_par() * sizeof(CPPAD_VEC_ENUM_TYPE)

        + f.size_dyn_par() * sizeof(tape_addr_type)

        + f.size_dyn_arg() * sizeof(tape_addr_type)

        + f.size_text()    * sizeof(char)

        + f.size_VecAD()   * sizeof(tape_addr_type)

see tape_addr_type . Note that this is the minimal amount of memory that can hold the information corresponding to an operation sequence. The actual amount of memory allocated (inuse ) for the operations sequence may be larger. Also note that CPPAD_VEC_ENUM_TYPE is not part of the CppAD API and may change.

Example
The file fun_property.cpp contains an example and test of these operations.

Input File: include/cppad/core/fun_property.omh